<
A extends Schema.Top = Schema.Void,
E extends Schema.Top = Schema.Never
>(wire?: {
readonly success?: A
readonly error?: E
}): {
events: Hyperlink.Method<
undefined,
Schema.Union<
readonly [
Schema.TaggedStruct<
"Started",
{
readonly key: Schema.String
readonly scheduleKey: Schema.NullOr<Schema.String>
readonly startedAt: Schema.Number
readonly isStartupRun: Schema.Boolean
}
>,
Schema.TaggedStruct<
"Completed",
| {
readonly key: Schema.String
readonly scheduleKey: Schema.NullOr<Schema.String>
readonly startedAt: Schema.Number
readonly completedAt: Schema.Number
readonly durationMs: Schema.Number
readonly isStartupRun: Schema.Boolean
}
| {
success: Schema.optional<Schema.Top>
key: Schema.String
scheduleKey: Schema.NullOr<Schema.String>
startedAt: Schema.Number
completedAt: Schema.Number
durationMs: Schema.Number
isStartupRun: Schema.Boolean
}
>,
Schema.TaggedStruct<
"Failed",
{
error: Schema.Top | Schema.String
key: Schema.String
scheduleKey: Schema.NullOr<Schema.String>
startedAt: Schema.Number
completedAt: Schema.Number
durationMs: Schema.Number
isStartupRun: Schema.Boolean
}
>,
Schema.TaggedStruct<
"Interrupted",
{
readonly key: Schema.String
readonly scheduleKey: Schema.NullOr<Schema.String>
readonly startedAt: Schema.Number
readonly completedAt: Schema.Number
readonly durationMs: Schema.Number
readonly isStartupRun: Schema.Boolean
}
>
]
>,
Schema.Never,
true,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
run:
| Hyperlink.Method<
undefined,
Schema.Void | A,
Schema.Never,
false,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
| Hyperlink.Method<
undefined,
Schema.Void | A,
E,
false,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
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
>
}Build a daemon instance spec — control surface, live events stream, and a typed
manual run RPC. Event element schema matches the durable store union
(daemonExecutionEventFor with the tag's optional success / error).
Source src/Daemon.ts:163925 lines
export const const buildDaemonSpec: <A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>(wire?: {
readonly success?: A;
readonly error?: E;
}) => {
events: Hyperlink.Method<undefined, Schema.Union<readonly [Schema.TaggedStruct<"Started", {
readonly key: Schema.String;
readonly scheduleKey: Schema.NullOr<Schema.String>;
readonly startedAt: Schema.Number;
readonly isStartupRun: Schema.Boolean;
}>, Schema.TaggedStruct<"Completed", {
readonly key: Schema.String;
readonly scheduleKey: Schema.NullOr<Schema.String>;
readonly startedAt: Schema.Number;
readonly completedAt: Schema.Number;
readonly durationMs: Schema.Number;
readonly isStartupRun: Schema.Boolean;
} | {
...;
}>, Schema.TaggedStruct<...>, Schema.TaggedStruct<...>]>, Schema.Never, true, Hyperlink.MethodAnnotations & {
...;
}, Hyperlink.Derive>;
... 5 more ...;
resetCadence: Hyperlink.Method<...>;
}
Build a daemon instance spec — control surface, live
events
stream, and a typed
manual
run
RPC. Event element schema matches the durable store union
(
daemonExecutionEventFor
with the tag's optional success / error).
buildDaemonSpec = <
function (type parameter) A in <A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>(wire?: {
readonly success?: A;
readonly error?: E;
}): {
events: Hyperlink.Method<undefined, Schema.Union<readonly [Schema.TaggedStruct<"Started", {
readonly key: Schema.String;
readonly scheduleKey: Schema.NullOr<...>;
readonly startedAt: Schema.Number;
readonly isStartupRun: Schema.Boolean;
}>, Schema.TaggedStruct<...>, Schema.TaggedStruct<...>, Schema.TaggedStruct<...>]>, Schema.Never, true, Hyperlink.MethodAnnotations & {
...;
}, Hyperlink.Derive>;
... 5 more ...;
resetCadence: Hyperlink.Method<...>;
}
import SchemaSchema.Top = typeof import SchemaSchema.const Void: 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?: MakeOptions) => void;
makeOption: (input: void, options?: MakeOptions) => Option_.Option<void>;
makeEffect: (input: void, options?: MakeOptions) => Effect.Effect<void, 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 <A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>(wire?: {
readonly success?: A;
readonly error?: E;
}): {
events: Hyperlink.Method<undefined, Schema.Union<readonly [Schema.TaggedStruct<"Started", {
readonly key: Schema.String;
readonly scheduleKey: Schema.NullOr<...>;
readonly startedAt: Schema.Number;
readonly isStartupRun: Schema.Boolean;
}>, Schema.TaggedStruct<...>, Schema.TaggedStruct<...>, Schema.TaggedStruct<...>]>, Schema.Never, true, Hyperlink.MethodAnnotations & {
...;
}, Hyperlink.Derive>;
... 5 more ...;
resetCadence: Hyperlink.Method<...>;
}
import SchemaSchema.Top = typeof import SchemaSchema.const Never: 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?: MakeOptions) => never;
makeOption: (input: never, options?: MakeOptions) => Option_.Option<never>;
makeEffect: (input: never, options?: MakeOptions) => Effect.Effect<never, 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,
>(wire: | {
readonly success?: A
readonly error?: E
}
| undefined
success?: A | undefinedsuccess?: function (type parameter) A in <A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>(wire?: {
readonly success?: A;
readonly error?: E;
}): {
events: Hyperlink.Method<undefined, Schema.Union<readonly [Schema.TaggedStruct<"Started", {
readonly key: Schema.String;
readonly scheduleKey: Schema.NullOr<...>;
readonly startedAt: Schema.Number;
readonly isStartupRun: Schema.Boolean;
}>, Schema.TaggedStruct<...>, Schema.TaggedStruct<...>, Schema.TaggedStruct<...>]>, Schema.Never, true, Hyperlink.MethodAnnotations & {
...;
}, Hyperlink.Derive>;
... 5 more ...;
resetCadence: Hyperlink.Method<...>;
}
error?: E | undefinederror?: function (type parameter) E in <A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never>(wire?: {
readonly success?: A;
readonly error?: E;
}): {
events: Hyperlink.Method<undefined, Schema.Union<readonly [Schema.TaggedStruct<"Started", {
readonly key: Schema.String;
readonly scheduleKey: Schema.NullOr<...>;
readonly startedAt: Schema.Number;
readonly isStartupRun: Schema.Boolean;
}>, Schema.TaggedStruct<...>, Schema.TaggedStruct<...>, Schema.TaggedStruct<...>]>, Schema.Never, true, Hyperlink.MethodAnnotations & {
...;
}, Hyperlink.Derive>;
... 5 more ...;
resetCadence: Hyperlink.Method<...>;
}
const eventSchema: Schema.Union<
readonly [
Schema.TaggedStruct<
"Started",
{
readonly key: Schema.String
readonly scheduleKey: Schema.NullOr<Schema.String>
readonly startedAt: Schema.Number
readonly isStartupRun: Schema.Boolean
}
>,
Schema.TaggedStruct<
"Completed",
| {
readonly key: Schema.String
readonly scheduleKey: Schema.NullOr<Schema.String>
readonly startedAt: Schema.Number
readonly completedAt: Schema.Number
readonly durationMs: Schema.Number
readonly isStartupRun: Schema.Boolean
}
| {
success: Schema.optional<Schema.Top>
key: Schema.String
scheduleKey: Schema.NullOr<Schema.String>
startedAt: Schema.Number
completedAt: Schema.Number
durationMs: Schema.Number
isStartupRun: Schema.Boolean
}
>,
Schema.TaggedStruct<
"Failed",
{
error: Schema.Top | Schema.String
key: Schema.String
scheduleKey: Schema.NullOr<Schema.String>
startedAt: Schema.Number
completedAt: Schema.Number
durationMs: Schema.Number
isStartupRun: Schema.Boolean
}
>,
Schema.TaggedStruct<
"Interrupted",
{
readonly key: Schema.String
readonly scheduleKey: Schema.NullOr<Schema.String>
readonly startedAt: Schema.Number
readonly completedAt: Schema.Number
readonly durationMs: Schema.Number
readonly isStartupRun: Schema.Boolean
}
>
]
>
const eventSchema: {
Type: { [K in keyof Members]: Members[K]["Type"]; }[number];
Encoded: { [K in keyof Members]: Members[K]["Encoded"]; }[number];
DecodingServices: { [K in keyof Members]: Members[K]["DecodingServices"]; }[number];
EncodingServices: { [K in keyof Members]: Members[K]["EncodingServices"]; }[number];
Iso: { [K in keyof Members]: Members[K]["Iso"]; }[number];
members: Members;
mapMembers: (f: (members: readonly [Schema.TaggedStruct<'Started', { readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly isStartupRun: Schema.Boolean }>, Schema.TaggedStruct<'Com…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'Started'>; readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly isStart…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'Started'>; readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly isStartupR…;
check: (checks_0: Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'Started'>; readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly isStartupRun: Schema.Boolean }…;
rebuild: (ast: Union<Objects>) => Schema.Union<readonly [Schema.TaggedStruct<'Started', { readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly isStartupRun: Schema.Boolean }>, …;
make: (input: { readonly key: string; readonly scheduleKey: string | null; readonly startedAt: number; readonly isStartupRun: boolean; readonly _tag?: 'Started' | undefined } | { readonly key: string; readonly scheduleKey: string | null; readonl…;
makeOption: (input: { readonly key: string; readonly scheduleKey: string | null; readonly startedAt: number; readonly isStartupRun: boolean; readonly _tag?: 'Started' | undefined } | { readonly key: string; readonly scheduleKey: string | null; readonl…;
makeEffect: (input: { readonly key: string; readonly scheduleKey: string | null; readonly startedAt: number; readonly isStartupRun: boolean; readonly _tag?: 'Started' | undefined } | { readonly key: string; readonly scheduleKey: string | null; readonl…;
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; <…;
}
function daemonStoreEventSchema(success?: Schema.Top, error?: Schema.Top): Schema.Union<readonly [Schema.TaggedStruct<'Started', { readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly isStartupRun: Schema.Boolean }>, Schema.TaggedStruct<'Completed', { readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly completedAt: Schema.Number; readonly durationMs: Schema.Number; readonly isStartupRun: Schema.Boolean } | { success: Schema.optional<Schema.Top>; key: Schema.String; scheduleKey: Schema.NullOr<Schema.String>; startedAt: Schema.Number; completedAt: Schema.Number; durationMs: Schema.Number; isStartupRun: Schema.Boolean }>, Schema.TaggedStruct<'Failed', { error: Schema.Top | Schema.String; key: Schema.String; scheduleKey: Schema.NullOr<Schema.String>; startedAt: Schema.Number; completedAt: Schema.Number; durationMs: Schema.Number; isStartupRun: Schema.Boolean }>, Schema.TaggedStruct<'Interrupted', { readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly completedAt: Schema.Number; readonly durationMs: Schema.Number; readonly isStartupRun: Schema.Boolean }>]>Event union schema for a daemon store contract.
daemonStoreEventSchema(wire: | {
readonly success?: A
readonly error?: E
}
| undefined
success?: A | undefinedsuccess, wire: | {
readonly success?: A
readonly error?: E
}
| undefined
error?: E | undefinederror);
return {
...const daemonControlSpec: {
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<...>;
readonly lastRunDurationMillis: Schema.optionalKey<...>;
}>, Schema.Never, true, Hyperlink.MethodAnnotations & {
...;
}, Hyperlink.Derive>, {
...;
}>;
start: Hyperlink.Method<...>;
stop: Hyperlink.Method<...>;
wake: Hyperlink.Method<...>;
resetCadence: Hyperlink.Method<...>;
}
The base daemon control + observation contract — shared by every daemon. Mirrors the
observable/controllable seams the engine supervisor exposes (
DaemonSnapshot
- lifecycle).
A base daemon has no schedule mutation verbs: arm/disarm is done by mutating a schedule, so
those verbs appear only when a daemon
owns an inline schedule
.
daemonControlSpec,
events: Hyperlink.Method<
undefined,
Schema.Union<
readonly [
Schema.TaggedStruct<
"Started",
{
readonly key: Schema.String
readonly scheduleKey: Schema.NullOr<Schema.String>
readonly startedAt: Schema.Number
readonly isStartupRun: Schema.Boolean
}
>,
Schema.TaggedStruct<
"Completed",
| {
readonly key: Schema.String
readonly scheduleKey: Schema.NullOr<Schema.String>
readonly startedAt: Schema.Number
readonly completedAt: Schema.Number
readonly durationMs: Schema.Number
readonly isStartupRun: Schema.Boolean
}
| {
success: Schema.optional<Schema.Top>
key: Schema.String
scheduleKey: Schema.NullOr<Schema.String>
startedAt: Schema.Number
completedAt: Schema.Number
durationMs: Schema.Number
isStartupRun: Schema.Boolean
}
>,
Schema.TaggedStruct<
"Failed",
{
error: Schema.Top | Schema.String
key: Schema.String
scheduleKey: Schema.NullOr<Schema.String>
startedAt: Schema.Number
completedAt: Schema.Number
durationMs: Schema.Number
isStartupRun: Schema.Boolean
}
>,
Schema.TaggedStruct<
"Interrupted",
{
readonly key: Schema.String
readonly scheduleKey: Schema.NullOr<Schema.String>
readonly startedAt: Schema.Number
readonly completedAt: Schema.Number
readonly durationMs: Schema.Number
readonly isStartupRun: Schema.Boolean
}
>
]
>,
Schema.Never,
true,
Hyperlink.MethodAnnotations & {
description: string
},
Hyperlink.Derive
>
(property) events: {
kind: MethodKind;
payload: P;
success: Su;
error: E;
stream: Str;
annotations: Ann;
annotate: <A extends MethodAnnotations>(annotations: A) => Method<P, Su, E, Str, Ann & A, Client>;
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; <…;
}
import HyperlinkHyperlink.function stream<Schema.Union<readonly [Schema.TaggedStruct<"Started", {
readonly key: Schema.String;
readonly scheduleKey: Schema.NullOr<Schema.String>;
readonly startedAt: Schema.Number;
readonly isStartupRun: Schema.Boolean;
}>, Schema.TaggedStruct<"Completed", {
readonly key: Schema.String;
readonly scheduleKey: Schema.NullOr<Schema.String>;
readonly startedAt: Schema.Number;
readonly completedAt: Schema.Number;
readonly durationMs: Schema.Number;
readonly isStartupRun: Schema.Boolean;
} | {
...;
}>, Schema.TaggedStruct<...>, Schema.TaggedStruct<...>]>>(success: Schema.Union<...>): Hyperlink.Method<...> (+5 overloads)
Define a stream (a live, idempotent push source) whose elements are success. The
service member surfaces as a Stream<Success, Error> (a property, or (payload) => Stream
when a payload is declared) rather than an Effect — drive dashboard atoms, a CLI
--watch, or a TUI from it. Conventionally named changes when it carries a HyperService's
whole observable state (a snapshot stream); back it with a SubscriptionRef's .changes.
Counts as a query for tools (an idempotent read). success is the element schema and
error (if any) is the stream error schema; both must be encodable (they cross RPC).
payload is a single schema or struct fields — same as Effect's Rpc.make.
changes: Hyperlink.stream(QueueSnapshot).annotate({ description: "Live queue state." }),
tail: Hyperlink.stream(LogLine, { payload: Schema.Struct({ since: Schema.Number }) }),
stream(const eventSchema: Schema.Union<
readonly [
Schema.TaggedStruct<
"Started",
{
readonly key: Schema.String
readonly scheduleKey: Schema.NullOr<Schema.String>
readonly startedAt: Schema.Number
readonly isStartupRun: Schema.Boolean
}
>,
Schema.TaggedStruct<
"Completed",
| {
readonly key: Schema.String
readonly scheduleKey: Schema.NullOr<Schema.String>
readonly startedAt: Schema.Number
readonly completedAt: Schema.Number
readonly durationMs: Schema.Number
readonly isStartupRun: Schema.Boolean
}
| {
success: Schema.optional<Schema.Top>
key: Schema.String
scheduleKey: Schema.NullOr<Schema.String>
startedAt: Schema.Number
completedAt: Schema.Number
durationMs: Schema.Number
isStartupRun: Schema.Boolean
}
>,
Schema.TaggedStruct<
"Failed",
{
error: Schema.Top | Schema.String
key: Schema.String
scheduleKey: Schema.NullOr<Schema.String>
startedAt: Schema.Number
completedAt: Schema.Number
durationMs: Schema.Number
isStartupRun: Schema.Boolean
}
>,
Schema.TaggedStruct<
"Interrupted",
{
readonly key: Schema.String
readonly scheduleKey: Schema.NullOr<Schema.String>
readonly startedAt: Schema.Number
readonly completedAt: Schema.Number
readonly durationMs: Schema.Number
readonly isStartupRun: Schema.Boolean
}
>
]
>
const eventSchema: {
Type: { [K in keyof Members]: Members[K]["Type"]; }[number];
Encoded: { [K in keyof Members]: Members[K]["Encoded"]; }[number];
DecodingServices: { [K in keyof Members]: Members[K]["DecodingServices"]; }[number];
EncodingServices: { [K in keyof Members]: Members[K]["EncodingServices"]; }[number];
Iso: { [K in keyof Members]: Members[K]["Iso"]; }[number];
members: Members;
mapMembers: (f: (members: readonly [Schema.TaggedStruct<'Started', { readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly isStartupRun: Schema.Boolean }>, Schema.TaggedStruct<'Com…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'Started'>; readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly isStart…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'Started'>; readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly isStartupR…;
check: (checks_0: Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'Started'>; readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly isStartupRun: Schema.Boolean }…;
rebuild: (ast: Union<Objects>) => Schema.Union<readonly [Schema.TaggedStruct<'Started', { readonly key: Schema.String; readonly scheduleKey: Schema.NullOr<Schema.String>; readonly startedAt: Schema.Number; readonly isStartupRun: Schema.Boolean }>, …;
make: (input: { readonly key: string; readonly scheduleKey: string | null; readonly startedAt: number; readonly isStartupRun: boolean; readonly _tag?: 'Started' | undefined } | { readonly key: string; readonly scheduleKey: string | null; readonl…;
makeOption: (input: { readonly key: string; readonly scheduleKey: string | null; readonly startedAt: number; readonly isStartupRun: boolean; readonly _tag?: 'Started' | undefined } | { readonly key: string; readonly scheduleKey: string | null; readonl…;
makeEffect: (input: { readonly key: string; readonly scheduleKey: string | null; readonly startedAt: number; readonly isStartupRun: boolean; readonly _tag?: 'Started' | undefined } | { readonly key: string; readonly scheduleKey: string | null; readonl…;
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; <…;
}
Method<undefined, Union<readonly [TaggedStruct<"Started", { readonly key: String; readonly scheduleKey: NullOr<String>; readonly startedAt: Number; readonly isStartupRun: Boolean; }>, TaggedStruct<...>, TaggedStruct<...>, TaggedStruct<...>]>, Never, true, MethodAnnotations, Derive>.annotate: <A extends MethodAnnotations>(annotations: A) => Method<P, Su, E, Str, Ann & A, Client>annotate({
description: stringdescription:
"Live execution lifecycle (Started / Completed / Failed / Interrupted). Same union as the " +
"durable Daemon.store journal — persist == stream.",
}),
run: | Hyperlink.Method<
undefined,
A | Schema.Void,
Schema.Never,
false,
Hyperlink.MethodAnnotations & {
description: string
},
Hyperlink.Derive
>
| Hyperlink.Method<
undefined,
A | Schema.Void,
E,
false,
Hyperlink.MethodAnnotations & {
description: string
},
Hyperlink.Derive
>
wire: | {
readonly success?: A
readonly error?: E
}
| undefined
error?: E | undefinederror !== var undefinedundefined
? import HyperlinkHyperlink.function effect<A | Schema.Void, E>(success: A | Schema.Void, error: E): Hyperlink.Method<undefined, A | Schema.Void, E, false, Hyperlink.MethodAnnotations, Hyperlink.Derive> (+3 overloads)Two-stage
effect
— override the client-facing type with a Client (an Effect type;
a read surfaces as Effect<Success>) that must narrow the schema-derived shape:
effect<Client>()(success). Widening the success fails to compile. For a free override, see
unsafeEffect
.
effect(wire: {
readonly success?: A
readonly error?: E
}
success?: A | undefinedsuccess ?? import SchemaSchema.const Void: 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?: MakeOptions) => void;
makeOption: (input: void, options?: MakeOptions) => Option_.Option<void>;
makeEffect: (input: void, options?: MakeOptions) => Effect.Effect<void, 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, wire: {
readonly success?: A
readonly error?: E
}
error?: E extends Schema.Top = Schema.Nevererror)
: import HyperlinkHyperlink.function effect<A | Schema.Void>(success: A | Schema.Void): Hyperlink.Method<undefined, A | Schema.Void, Schema.Never, false, Hyperlink.MethodAnnotations, Hyperlink.Derive> (+3 overloads)Two-stage
effect
— override the client-facing type with a Client (an Effect type;
a read surfaces as Effect<Success>) that must narrow the schema-derived shape:
effect<Client>()(success). Widening the success fails to compile. For a free override, see
unsafeEffect
.
effect(wire: | {
readonly success?: A
readonly error?: E
}
| undefined
success?: A | undefinedsuccess ?? import SchemaSchema.const Void: 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?: MakeOptions) => void;
makeOption: (input: void, options?: MakeOptions) => Option_.Option<void>;
makeEffect: (input: void, options?: MakeOptions) => Effect.Effect<void, 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)
).Method<P extends Schema.Struct.Fields | Schema.Top | undefined, Su extends Schema.Top, E extends Schema.Top, Str extends boolean = false, Ann extends MethodAnnotations = MethodAnnotations, Client = Derive>.annotate: <A extends MethodAnnotations>(annotations: A) => Method<P, Su, E, Str, Ann & A, Client>annotate({
description: stringdescription:
"Run the daemon worker effect once, tracked — returns success; failures typed on error.",
}),
};
};
Referenced by 2 symbols