ProcessInstanceSpec<A, E>Per-tag process spec — control surface, live events, plus stamped run success/error on the wire.
export type type ProcessInstanceSpec<
A extends Schema.Top = Schema.Void,
E extends Schema.Top = Schema.Never
> = {
status: any
start: any
stop: any
wake: any
resetCadence: any
} & {
readonly events: ReturnType<
typeof buildProcessSpec<A, E>
>["events"]
readonly run: Hyperlink.Method<undefined, A, E>
} & (A extends Schema.Void
? Record<string, never>
: ResultGroupSpec<A>)
Per-tag process spec — control surface, live events, plus stamped run success/error on the wire.
ProcessInstanceSpec<
function (type parameter) A in type ProcessInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>A extends import SchemaSchema.Top = typeof import SchemaSchema.const Void: Schema.Voidconst Void: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<void, readonly []>) => Schema.Void;
annotateKey: (annotations: Schema.Annotations.Key<void>) => Schema.Void;
check: (checks_0: Check<void>, ...checks: Array<Check<void>>) => Schema.Void;
rebuild: (ast: Void) => Schema.Void;
make: (input: void, options?: Schema.MakeOptions) => void;
makeOption: (input: void, options?: Schema.MakeOptions) => Option.Option<void>;
makeEffect: (input: void, options?: Schema.MakeOptions) => Effect.Effect<void, Schema.SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Type-level representation of
Void
.
Schema for a TypeScript void return value.
When to use
Use when you need to model the return value of a function, RPC, or endpoint
whose result is intentionally ignored.
Details
Runtime parsing accepts any present value and discards it, producing
undefined. The public decoded and encoded TypeScript representation remains
void, so typed construction, decoding, and encoding APIs are still modeled
as void.
Void,
function (type parameter) E in type ProcessInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>E extends import SchemaSchema.Top = typeof import SchemaSchema.const Never: Schema.Neverconst Never: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<never, readonly []>) => Schema.Never;
annotateKey: (annotations: Schema.Annotations.Key<never>) => Schema.Never;
check: (checks_0: Check<never>, ...checks: Array<Check<never>>) => Schema.Never;
rebuild: (ast: Never) => Schema.Never;
make: (input: never, options?: Schema.MakeOptions) => never;
makeOption: (input: never, options?: Schema.MakeOptions) => Option.Option<never>;
makeEffect: (input: never, options?: Schema.MakeOptions) => Effect.Effect<never, Schema.SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Type-level representation of
Never
.
Schema for the never type. Always fails validation — no value satisfies it.
Never,
> = typeof const processControlSpec: {
status: any
start: any
stop: any
wake: any
resetCadence: any
}
The base process control + observation contract — shared by every process. Mirrors the
observable/controllable seams the engine supervisor exposes (
ProcessSnapshot
- lifecycle).
A base process has no schedule mutation verbs: arm/disarm is done by mutating a schedule, so
those verbs appear only when a process
owns an inline schedule
.
processControlSpec & {
readonly events: ReturnType<
typeof buildProcessSpec<A, E>
>["events"]
type ReturnType<
T extends (...args: any) => any
> = T extends (...args: any) => infer R ? R : any
Obtain the return type of a function type
ReturnType<typeof const buildProcessSpec: <
A extends Schema.Top = Schema.Void,
E extends Schema.Top = Schema.Never
>(wire?: {
readonly success?: A
readonly error?: E
}) => {
events: any
run: any
status: any
start: any
stop: any
wake: any
resetCadence: any
}
Build a process instance spec — control surface, live
events
stream, and a typed
manual
run
RPC. Event element schema matches the durable store union
(
processExecutionEventFor
with the tag's optional success / error).
buildProcessSpec<function (type parameter) A in type ProcessInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>A, function (type parameter) E in type ProcessInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>E>>["events"];
readonly run: Hyperlink.Method<undefined, A, E>run: import HyperlinkHyperlink.type Hyperlink.Method = /*unresolved*/ anyMethod<undefined, function (type parameter) A in type ProcessInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>A, function (type parameter) E in type ProcessInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>E>;
} & (function (type parameter) A in type ProcessInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>A extends typeof import SchemaSchema.const Void: Schema.Voidconst Void: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<void, readonly []>) => Schema.Void;
annotateKey: (annotations: Schema.Annotations.Key<void>) => Schema.Void;
check: (checks_0: Check<void>, ...checks: Array<Check<void>>) => Schema.Void;
rebuild: (ast: Void) => Schema.Void;
make: (input: void, options?: Schema.MakeOptions) => void;
makeOption: (input: void, options?: Schema.MakeOptions) => Option.Option<void>;
makeEffect: (input: void, options?: Schema.MakeOptions) => Effect.Effect<void, Schema.SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Type-level representation of
Void
.
Schema for a TypeScript void return value.
When to use
Use when you need to model the return value of a function, RPC, or endpoint
whose result is intentionally ignored.
Details
Runtime parsing accepts any present value and discards it, producing
undefined. The public decoded and encoded TypeScript representation remains
void, so typed construction, decoding, and encoding APIs are still modeled
as void.
Void ? type Record<K extends keyof any, T> = {
[P in K]: T
}
Construct a type with a set of properties K of type T
Record<string, never> : type ResultGroupSpec<
A extends Schema.Top
> = {
readonly result: ResultField<A>
}
The result field as a
Spec
fragment (what
result
grafts).
ResultGroupSpec<function (type parameter) A in type ProcessInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>A>);