(key: string): HyperlinkTag<Self, DaemonInstanceSpec>
<A extends Schema.Top>(key: string, success: A): HyperlinkTag<
Self,
DaemonInstanceSpec<A>
>
<A extends Schema.Top, E extends Schema.Top>(
key: string,
success: A,
error: E
): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>
<A extends Schema.Top, const D extends Hyperlink.DefaultsBag>(
key: string,
options: DaemonTagOptions & {
readonly success: A
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A>>, D>
<A extends Schema.Top>(
key: string,
options: DaemonTagOptions & { readonly success: A }
): HyperlinkTag<Self, DaemonInstanceSpec<A>>
<E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(
key: string,
options: DaemonTagOptions & {
readonly error: E
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
HyperlinkTag<Self, DaemonInstanceSpec<typeof Schema.Void, E>>,
D
>
<E extends Schema.Top>(
key: string,
options: DaemonTagOptions & { readonly error: E }
): HyperlinkTag<Self, DaemonInstanceSpec<typeof Schema.Void, E>>
<
A extends Schema.Top,
E extends Schema.Top,
const D extends Hyperlink.DefaultsBag
>(
key: string,
options: DaemonTagOptions & {
readonly success: A
readonly error: E
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
HyperlinkTag<Self, DaemonInstanceSpec<A, E>>,
D
>
<A extends Schema.Top, E extends Schema.Top>(
key: string,
options: DaemonTagOptions & { readonly success: A; readonly error: E }
): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>
<HSelf, const D extends Hyperlink.DefaultsBag>(
key: string,
options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
NodeBoundTag<Self, DaemonInstanceSpec, HSelf>,
D
>
<HSelf>(
key: string,
options: DaemonTagOptions & { readonly node: NodeKey<HSelf> }
): NodeBoundTag<Self, DaemonInstanceSpec, HSelf>
<A extends Schema.Top, HSelf, const D extends Hyperlink.DefaultsBag>(
key: string,
options: DaemonTagOptions & {
readonly success: A
readonly node: NodeKey<HSelf>
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>,
D
>
<A extends Schema.Top, HSelf>(
key: string,
options: DaemonTagOptions & {
readonly success: A
readonly node: NodeKey<HSelf>
}
): NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>
<const D extends Hyperlink.DefaultsBag>(
key: string,
options: DaemonTagOptions & {
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec>, D>
(key: string, options?: DaemonTagOptions): HyperlinkTag<
Self,
DaemonInstanceSpec
>Callable shape for Tag — overloads for positional schemas + config object.
export type type DaemonTagBuild<Self> = {
(key: string): HyperlinkTag<
Self,
DaemonInstanceSpec
>
<A extends Schema.Top>(
key: string,
success: A
): HyperlinkTag<Self, DaemonInstanceSpec<A>>
<A extends Schema.Top, E extends Schema.Top>(
key: string,
success: A,
error: E
): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>
<
A extends Schema.Top,
const D extends Hyperlink.DefaultsBag
>(
key: string,
options: DaemonTagOptions & {
readonly success: A
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
HyperlinkTag<Self, DaemonInstanceSpec<A>>,
D
>
<A extends Schema.Top>(
key: string,
options: DaemonTagOptions & {
readonly success: A
}
): HyperlinkTag<Self, DaemonInstanceSpec<A>>
<
E extends Schema.Top,
const D extends Hyperlink.DefaultsBag
>(
key: string,
options: DaemonTagOptions & {
readonly error: E
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
HyperlinkTag<
Self,
DaemonInstanceSpec<typeof Schema.Void, E>
>,
D
>
<E extends Schema.Top>(
key: string,
options: DaemonTagOptions & {
readonly error: E
}
): HyperlinkTag<
Self,
DaemonInstanceSpec<typeof Schema.Void, E>
>
<
A extends Schema.Top,
E extends Schema.Top,
const D extends Hyperlink.DefaultsBag
>(
key: string,
options: DaemonTagOptions & {
readonly success: A
readonly error: E
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
HyperlinkTag<Self, DaemonInstanceSpec<A, E>>,
D
>
<A extends Schema.Top, E extends Schema.Top>(
key: string,
options: DaemonTagOptions & {
readonly success: A
readonly error: E
}
): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>
<HSelf, const D extends Hyperlink.DefaultsBag>(
key: string,
options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
NodeBoundTag<Self, DaemonInstanceSpec, HSelf>,
D
>
<HSelf>(
key: string,
options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>
}
): NodeBoundTag<Self, DaemonInstanceSpec, HSelf>
<
A extends Schema.Top,
HSelf,
const D extends Hyperlink.DefaultsBag
>(
key: string,
options: DaemonTagOptions & {
readonly success: A
readonly node: NodeKey<HSelf>
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
NodeBoundTag<
Self,
DaemonInstanceSpec<A>,
HSelf
>,
D
>
<A extends Schema.Top, HSelf>(
key: string,
options: DaemonTagOptions & {
readonly success: A
readonly node: NodeKey<HSelf>
}
): NodeBoundTag<
Self,
DaemonInstanceSpec<A>,
HSelf
>
<const D extends Hyperlink.DefaultsBag>(
key: string,
options: DaemonTagOptions & {
readonly defaults: Hyperlink.DefaultsInput<D>
}
): Hyperlink.TagWithDefaults<
HyperlinkTag<Self, DaemonInstanceSpec>,
D
>
(
key: string,
options?: DaemonTagOptions
): HyperlinkTag<Self, DaemonInstanceSpec>
}
Callable shape for
Tag
— overloads for positional schemas + config object.
DaemonTagBuild<function (type parameter) Self in type DaemonTagBuild<Self>Self> = {
(key: stringkey: string): interface HyperlinkTag<Self, S extends Spec, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>The type of a HyperService tag carrying spec S — what
Hyperlink.Tag
produces
(and what you extend). Lets a consumer write
<S extends Spec>(tag: HyperlinkTag<Self, S>) and read the spec through named types
(
specOf
/
groupOf
) instead of a Parameters<typeof specOf> workaround.
HyperlinkTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec>;
<function (type parameter) A in <A extends Schema.Top>(key: string, success: A): HyperlinkTag<Self, DaemonInstanceSpec<A>>A extends import SchemaSchema.Top>(
key: stringkey: string,
success: A extends Schema.Topsuccess: function (type parameter) A in <A extends Schema.Top>(key: string, success: A): HyperlinkTag<Self, DaemonInstanceSpec<A>>A,
): interface HyperlinkTag<Self, S extends Spec, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>The type of a HyperService tag carrying spec S — what
Hyperlink.Tag
produces
(and what you extend). Lets a consumer write
<S extends Spec>(tag: HyperlinkTag<Self, S>) and read the spec through named types
(
specOf
/
groupOf
) instead of a Parameters<typeof specOf> workaround.
HyperlinkTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec<function (type parameter) A in <A extends Schema.Top>(key: string, success: A): HyperlinkTag<Self, DaemonInstanceSpec<A>>A>>;
<function (type parameter) A in <A extends Schema.Top, E extends Schema.Top>(key: string, success: A, error: E): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>A extends import SchemaSchema.Top, function (type parameter) E in <A extends Schema.Top, E extends Schema.Top>(key: string, success: A, error: E): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>E extends import SchemaSchema.Top>(
key: stringkey: string,
success: A extends Schema.Topsuccess: function (type parameter) A in <A extends Schema.Top, E extends Schema.Top>(key: string, success: A, error: E): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>A,
error: E extends Schema.Toperror: function (type parameter) E in <A extends Schema.Top, E extends Schema.Top>(key: string, success: A, error: E): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>E,
): interface HyperlinkTag<Self, S extends Spec, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>The type of a HyperService tag carrying spec S — what
Hyperlink.Tag
produces
(and what you extend). Lets a consumer write
<S extends Spec>(tag: HyperlinkTag<Self, S>) and read the spec through named types
(
specOf
/
groupOf
) instead of a Parameters<typeof specOf> workaround.
HyperlinkTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec<function (type parameter) A in <A extends Schema.Top, E extends Schema.Top>(key: string, success: A, error: E): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>A, function (type parameter) E in <A extends Schema.Top, E extends Schema.Top>(key: string, success: A, error: E): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>E>>;
<function (type parameter) A in <A extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A>>, D>
A extends import SchemaSchema.Top, const function (type parameter) D in <A extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A>>, D>
D extends import HyperlinkHyperlink.type DefaultsBag = {
readonly [key: string]: unknown
}
A bag of Tag-baked defaults for
defaults
.
DefaultsBag>(
key: stringkey: string,
options: DaemonTagOptions & {
readonly success: A
readonly defaults: Hyperlink.DefaultsInput<D>
}
options: type DaemonTagOptions = {
readonly description?: string
readonly success?: Schema.Top
readonly error?: Schema.Top
readonly node?: NodeKey<unknown>
}
Options for
Tag
— use as the sole 2nd argument (config-object overload) or merge with
positional success / error args.
DaemonTagOptions & {
readonly success: A extends Schema.Topsuccess: function (type parameter) A in <A extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A>>, D>
A;
readonly defaults: Hyperlink.DefaultsInput<D>defaults: import HyperlinkHyperlink.type DefaultsInput<
D extends Hyperlink.DefaultsBag
> = { readonly [K in keyof D]: SyncDefault<D[K]> }
Input bag for
defaults
/ Tag { defaults } — sync values only (Promise-returning
fns are a type error).
DefaultsInput<function (type parameter) D in <A extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A>>, D>
D>;
},
): import HyperlinkHyperlink.type TagWithDefaults<
T,
D extends Hyperlink.DefaultsBag
> = T & {
readonly Service: ServiceOfTag<T> &
MergedDefaultsBag<T, D>
readonly [defaultsSym]: MergedDefaultsBag<T, D>
} & Effect.Effect<
ServiceOfTag<T> & PriorDefaults<T> & D,
never,
never
>
Tag after
defaults
(pipe or factory { defaults } sugar).
Keeps T (shallow
PipeableTag
pipe — no HyperlinkTag<Self,…> rebuild,
so class X extends Tag<X>().pipe(defaults) does not recurse on X). Widens
what yield* Tag /
Shape
see by intersecting a covariant
Effect<Svc & Bag> and a widened Service property. Soundness:
test/defaults-handle.test-d.ts.
TagWithDefaults<interface HyperlinkTag<Self, S extends Spec, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>The type of a HyperService tag carrying spec S — what
Hyperlink.Tag
produces
(and what you extend). Lets a consumer write
<S extends Spec>(tag: HyperlinkTag<Self, S>) and read the spec through named types
(
specOf
/
groupOf
) instead of a Parameters<typeof specOf> workaround.
HyperlinkTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec<function (type parameter) A in <A extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A>>, D>
A>>, function (type parameter) D in <A extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A>>, D>
D>;
<function (type parameter) A in <A extends Schema.Top>(key: string, options: DaemonTagOptions & {
readonly success: A;
}): HyperlinkTag<Self, DaemonInstanceSpec<A>>
A extends import SchemaSchema.Top>(
key: stringkey: string,
options: DaemonTagOptions & {
readonly success: A
}
options: type DaemonTagOptions = {
readonly description?: string
readonly success?: Schema.Top
readonly error?: Schema.Top
readonly node?: NodeKey<unknown>
}
Options for
Tag
— use as the sole 2nd argument (config-object overload) or merge with
positional success / error args.
DaemonTagOptions & { readonly success: A extends Schema.Topsuccess: function (type parameter) A in <A extends Schema.Top>(key: string, options: DaemonTagOptions & {
readonly success: A;
}): HyperlinkTag<Self, DaemonInstanceSpec<A>>
A },
): interface HyperlinkTag<Self, S extends Spec, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>The type of a HyperService tag carrying spec S — what
Hyperlink.Tag
produces
(and what you extend). Lets a consumer write
<S extends Spec>(tag: HyperlinkTag<Self, S>) and read the spec through named types
(
specOf
/
groupOf
) instead of a Parameters<typeof specOf> workaround.
HyperlinkTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec<function (type parameter) A in <A extends Schema.Top>(key: string, options: DaemonTagOptions & {
readonly success: A;
}): HyperlinkTag<Self, DaemonInstanceSpec<A>>
A>>;
<function (type parameter) E in <E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<typeof Schema.Void, E>>, D>
E extends import SchemaSchema.Top, const function (type parameter) D in <E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<typeof Schema.Void, E>>, D>
D extends import HyperlinkHyperlink.type DefaultsBag = {
readonly [key: string]: unknown
}
A bag of Tag-baked defaults for
defaults
.
DefaultsBag>(
key: stringkey: string,
options: DaemonTagOptions & {
readonly error: E
readonly defaults: Hyperlink.DefaultsInput<D>
}
options: type DaemonTagOptions = {
readonly description?: string
readonly success?: Schema.Top
readonly error?: Schema.Top
readonly node?: NodeKey<unknown>
}
Options for
Tag
— use as the sole 2nd argument (config-object overload) or merge with
positional success / error args.
DaemonTagOptions & {
readonly error: E extends Schema.Toperror: function (type parameter) E in <E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<typeof Schema.Void, E>>, D>
E;
readonly defaults: Hyperlink.DefaultsInput<D>defaults: import HyperlinkHyperlink.type DefaultsInput<
D extends Hyperlink.DefaultsBag
> = { readonly [K in keyof D]: SyncDefault<D[K]> }
Input bag for
defaults
/ Tag { defaults } — sync values only (Promise-returning
fns are a type error).
DefaultsInput<function (type parameter) D in <E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<typeof Schema.Void, E>>, D>
D>;
},
): import HyperlinkHyperlink.type TagWithDefaults<
T,
D extends Hyperlink.DefaultsBag
> = T & {
readonly Service: ServiceOfTag<T> &
MergedDefaultsBag<T, D>
readonly [defaultsSym]: MergedDefaultsBag<T, D>
} & Effect.Effect<
ServiceOfTag<T> & PriorDefaults<T> & D,
never,
never
>
Tag after
defaults
(pipe or factory { defaults } sugar).
Keeps T (shallow
PipeableTag
pipe — no HyperlinkTag<Self,…> rebuild,
so class X extends Tag<X>().pipe(defaults) does not recurse on X). Widens
what yield* Tag /
Shape
see by intersecting a covariant
Effect<Svc & Bag> and a widened Service property. Soundness:
test/defaults-handle.test-d.ts.
TagWithDefaults<
interface HyperlinkTag<Self, S extends Spec, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>The type of a HyperService tag carrying spec S — what
Hyperlink.Tag
produces
(and what you extend). Lets a consumer write
<S extends Spec>(tag: HyperlinkTag<Self, S>) and read the spec through named types
(
specOf
/
groupOf
) instead of a Parameters<typeof specOf> workaround.
HyperlinkTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec<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 <E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<typeof Schema.Void, E>>, D>
E>>,
function (type parameter) D in <E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<typeof Schema.Void, E>>, D>
D
>;
<function (type parameter) E in <E extends Schema.Top>(key: string, options: DaemonTagOptions & {
readonly error: E;
}): HyperlinkTag<Self, DaemonInstanceSpec<typeof Schema.Void, E>>
E extends import SchemaSchema.Top>(
key: stringkey: string,
options: DaemonTagOptions & { readonly error: E }options: type DaemonTagOptions = {
readonly description?: string
readonly success?: Schema.Top
readonly error?: Schema.Top
readonly node?: NodeKey<unknown>
}
Options for
Tag
— use as the sole 2nd argument (config-object overload) or merge with
positional success / error args.
DaemonTagOptions & { readonly error: E extends Schema.Toperror: function (type parameter) E in <E extends Schema.Top>(key: string, options: DaemonTagOptions & {
readonly error: E;
}): HyperlinkTag<Self, DaemonInstanceSpec<typeof Schema.Void, E>>
E },
): interface HyperlinkTag<Self, S extends Spec, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>The type of a HyperService tag carrying spec S — what
Hyperlink.Tag
produces
(and what you extend). Lets a consumer write
<S extends Spec>(tag: HyperlinkTag<Self, S>) and read the spec through named types
(
specOf
/
groupOf
) instead of a Parameters<typeof specOf> workaround.
HyperlinkTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec<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 <E extends Schema.Top>(key: string, options: DaemonTagOptions & {
readonly error: E;
}): HyperlinkTag<Self, DaemonInstanceSpec<typeof Schema.Void, E>>
E>>;
<function (type parameter) A in <A extends Schema.Top, E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A, E>>, D>
A extends import SchemaSchema.Top, function (type parameter) E in <A extends Schema.Top, E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A, E>>, D>
E extends import SchemaSchema.Top, const function (type parameter) D in <A extends Schema.Top, E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A, E>>, D>
D extends import HyperlinkHyperlink.type DefaultsBag = {
readonly [key: string]: unknown
}
A bag of Tag-baked defaults for
defaults
.
DefaultsBag>(
key: stringkey: string,
options: DaemonTagOptions & {
readonly success: A
readonly error: E
readonly defaults: Hyperlink.DefaultsInput<D>
}
options: type DaemonTagOptions = {
readonly description?: string
readonly success?: Schema.Top
readonly error?: Schema.Top
readonly node?: NodeKey<unknown>
}
Options for
Tag
— use as the sole 2nd argument (config-object overload) or merge with
positional success / error args.
DaemonTagOptions & {
readonly success: A extends Schema.Topsuccess: function (type parameter) A in <A extends Schema.Top, E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A, E>>, D>
A;
readonly error: E extends Schema.Toperror: function (type parameter) E in <A extends Schema.Top, E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A, E>>, D>
E;
readonly defaults: Hyperlink.DefaultsInput<D>defaults: import HyperlinkHyperlink.type DefaultsInput<
D extends Hyperlink.DefaultsBag
> = { readonly [K in keyof D]: SyncDefault<D[K]> }
Input bag for
defaults
/ Tag { defaults } — sync values only (Promise-returning
fns are a type error).
DefaultsInput<function (type parameter) D in <A extends Schema.Top, E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A, E>>, D>
D>;
},
): import HyperlinkHyperlink.type TagWithDefaults<
T,
D extends Hyperlink.DefaultsBag
> = T & {
readonly Service: ServiceOfTag<T> &
MergedDefaultsBag<T, D>
readonly [defaultsSym]: MergedDefaultsBag<T, D>
} & Effect.Effect<
ServiceOfTag<T> & PriorDefaults<T> & D,
never,
never
>
Tag after
defaults
(pipe or factory { defaults } sugar).
Keeps T (shallow
PipeableTag
pipe — no HyperlinkTag<Self,…> rebuild,
so class X extends Tag<X>().pipe(defaults) does not recurse on X). Widens
what yield* Tag /
Shape
see by intersecting a covariant
Effect<Svc & Bag> and a widened Service property. Soundness:
test/defaults-handle.test-d.ts.
TagWithDefaults<interface HyperlinkTag<Self, S extends Spec, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>The type of a HyperService tag carrying spec S — what
Hyperlink.Tag
produces
(and what you extend). Lets a consumer write
<S extends Spec>(tag: HyperlinkTag<Self, S>) and read the spec through named types
(
specOf
/
groupOf
) instead of a Parameters<typeof specOf> workaround.
HyperlinkTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec<function (type parameter) A in <A extends Schema.Top, E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A, E>>, D>
A, function (type parameter) E in <A extends Schema.Top, E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A, E>>, D>
E>>, function (type parameter) D in <A extends Schema.Top, E extends Schema.Top, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec<A, E>>, D>
D>;
<function (type parameter) A in <A extends Schema.Top, E extends Schema.Top>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
}): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>
A extends import SchemaSchema.Top, function (type parameter) E in <A extends Schema.Top, E extends Schema.Top>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
}): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>
E extends import SchemaSchema.Top>(
key: stringkey: string,
options: DaemonTagOptions & {
readonly success: A
readonly error: E
}
options: type DaemonTagOptions = {
readonly description?: string
readonly success?: Schema.Top
readonly error?: Schema.Top
readonly node?: NodeKey<unknown>
}
Options for
Tag
— use as the sole 2nd argument (config-object overload) or merge with
positional success / error args.
DaemonTagOptions & { readonly success: A extends Schema.Topsuccess: function (type parameter) A in <A extends Schema.Top, E extends Schema.Top>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
}): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>
A; readonly error: E extends Schema.Toperror: function (type parameter) E in <A extends Schema.Top, E extends Schema.Top>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
}): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>
E },
): interface HyperlinkTag<Self, S extends Spec, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>The type of a HyperService tag carrying spec S — what
Hyperlink.Tag
produces
(and what you extend). Lets a consumer write
<S extends Spec>(tag: HyperlinkTag<Self, S>) and read the spec through named types
(
specOf
/
groupOf
) instead of a Parameters<typeof specOf> workaround.
HyperlinkTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec<function (type parameter) A in <A extends Schema.Top, E extends Schema.Top>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
}): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>
A, function (type parameter) E in <A extends Schema.Top, E extends Schema.Top>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly error: E;
}): HyperlinkTag<Self, DaemonInstanceSpec<A, E>>
E>>;
<function (type parameter) HSelf in <HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec, HSelf>, D>
HSelf, const function (type parameter) D in <HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec, HSelf>, D>
D extends import HyperlinkHyperlink.type DefaultsBag = {
readonly [key: string]: unknown
}
A bag of Tag-baked defaults for
defaults
.
DefaultsBag>(
key: stringkey: string,
options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>
readonly defaults: Hyperlink.DefaultsInput<D>
}
options: type DaemonTagOptions = {
readonly description?: string
readonly success?: Schema.Top
readonly error?: Schema.Top
readonly node?: NodeKey<unknown>
}
Options for
Tag
— use as the sole 2nd argument (config-object overload) or merge with
positional success / error args.
DaemonTagOptions & {
readonly node: NodeKey<HSelf>(property) node: {
key: string;
Service: {
protocol: Context.Service.Shape<typeof RpcClient.Protocol>;
ping: Effect.Effect<number, NodeUnreachable>;
status: { readonly get: Effect.Effect<NodeStatusSnapshot, NodeUnreachable>; readonly changes: Stream.Stream<NodeStatusSnapshot, NodeUnreachable> };
logs: { readonly stream: Stream.Stream<LogEntry, NodeUnreachable>; readonly query: (options: { readonly limit: number }) => Effect.Effect<ReadonlyArray<LogEntry>, NodeUnreachable> };
};
Identifier: Identifier;
stack: string | undefined;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
node: type NodeKey<HSelf> = Context.Key<HSelf, NodeProtocol>The Context key of a
Node
(HSelf = its identity): a service whose value is the
transport
NodeProtocol
. Stored on a node-bearing tag under
nodeSym
; read by
Hyperlink.client
to resolve where to connect (its requirement channel).
NodeKey<function (type parameter) HSelf in <HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec, HSelf>, D>
HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>defaults: import HyperlinkHyperlink.type DefaultsInput<
D extends Hyperlink.DefaultsBag
> = { readonly [K in keyof D]: SyncDefault<D[K]> }
Input bag for
defaults
/ Tag { defaults } — sync values only (Promise-returning
fns are a type error).
DefaultsInput<function (type parameter) D in <HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec, HSelf>, D>
D>;
},
): import HyperlinkHyperlink.type TagWithDefaults<
T,
D extends Hyperlink.DefaultsBag
> = T & {
readonly Service: ServiceOfTag<T> &
MergedDefaultsBag<T, D>
readonly [defaultsSym]: MergedDefaultsBag<T, D>
} & Effect.Effect<
ServiceOfTag<T> & PriorDefaults<T> & D,
never,
never
>
Tag after
defaults
(pipe or factory { defaults } sugar).
Keeps T (shallow
PipeableTag
pipe — no HyperlinkTag<Self,…> rebuild,
so class X extends Tag<X>().pipe(defaults) does not recurse on X). Widens
what yield* Tag /
Shape
see by intersecting a covariant
Effect<Svc & Bag> and a widened Service property. Soundness:
test/defaults-handle.test-d.ts.
TagWithDefaults<interface NodeBoundTag<Self, S extends Spec, HSelf, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>A
HyperlinkTag
bound to a concrete
Node
— its [nodeSym] narrowed to that node's
NodeKey<HSelf>, which is how
Hyperlink.client
discriminates the node-aware path. Returned
by the node-bearing tag constructors. It's a named type (not an inline & { [nodeSym] }) so a
consumer can export a node-bearing tag without leaking the internal symbol (TS4020).
NodeBoundTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec, function (type parameter) HSelf in <HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec, HSelf>, D>
HSelf>, function (type parameter) D in <HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec, HSelf>, D>
D>;
<function (type parameter) HSelf in <HSelf>(key: string, options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>;
}): NodeBoundTag<Self, DaemonInstanceSpec, HSelf>
HSelf>(
key: stringkey: string,
options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>
}
options: type DaemonTagOptions = {
readonly description?: string
readonly success?: Schema.Top
readonly error?: Schema.Top
readonly node?: NodeKey<unknown>
}
Options for
Tag
— use as the sole 2nd argument (config-object overload) or merge with
positional success / error args.
DaemonTagOptions & { readonly node: NodeKey<HSelf>(property) node: {
key: string;
Service: {
protocol: Context.Service.Shape<typeof RpcClient.Protocol>;
ping: Effect.Effect<number, NodeUnreachable>;
status: { readonly get: Effect.Effect<NodeStatusSnapshot, NodeUnreachable>; readonly changes: Stream.Stream<NodeStatusSnapshot, NodeUnreachable> };
logs: { readonly stream: Stream.Stream<LogEntry, NodeUnreachable>; readonly query: (options: { readonly limit: number }) => Effect.Effect<ReadonlyArray<LogEntry>, NodeUnreachable> };
};
Identifier: Identifier;
stack: string | undefined;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
node: type NodeKey<HSelf> = Context.Key<HSelf, NodeProtocol>The Context key of a
Node
(HSelf = its identity): a service whose value is the
transport
NodeProtocol
. Stored on a node-bearing tag under
nodeSym
; read by
Hyperlink.client
to resolve where to connect (its requirement channel).
NodeKey<function (type parameter) HSelf in <HSelf>(key: string, options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>;
}): NodeBoundTag<Self, DaemonInstanceSpec, HSelf>
HSelf> },
): interface NodeBoundTag<Self, S extends Spec, HSelf, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>A
HyperlinkTag
bound to a concrete
Node
— its [nodeSym] narrowed to that node's
NodeKey<HSelf>, which is how
Hyperlink.client
discriminates the node-aware path. Returned
by the node-bearing tag constructors. It's a named type (not an inline & { [nodeSym] }) so a
consumer can export a node-bearing tag without leaking the internal symbol (TS4020).
NodeBoundTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec, function (type parameter) HSelf in <HSelf>(key: string, options: DaemonTagOptions & {
readonly node: NodeKey<HSelf>;
}): NodeBoundTag<Self, DaemonInstanceSpec, HSelf>
HSelf>;
<function (type parameter) A in <A extends Schema.Top, HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>, D>
A extends import SchemaSchema.Top, function (type parameter) HSelf in <A extends Schema.Top, HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>, D>
HSelf, const function (type parameter) D in <A extends Schema.Top, HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>, D>
D extends import HyperlinkHyperlink.type DefaultsBag = {
readonly [key: string]: unknown
}
A bag of Tag-baked defaults for
defaults
.
DefaultsBag>(
key: stringkey: string,
options: DaemonTagOptions & {
readonly success: A
readonly node: NodeKey<HSelf>
readonly defaults: Hyperlink.DefaultsInput<D>
}
options: type DaemonTagOptions = {
readonly description?: string
readonly success?: Schema.Top
readonly error?: Schema.Top
readonly node?: NodeKey<unknown>
}
Options for
Tag
— use as the sole 2nd argument (config-object overload) or merge with
positional success / error args.
DaemonTagOptions & {
readonly success: A extends Schema.Topsuccess: function (type parameter) A in <A extends Schema.Top, HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>, D>
A;
readonly node: NodeKey<HSelf>(property) node: {
key: string;
Service: {
protocol: Context.Service.Shape<typeof RpcClient.Protocol>;
ping: Effect.Effect<number, NodeUnreachable>;
status: { readonly get: Effect.Effect<NodeStatusSnapshot, NodeUnreachable>; readonly changes: Stream.Stream<NodeStatusSnapshot, NodeUnreachable> };
logs: { readonly stream: Stream.Stream<LogEntry, NodeUnreachable>; readonly query: (options: { readonly limit: number }) => Effect.Effect<ReadonlyArray<LogEntry>, NodeUnreachable> };
};
Identifier: Identifier;
stack: string | undefined;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
node: type NodeKey<HSelf> = Context.Key<HSelf, NodeProtocol>The Context key of a
Node
(HSelf = its identity): a service whose value is the
transport
NodeProtocol
. Stored on a node-bearing tag under
nodeSym
; read by
Hyperlink.client
to resolve where to connect (its requirement channel).
NodeKey<function (type parameter) HSelf in <A extends Schema.Top, HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>, D>
HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>defaults: import HyperlinkHyperlink.type DefaultsInput<
D extends Hyperlink.DefaultsBag
> = { readonly [K in keyof D]: SyncDefault<D[K]> }
Input bag for
defaults
/ Tag { defaults } — sync values only (Promise-returning
fns are a type error).
DefaultsInput<function (type parameter) D in <A extends Schema.Top, HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>, D>
D>;
},
): import HyperlinkHyperlink.type TagWithDefaults<
T,
D extends Hyperlink.DefaultsBag
> = T & {
readonly Service: ServiceOfTag<T> &
MergedDefaultsBag<T, D>
readonly [defaultsSym]: MergedDefaultsBag<T, D>
} & Effect.Effect<
ServiceOfTag<T> & PriorDefaults<T> & D,
never,
never
>
Tag after
defaults
(pipe or factory { defaults } sugar).
Keeps T (shallow
PipeableTag
pipe — no HyperlinkTag<Self,…> rebuild,
so class X extends Tag<X>().pipe(defaults) does not recurse on X). Widens
what yield* Tag /
Shape
see by intersecting a covariant
Effect<Svc & Bag> and a widened Service property. Soundness:
test/defaults-handle.test-d.ts.
TagWithDefaults<interface NodeBoundTag<Self, S extends Spec, HSelf, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>A
HyperlinkTag
bound to a concrete
Node
— its [nodeSym] narrowed to that node's
NodeKey<HSelf>, which is how
Hyperlink.client
discriminates the node-aware path. Returned
by the node-bearing tag constructors. It's a named type (not an inline & { [nodeSym] }) so a
consumer can export a node-bearing tag without leaking the internal symbol (TS4020).
NodeBoundTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec<function (type parameter) A in <A extends Schema.Top, HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>, D>
A>, function (type parameter) HSelf in <A extends Schema.Top, HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>, D>
HSelf>, function (type parameter) D in <A extends Schema.Top, HSelf, const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>, D>
D>;
<function (type parameter) A in <A extends Schema.Top, HSelf>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
}): NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>
A extends import SchemaSchema.Top, function (type parameter) HSelf in <A extends Schema.Top, HSelf>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
}): NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>
HSelf>(
key: stringkey: string,
options: DaemonTagOptions & {
readonly success: A
readonly node: NodeKey<HSelf>
}
options: type DaemonTagOptions = {
readonly description?: string
readonly success?: Schema.Top
readonly error?: Schema.Top
readonly node?: NodeKey<unknown>
}
Options for
Tag
— use as the sole 2nd argument (config-object overload) or merge with
positional success / error args.
DaemonTagOptions & { readonly success: A extends Schema.Topsuccess: function (type parameter) A in <A extends Schema.Top, HSelf>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
}): NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>
A; readonly node: NodeKey<HSelf>(property) node: {
key: string;
Service: {
protocol: Context.Service.Shape<typeof RpcClient.Protocol>;
ping: Effect.Effect<number, NodeUnreachable>;
status: { readonly get: Effect.Effect<NodeStatusSnapshot, NodeUnreachable>; readonly changes: Stream.Stream<NodeStatusSnapshot, NodeUnreachable> };
logs: { readonly stream: Stream.Stream<LogEntry, NodeUnreachable>; readonly query: (options: { readonly limit: number }) => Effect.Effect<ReadonlyArray<LogEntry>, NodeUnreachable> };
};
Identifier: Identifier;
stack: string | undefined;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
node: type NodeKey<HSelf> = Context.Key<HSelf, NodeProtocol>The Context key of a
Node
(HSelf = its identity): a service whose value is the
transport
NodeProtocol
. Stored on a node-bearing tag under
nodeSym
; read by
Hyperlink.client
to resolve where to connect (its requirement channel).
NodeKey<function (type parameter) HSelf in <A extends Schema.Top, HSelf>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
}): NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>
HSelf> },
): interface NodeBoundTag<Self, S extends Spec, HSelf, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>A
HyperlinkTag
bound to a concrete
Node
— its [nodeSym] narrowed to that node's
NodeKey<HSelf>, which is how
Hyperlink.client
discriminates the node-aware path. Returned
by the node-bearing tag constructors. It's a named type (not an inline & { [nodeSym] }) so a
consumer can export a node-bearing tag without leaking the internal symbol (TS4020).
NodeBoundTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec<function (type parameter) A in <A extends Schema.Top, HSelf>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
}): NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>
A>, function (type parameter) HSelf in <A extends Schema.Top, HSelf>(key: string, options: DaemonTagOptions & {
readonly success: A;
readonly node: NodeKey<HSelf>;
}): NodeBoundTag<Self, DaemonInstanceSpec<A>, HSelf>
HSelf>;
<const function (type parameter) D in <const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec>, D>
D extends import HyperlinkHyperlink.type DefaultsBag = {
readonly [key: string]: unknown
}
A bag of Tag-baked defaults for
defaults
.
DefaultsBag>(
key: stringkey: string,
options: DaemonTagOptions & {
readonly defaults: Hyperlink.DefaultsInput<D>
}
options: type DaemonTagOptions = {
readonly description?: string
readonly success?: Schema.Top
readonly error?: Schema.Top
readonly node?: NodeKey<unknown>
}
Options for
Tag
— use as the sole 2nd argument (config-object overload) or merge with
positional success / error args.
DaemonTagOptions & { readonly defaults: Hyperlink.DefaultsInput<D>defaults: import HyperlinkHyperlink.type DefaultsInput<
D extends Hyperlink.DefaultsBag
> = { readonly [K in keyof D]: SyncDefault<D[K]> }
Input bag for
defaults
/ Tag { defaults } — sync values only (Promise-returning
fns are a type error).
DefaultsInput<function (type parameter) D in <const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec>, D>
D> },
): import HyperlinkHyperlink.type TagWithDefaults<
T,
D extends Hyperlink.DefaultsBag
> = T & {
readonly Service: ServiceOfTag<T> &
MergedDefaultsBag<T, D>
readonly [defaultsSym]: MergedDefaultsBag<T, D>
} & Effect.Effect<
ServiceOfTag<T> & PriorDefaults<T> & D,
never,
never
>
Tag after
defaults
(pipe or factory { defaults } sugar).
Keeps T (shallow
PipeableTag
pipe — no HyperlinkTag<Self,…> rebuild,
so class X extends Tag<X>().pipe(defaults) does not recurse on X). Widens
what yield* Tag /
Shape
see by intersecting a covariant
Effect<Svc & Bag> and a widened Service property. Soundness:
test/defaults-handle.test-d.ts.
TagWithDefaults<interface HyperlinkTag<Self, S extends Spec, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>The type of a HyperService tag carrying spec S — what
Hyperlink.Tag
produces
(and what you extend). Lets a consumer write
<S extends Spec>(tag: HyperlinkTag<Self, S>) and read the spec through named types
(
specOf
/
groupOf
) instead of a Parameters<typeof specOf> workaround.
HyperlinkTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec>, function (type parameter) D in <const D extends Hyperlink.DefaultsBag>(key: string, options: DaemonTagOptions & {
readonly defaults: Hyperlink.DefaultsInput<D>;
}): Hyperlink.TagWithDefaults<HyperlinkTag<Self, DaemonInstanceSpec>, D>
D>;
(key: stringkey: string, options: DaemonTagOptionsoptions?: type DaemonTagOptions = {
readonly description?: string
readonly success?: Schema.Top
readonly error?: Schema.Top
readonly node?: NodeKey<unknown>
}
Options for
Tag
— use as the sole 2nd argument (config-object overload) or merge with
positional success / error args.
DaemonTagOptions): interface HyperlinkTag<Self, S extends Spec, Svc = Simplify<{ readonly [K in keyof S]: S[K] extends FromLocalMethod<infer M> ? InjectLocal<M, Self> : S[K] extends LocalMethod<infer T> ? LocalEffect<...> : S[K] extends DefaultMethod<...> ? F : S[K] extends { ...; } ? SuccessOf<...> : S[K] extends { ...; } ? Subscribable<...> : S[K] extends { ...; } ? ClientMethod<...> : S[K] extends Spec ? Simplify<...> : never; }>>The type of a HyperService tag carrying spec S — what
Hyperlink.Tag
produces
(and what you extend). Lets a consumer write
<S extends Spec>(tag: HyperlinkTag<Self, S>) and read the spec through named types
(
specOf
/
groupOf
) instead of a Parameters<typeof specOf> workaround.
HyperlinkTag<function (type parameter) Self in type DaemonTagBuild<Self>Self, type DaemonInstanceSpec<A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never> = {
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<...>;
} & {
...;
} & (A extends Schema.Void ? Record<...> : ResultGroupSpec<...>)
Per-tag daemon spec — control surface, live events, plus stamped run success/error on the wire.
DaemonInstanceSpec>;
};