{
status: Hyperlink.Marked<
Hyperlink.Method<
undefined,
Schema.Struct<{
readonly supervising: Schema.Boolean
readonly armed: Schema.Boolean
readonly activeInstances: Schema.Number
readonly nextTriggerRun: Schema.optionalKey<Schema.DateTimeUtc>
readonly nextScheduleTransition: Schema.optionalKey<Schema.DateTimeUtc>
readonly nextPollCadence: Schema.optionalKey<Schema.Duration>
readonly runsStarted: Schema.Number
readonly runsSucceeded: Schema.Number
readonly runsFailed: Schema.Number
readonly lastRunStartedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly lastRunDurationMillis: Schema.optionalKey<Schema.Number>
}>,
Schema.Never,
true,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>,
{ readonly _tag: "ref" }
>
start: Hyperlink.Method<
undefined,
Schema.Void,
Schema.Never,
false,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
stop: Hyperlink.Method<
undefined,
Schema.Void,
Schema.Never,
false,
Hyperlink.MethodAnnotations & {
description: string
destructive: true
},
Hyperlink.Derive
>
wake: Hyperlink.Method<
undefined,
Schema.Void,
Schema.Never,
false,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
resetCadence: Hyperlink.Method<
undefined,
Schema.Void,
Schema.Never,
false,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
}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.
Source src/Process.ts:160429 lines
export const 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
schedule
.
processControlSpec = {
// ── live current state — one SubscriptionRef-backed source of truth ──
// `status` is the whole snapshot; `status.get` reads it once, `status.changes` streams every
// change (uniform local + remote), mirroring the queue's `status` ref.
status: anystatus: import HyperlinkHyperlink.ref(const processStatus: Schema.Struct<{
readonly supervising: Schema.Boolean;
readonly armed: Schema.Boolean;
readonly activeInstances: Schema.Number;
readonly nextTriggerRun: Schema.optionalKey<Schema.DateTimeUtc>;
readonly nextScheduleTransition: Schema.optionalKey<Schema.DateTimeUtc>;
readonly nextPollCadence: Schema.optionalKey<Schema.Duration>;
readonly runsStarted: Schema.Number;
readonly runsSucceeded: Schema.Number;
readonly runsFailed: Schema.Number;
readonly lastRunStartedAt: Schema.optionalKey<...>;
readonly lastRunDurationMillis: Schema.optionalKey<...>;
}>
const processStatus: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly supervising: Schema.Boolean; readonly armed: Schema.Boolean; readonly activeInstances: Schema.Number; readonly nextTriggerRun: Schema.optionalKey<Schema.DateTimeUtc>; readonly nextScheduleTransition: Schema.optional…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly supervising: boolean; readonly armed: boolean; readonly activeInstances: number; readonly runsStarted: number; readonly runsSucceeded: number; readonly runsFailed: number; readonly nextTri…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly supervising: boolean; readonly armed: boolean; readonly activeInstances: number; readonly runsStarted: number; readonly runsSucceeded: number; readonly runsFailed: number; readonly nextTrigge…;
check: (checks_0: Check<{ readonly supervising: boolean; readonly armed: boolean; readonly activeInstances: number; readonly runsStarted: number; readonly runsSucceeded: number; readonly runsFailed: number; readonly nextTriggerRun?: DateTime.Utc …;
rebuild: (ast: Objects) => Schema.Struct<{ readonly supervising: Schema.Boolean; readonly armed: Schema.Boolean; readonly activeInstances: Schema.Number; readonly nextTriggerRun: Schema.optionalKey<Schema.DateTimeUtc>; readonly nextScheduleTransiti…;
make: (input: { readonly supervising: boolean; readonly armed: boolean; readonly activeInstances: number; readonly runsStarted: number; readonly runsSucceeded: number; readonly runsFailed: number; readonly nextTriggerRun?: DateTime.Utc | undefin…;
makeOption: (input: { readonly supervising: boolean; readonly armed: boolean; readonly activeInstances: number; readonly runsStarted: number; readonly runsSucceeded: number; readonly runsFailed: number; readonly nextTriggerRun?: DateTime.Utc | undefin…;
makeEffect: (input: { readonly supervising: boolean; readonly armed: boolean; readonly activeInstances: number; readonly runsStarted: number; readonly runsSucceeded: number; readonly runsFailed: number; readonly nextTriggerRun?: DateTime.Utc | undefin…;
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; <…;
}
The current-state snapshot of a managed process — the wire form of the engine's
ProcessSnapshot
(plus supervising). The element of the reactive status field:
status.get reads it once, status.changes streams it.
processStatus).annotate({
description: stringdescription:
"Live current-state snapshot: supervising, armed, active instances, next trigger/transition, " +
"poll cadence, and cumulative run metrics.",
}),
// ── lifecycle commands ──
start: anystart: import HyperlinkHyperlink.effect(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).annotate({
description: stringdescription: "Begin supervising — fork the trigger driver (idempotent).",
}),
stop: anystop: import HyperlinkHyperlink.effect(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).annotate({
description: stringdescription: "Stop supervising — interrupt the driver and any active run instances.",
destructive: booleandestructive: true,
}),
// ── cadence commands (no-ops while not supervising / no polling layer) ──
wake: anywake: import HyperlinkHyperlink.effect(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).annotate({
description: stringdescription:
"End the current polling wait immediately — the next tick runs now; cadence unchanged.",
}),
resetCadence: anyresetCadence: import HyperlinkHyperlink.effect(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).annotate({
description: stringdescription:
"Reset the cadence preset to its initial state (backoff → initial, accelerating → slow) and wake.",
}),
};
Referenced by 2 symbols