@nyte-ai/schema 0.0.0-stage → 0.0.18

package/dist/src/plugins.d.ts

@@ -0,0 +1,36 @@
+import { Type } from "typebox";
+import type { Failure } from "./errors.ts";
+import type { Message as ModelMessage } from "./model/message.ts";
+import type { ModelRef, Thinking, Usage } from "./models.ts";
+import type { Decoded, Schema } from "./schema.ts";
+export declare const PromptOverrideType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"layer">;
+    text: Type.TString;
+    order: Type.TOptional<Type.TNumber>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"replace">;
+    text: Type.TString;
+}>]>;
+export type PromptOverride = Decoded<typeof PromptOverrideType>;
+export declare const PromptOverrideSchema: Schema<PromptOverride>;
+export type ModelRequestInput<T = string> = {
+    readonly model: ModelRef;
+    readonly system?: string;
+    readonly messages: readonly ModelMessage[];
+    readonly thinking?: Thinking;
+    readonly output?: Schema<T>;
+    readonly maxOutput?: number;
+    readonly signal?: AbortSignal;
+};
+export type ModelRequestOutcome<T = string> = {
+    readonly kind: "ok";
+    readonly value: T;
+    readonly usage: Usage;
+    readonly stop: "end" | "length";
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+} | {
+    readonly kind: "failed";
+    readonly failure: Failure;
+};

package/dist/src/plugins.js

@@ -0,0 +1,9 @@
+import {
+  PromptOverrideType2,
+  PromptOverrideSchema2
+} from "../chunks/browser-j629a6wa.js";
+import"../chunks/browser-vzc3r2r3.js";
+export {
+  PromptOverrideSchema2 as PromptOverrideSchema,
+  PromptOverrideType2 as PromptOverrideType
+};

package/dist/src/primitives.d.ts

@@ -0,0 +1,83 @@
+import { Type } from "typebox";
+import type { TSchema } from "typebox";
+import type { Cursor } from "./ids.ts";
+import type { Decoded, Schema } from "./schema.ts";
+export declare function pagedSchema<T extends TSchema>(item: T): Schema<{
+    items: import("typebox").StaticType<["Root"], "Decode", {
+        Json: Type.TUnion<[Type.TNull, Type.TBoolean, Type.TNumber, Type.TString, Type.TArray<Type.TRef<"Json">>, Type.TRecord<"^.*$", Type.TRef<"Json">>]>;
+    } & {
+        Root: Type.TObject<{
+            items: Type.TArray<T>;
+            next: Type.TUnion<[Type.TUnsafe<import("./ids.ts").Id<"cursor">>, Type.TNull]>;
+        }>;
+    }, {
+        items: Type.TArray<T>;
+        next: Type.TUnion<[Type.TUnsafe<import("./ids.ts").Id<"cursor">>, Type.TNull]>;
+    }, T>[];
+    next: import("./ids.ts").Id<"cursor"> | null;
+}>;
+export declare const ParentFilterType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"all">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"roots">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"children">;
+    session: Type.TUnsafe<import("./ids.ts").Id<"session">>;
+}>]>;
+export type ParentFilter = Decoded<typeof ParentFilterType>;
+export declare const CapabilityWireType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"available">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"unsupported">;
+    reason: Type.TString;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"denied">;
+    reason: Type.TString;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"unavailable">;
+    retry: Type.TEnum<["allowed", "manual"]>;
+    reason: Type.TString;
+}>]>;
+export type CapabilityWire = Decoded<typeof CapabilityWireType>;
+export declare const IdentityChallengeType: Type.TObject<{
+    hostId: Type.TUnsafe<import("./ids.ts").Id<"host">>;
+    nonce: Type.TString;
+    signature: Type.TString;
+    publicKey: Type.TString;
+}>;
+export type IdentityChallenge = Decoded<typeof IdentityChallengeType>;
+export declare const HostDescriptionType: Type.TObject<{
+    name: Type.TString;
+    platform: Type.TString;
+    version: Type.TString;
+}>;
+export type HostDescription = Decoded<typeof HostDescriptionType>;
+export declare const ParentFilterSchema: Schema<ParentFilter>;
+export declare const CapabilityWireSchema: Schema<CapabilityWire>;
+export declare const IdentityChallengeSchema: Schema<IdentityChallenge>;
+export declare const HostDescriptionSchema: Schema<HostDescription>;
+export type Disposer = () => void;
+export type Owned = {
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+};
+export type RequestOptions = {
+    readonly signal?: AbortSignal;
+};
+export type Paged<T> = {
+    readonly items: readonly T[];
+    readonly next: Cursor | null;
+};
+/** A capability as the client holds it: the wire's answer, with the API itself when it is available. */
+export type Capability<T> = Exclude<CapabilityWire, {
+    readonly kind: "available";
+}> | {
+    readonly kind: "available";
+    readonly api: T;
+};
+export type ByteReader = Owned & {
+    readonly size: number | null;
+    readonly mime: string | null;
+    chunks(): AsyncIterable<Uint8Array>;
+};
+export type Awaitable<T> = T | Promise<T>;

package/dist/src/primitives.js

@@ -0,0 +1,26 @@
+import {
+  pagedSchema2,
+  ParentFilterType2,
+  CapabilityWireType2,
+  IdentityChallengeType2,
+  HostDescriptionType2,
+  ParentFilterSchema2,
+  CapabilityWireSchema2,
+  IdentityChallengeSchema2,
+  HostDescriptionSchema2
+} from "../chunks/browser-0byq2fja.js";
+import"../chunks/browser-sgwxbek9.js";
+import"../chunks/browser-4et7qtz3.js";
+import"../chunks/browser-ypez6s7v.js";
+import"../chunks/browser-vzc3r2r3.js";
+export {
+  CapabilityWireSchema2 as CapabilityWireSchema,
+  CapabilityWireType2 as CapabilityWireType,
+  HostDescriptionSchema2 as HostDescriptionSchema,
+  HostDescriptionType2 as HostDescriptionType,
+  IdentityChallengeSchema2 as IdentityChallengeSchema,
+  IdentityChallengeType2 as IdentityChallengeType,
+  ParentFilterSchema2 as ParentFilterSchema,
+  ParentFilterType2 as ParentFilterType,
+  pagedSchema2 as pagedSchema
+};

package/dist/src/runs.d.ts

@@ -0,0 +1,433 @@
+import { Type } from "typebox";
+import type { TSchema } from "typebox";
+import type { Decoded, Schema } from "./schema.ts";
+export declare const RunViewType: Type.TObject<{
+    id: Type.TUnsafe<import("./ids.ts").Id<"run">>;
+    head: Type.TUnsafe<import("./ids.ts").Id<"head">>;
+    startedAt: Type.TNumber;
+    attempt: Type.TNumber;
+    configuration: Type.TObject<{
+        kind: Type.TLiteral<"exact">;
+        model: Type.TObject<{
+            provider: Type.TString;
+            id: Type.TString;
+        }>;
+        thinking: Type.TEnum<["off", "minimal", "low", "medium", "high", "xhigh", "max"]>;
+        agent: Type.TUnion<[Type.TString, Type.TNull]>;
+        settings: Type.TRecord<"^.*$", Type.TUnsafe<import("./json.ts").Json>>;
+        settingsVersion: Type.TString;
+    }>;
+    origin: Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"input">;
+        message: Type.TUnsafe<import("./ids.ts").Id<"message">>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"continuation">;
+        from: Type.TEnum<["child", "job", "wake"]>;
+    }>]>;
+}>;
+export type RunView = Decoded<typeof RunViewType>;
+export declare const RunEndType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"completed">;
+    usage: Type.TObject<{
+        input: Type.TNumber;
+        output: Type.TNumber;
+        cacheRead: Type.TNumber;
+        cacheWrite: Type.TNumber;
+        reasoning: Type.TUnion<[Type.TNumber, Type.TNull]>;
+        total: Type.TNumber;
+        cost: Type.TObject<{
+            input: Type.TNumber;
+            output: Type.TNumber;
+            cacheRead: Type.TNumber;
+            cacheWrite: Type.TNumber;
+            total: Type.TNumber;
+        }>;
+    }>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"stopped">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"failed">;
+    failure: Type.TObject<{
+        class: Type.TEnum<["rate_limit", "auth", "quota", "context_window", "overloaded", "network", "aborted", "provider", "runner"]>;
+        message: Type.TString;
+        retryAfterMs: Type.TOptional<Type.TNumber>;
+    }>;
+}>]>;
+export type RunEnd = Decoded<typeof RunEndType>;
+export declare const WaitTargetType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"run">;
+    session: Type.TUnsafe<import("./ids.ts").Id<"session">>;
+    run: Type.TUnsafe<import("./ids.ts").Id<"run">>;
+    deadline: Type.TOptional<Type.TNumber>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"job">;
+    job: Type.TUnsafe<import("./ids.ts").Id<"job">>;
+    deadline: Type.TOptional<Type.TNumber>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"part">;
+    part: Type.TUnsafe<import("./ids.ts").Id<"part">>;
+    deadline: Type.TOptional<Type.TNumber>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"timer">;
+    until: Type.TNumber;
+    deadline: Type.TOptional<Type.TNumber>;
+}>]>;
+export type WaitTarget = Decoded<typeof WaitTargetType>;
+export declare const ExecutionType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"idle">;
+    lastRun: Type.TUnion<[Type.TObject<{
+        id: Type.TUnsafe<import("./ids.ts").Id<"run">>;
+        end: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"completed">;
+            usage: Type.TObject<{
+                input: Type.TNumber;
+                output: Type.TNumber;
+                cacheRead: Type.TNumber;
+                cacheWrite: Type.TNumber;
+                reasoning: Type.TUnion<[Type.TNumber, Type.TNull]>;
+                total: Type.TNumber;
+                cost: Type.TObject<{
+                    input: Type.TNumber;
+                    output: Type.TNumber;
+                    cacheRead: Type.TNumber;
+                    cacheWrite: Type.TNumber;
+                    total: Type.TNumber;
+                }>;
+            }>;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"stopped">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"failed">;
+            failure: Type.TObject<{
+                class: Type.TEnum<["rate_limit", "auth", "quota", "context_window", "overloaded", "network", "aborted", "provider", "runner"]>;
+                message: Type.TString;
+                retryAfterMs: Type.TOptional<Type.TNumber>;
+            }>;
+        }>]>;
+        endedAt: Type.TNumber;
+    }>, Type.TNull]>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"live">;
+    run: Type.TObject<{
+        id: Type.TUnsafe<import("./ids.ts").Id<"run">>;
+        head: Type.TUnsafe<import("./ids.ts").Id<"head">>;
+        startedAt: Type.TNumber;
+        attempt: Type.TNumber;
+        configuration: Type.TObject<{
+            kind: Type.TLiteral<"exact">;
+            model: Type.TObject<{
+                provider: Type.TString;
+                id: Type.TString;
+            }>;
+            thinking: Type.TEnum<["off", "minimal", "low", "medium", "high", "xhigh", "max"]>;
+            agent: Type.TUnion<[Type.TString, Type.TNull]>;
+            settings: Type.TRecord<"^.*$", Type.TUnsafe<import("./json.ts").Json>>;
+            settingsVersion: Type.TString;
+        }>;
+        origin: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"input">;
+            message: Type.TUnsafe<import("./ids.ts").Id<"message">>;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"continuation">;
+            from: Type.TEnum<["child", "job", "wake"]>;
+        }>]>;
+    }>;
+    phase: Type.TEnum<["responding", "executing"]>;
+    stopping: Type.TBoolean;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"waiting">;
+    run: Type.TObject<{
+        id: Type.TUnsafe<import("./ids.ts").Id<"run">>;
+        head: Type.TUnsafe<import("./ids.ts").Id<"head">>;
+        startedAt: Type.TNumber;
+        attempt: Type.TNumber;
+        configuration: Type.TObject<{
+            kind: Type.TLiteral<"exact">;
+            model: Type.TObject<{
+                provider: Type.TString;
+                id: Type.TString;
+            }>;
+            thinking: Type.TEnum<["off", "minimal", "low", "medium", "high", "xhigh", "max"]>;
+            agent: Type.TUnion<[Type.TString, Type.TNull]>;
+            settings: Type.TRecord<"^.*$", Type.TUnsafe<import("./json.ts").Json>>;
+            settingsVersion: Type.TString;
+        }>;
+        origin: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"input">;
+            message: Type.TUnsafe<import("./ids.ts").Id<"message">>;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"continuation">;
+            from: Type.TEnum<["child", "job", "wake"]>;
+        }>]>;
+    }>;
+    on: Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"run">;
+        session: Type.TUnsafe<import("./ids.ts").Id<"session">>;
+        run: Type.TUnsafe<import("./ids.ts").Id<"run">>;
+        deadline: Type.TOptional<Type.TNumber>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"job">;
+        job: Type.TUnsafe<import("./ids.ts").Id<"job">>;
+        deadline: Type.TOptional<Type.TNumber>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"part">;
+        part: Type.TUnsafe<import("./ids.ts").Id<"part">>;
+        deadline: Type.TOptional<Type.TNumber>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"timer">;
+        until: Type.TNumber;
+        deadline: Type.TOptional<Type.TNumber>;
+    }>]>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"retrying">;
+    run: Type.TObject<{
+        id: Type.TUnsafe<import("./ids.ts").Id<"run">>;
+        head: Type.TUnsafe<import("./ids.ts").Id<"head">>;
+        startedAt: Type.TNumber;
+        attempt: Type.TNumber;
+        configuration: Type.TObject<{
+            kind: Type.TLiteral<"exact">;
+            model: Type.TObject<{
+                provider: Type.TString;
+                id: Type.TString;
+            }>;
+            thinking: Type.TEnum<["off", "minimal", "low", "medium", "high", "xhigh", "max"]>;
+            agent: Type.TUnion<[Type.TString, Type.TNull]>;
+            settings: Type.TRecord<"^.*$", Type.TUnsafe<import("./json.ts").Json>>;
+            settingsVersion: Type.TString;
+        }>;
+        origin: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"input">;
+            message: Type.TUnsafe<import("./ids.ts").Id<"message">>;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"continuation">;
+            from: Type.TEnum<["child", "job", "wake"]>;
+        }>]>;
+    }>;
+    until: Type.TNumber;
+    reason: Type.TString;
+}>]>;
+export type Execution = Decoded<typeof ExecutionType>;
+export declare const BackgroundItemType: Type.TObject<{
+    kind: Type.TEnum<["child", "job", "page"]>;
+    id: Type.TString;
+    title: Type.TString;
+    state: Type.TEnum<["working", "waiting", "done", "failed"]>;
+    startedBy: Type.TUnion<[Type.TUnsafe<import("./ids.ts").Id<"call">>, Type.TNull]>;
+}>;
+export type BackgroundItem = Decoded<typeof BackgroundItemType>;
+export declare const WaitOutcomeType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"run">;
+    session: Type.TUnsafe<import("./ids.ts").Id<"session">>;
+    run: Type.TUnsafe<import("./ids.ts").Id<"run">>;
+    end: Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"completed">;
+        usage: Type.TObject<{
+            input: Type.TNumber;
+            output: Type.TNumber;
+            cacheRead: Type.TNumber;
+            cacheWrite: Type.TNumber;
+            reasoning: Type.TUnion<[Type.TNumber, Type.TNull]>;
+            total: Type.TNumber;
+            cost: Type.TObject<{
+                input: Type.TNumber;
+                output: Type.TNumber;
+                cacheRead: Type.TNumber;
+                cacheWrite: Type.TNumber;
+                total: Type.TNumber;
+            }>;
+        }>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"stopped">;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"failed">;
+        failure: Type.TObject<{
+            class: Type.TEnum<["rate_limit", "auth", "quota", "context_window", "overloaded", "network", "aborted", "provider", "runner"]>;
+            message: Type.TString;
+            retryAfterMs: Type.TOptional<Type.TNumber>;
+        }>;
+    }>]>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"job">;
+    job: Type.TUnsafe<import("./ids.ts").Id<"job">>;
+    end: Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"exited">;
+        code: Type.TUnion<[Type.TNumber, Type.TNull]>;
+        reason: Type.TEnum<["exited", "terminated", "expired", "host-lost"]>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"lost">;
+    }>]>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"part">;
+    part: Type.TUnsafe<import("./ids.ts").Id<"part">>;
+    answer: Type.TUnion<[Type.TObject<{
+        action: Type.TString;
+        input: Type.TUnsafe<import("./json.ts").Json>;
+    }>, Type.TNull]>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"timer">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"deadline">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"input">;
+    message: Type.TUnsafe<import("./ids.ts").Id<"message">>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"all">;
+    outcomes: Type.TArray<Type.TRef<"WaitOutcome">>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"stopped">;
+}>]>;
+declare const WAIT_OUTCOME: Type.TCyclic<{
+    Json: Type.TUnion<[Type.TNull, Type.TBoolean, Type.TNumber, Type.TString, Type.TArray<Type.TRef<"Json">>, Type.TRecord<"^.*$", Type.TRef<"Json">>]>;
+} & {
+    WaitOutcome: Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"run">;
+        session: Type.TUnsafe<import("./ids.ts").Id<"session">>;
+        run: Type.TUnsafe<import("./ids.ts").Id<"run">>;
+        end: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"completed">;
+            usage: Type.TObject<{
+                input: Type.TNumber;
+                output: Type.TNumber;
+                cacheRead: Type.TNumber;
+                cacheWrite: Type.TNumber;
+                reasoning: Type.TUnion<[Type.TNumber, Type.TNull]>;
+                total: Type.TNumber;
+                cost: Type.TObject<{
+                    input: Type.TNumber;
+                    output: Type.TNumber;
+                    cacheRead: Type.TNumber;
+                    cacheWrite: Type.TNumber;
+                    total: Type.TNumber;
+                }>;
+            }>;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"stopped">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"failed">;
+            failure: Type.TObject<{
+                class: Type.TEnum<["rate_limit", "auth", "quota", "context_window", "overloaded", "network", "aborted", "provider", "runner"]>;
+                message: Type.TString;
+                retryAfterMs: Type.TOptional<Type.TNumber>;
+            }>;
+        }>]>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"job">;
+        job: Type.TUnsafe<import("./ids.ts").Id<"job">>;
+        end: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"exited">;
+            code: Type.TUnion<[Type.TNumber, Type.TNull]>;
+            reason: Type.TEnum<["exited", "terminated", "expired", "host-lost"]>;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"lost">;
+        }>]>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"part">;
+        part: Type.TUnsafe<import("./ids.ts").Id<"part">>;
+        answer: Type.TUnion<[Type.TObject<{
+            action: Type.TString;
+            input: Type.TUnsafe<import("./json.ts").Json>;
+        }>, Type.TNull]>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"timer">;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"deadline">;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"input">;
+        message: Type.TUnsafe<import("./ids.ts").Id<"message">>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"all">;
+        outcomes: Type.TArray<Type.TRef<"WaitOutcome">>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"stopped">;
+    }>]>;
+}, "WaitOutcome">;
+export type WaitOutcome = Decoded<typeof WAIT_OUTCOME>;
+export declare function stopOutcomeSchema<T extends TSchema>(outcome: T): Schema<{
+    kind: "requested";
+} | ((Readonly<Partial<Pick<{
+    kind: "settled";
+    outcome: import("typebox").StaticType<["Root"], "Decode", {
+        Json: Type.TUnion<[Type.TNull, Type.TBoolean, Type.TNumber, Type.TString, Type.TArray<Type.TRef<"Json">>, Type.TRecord<"^.*$", Type.TRef<"Json">>]>;
+    } & {
+        Root: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"requested">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"settled">;
+            outcome: T;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"missing">;
+        }>]>;
+    }, {
+        kind: Type.TLiteral<"settled">;
+        outcome: T;
+    }, T>;
+}, T extends Type.TReadonly<Type.TSchema> ? T extends Type.TOptional<T> ? "outcome" : never : never>>> & Readonly<Pick<{
+    kind: "settled";
+    outcome: import("typebox").StaticType<["Root"], "Decode", {
+        Json: Type.TUnion<[Type.TNull, Type.TBoolean, Type.TNumber, Type.TString, Type.TArray<Type.TRef<"Json">>, Type.TRecord<"^.*$", Type.TRef<"Json">>]>;
+    } & {
+        Root: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"requested">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"settled">;
+            outcome: T;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"missing">;
+        }>]>;
+    }, {
+        kind: Type.TLiteral<"settled">;
+        outcome: T;
+    }, T>;
+}, T extends Type.TReadonly<Type.TSchema> ? T extends Type.TOptional<T> ? never : "outcome" : never>> & Partial<Pick<{
+    kind: "settled";
+    outcome: import("typebox").StaticType<["Root"], "Decode", {
+        Json: Type.TUnion<[Type.TNull, Type.TBoolean, Type.TNumber, Type.TString, Type.TArray<Type.TRef<"Json">>, Type.TRecord<"^.*$", Type.TRef<"Json">>]>;
+    } & {
+        Root: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"requested">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"settled">;
+            outcome: T;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"missing">;
+        }>]>;
+    }, {
+        kind: Type.TLiteral<"settled">;
+        outcome: T;
+    }, T>;
+}, T extends Type.TOptional<Type.TSchema> ? T extends Type.TReadonly<T> ? never : "outcome" : never>> & Required<Pick<{
+    kind: "settled";
+    outcome: import("typebox").StaticType<["Root"], "Decode", {
+        Json: Type.TUnion<[Type.TNull, Type.TBoolean, Type.TNumber, Type.TString, Type.TArray<Type.TRef<"Json">>, Type.TRecord<"^.*$", Type.TRef<"Json">>]>;
+    } & {
+        Root: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"requested">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"settled">;
+            outcome: T;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"missing">;
+        }>]>;
+    }, {
+        kind: Type.TLiteral<"settled">;
+        outcome: T;
+    }, T>;
+}, Exclude<"kind", (T extends Type.TReadonly<Type.TSchema> ? T extends Type.TOptional<T> ? "outcome" : never : never) | (T extends Type.TReadonly<Type.TSchema> ? T extends Type.TOptional<T> ? never : "outcome" : never) | (T extends Type.TOptional<Type.TSchema> ? T extends Type.TReadonly<T> ? never : "outcome" : never)> | Exclude<"outcome", (T extends Type.TReadonly<Type.TSchema> ? T extends Type.TOptional<T> ? "outcome" : never : never) | (T extends Type.TReadonly<Type.TSchema> ? T extends Type.TOptional<T> ? never : "outcome" : never) | (T extends Type.TOptional<Type.TSchema> ? T extends Type.TReadonly<T> ? never : "outcome" : never)>>> extends infer T_2 ? { [K in keyof T_2]: T_2[K]; } : never) extends infer T_1 extends Record<PropertyKey, unknown> ? { [Key in keyof T_1]: T_1[Key]; } : never) | {
+    kind: "missing";
+}>;
+export declare const RunViewSchema: Schema<RunView>;
+export declare const RunEndSchema: Schema<RunEnd>;
+export declare const WaitTargetSchema: Schema<WaitTarget>;
+export declare const ExecutionSchema: Schema<Execution>;
+export declare const BackgroundItemSchema: Schema<BackgroundItem>;
+export declare const WaitOutcomeSchema: Schema<WaitOutcome>;
+export type StopOutcome<O> = {
+    readonly kind: "requested";
+} | {
+    readonly kind: "settled";
+    readonly outcome: O;
+} | {
+    readonly kind: "missing";
+};
+export {};

package/dist/src/runs.js

@@ -0,0 +1,39 @@
+import {
+  RunViewType2,
+  RunEndType2,
+  WaitTargetType2,
+  ExecutionType2,
+  BackgroundItemType2,
+  WaitOutcomeType2,
+  stopOutcomeSchema2,
+  RunViewSchema2,
+  RunEndSchema2,
+  WaitTargetSchema2,
+  ExecutionSchema2,
+  BackgroundItemSchema2,
+  WaitOutcomeSchema2
+} from "../chunks/browser-s7907azt.js";
+import"../chunks/browser-40enyw9r.js";
+import"../chunks/browser-m0wzr0g8.js";
+import"../chunks/browser-vapnjwp3.js";
+import"../chunks/browser-8t9anqfc.js";
+import"../chunks/browser-sgwxbek9.js";
+import"../chunks/browser-1sfp0bcx.js";
+import"../chunks/browser-4et7qtz3.js";
+import"../chunks/browser-ypez6s7v.js";
+import"../chunks/browser-vzc3r2r3.js";
+export {
+  BackgroundItemSchema2 as BackgroundItemSchema,
+  BackgroundItemType2 as BackgroundItemType,
+  ExecutionSchema2 as ExecutionSchema,
+  ExecutionType2 as ExecutionType,
+  RunEndSchema2 as RunEndSchema,
+  RunEndType2 as RunEndType,
+  RunViewSchema2 as RunViewSchema,
+  RunViewType2 as RunViewType,
+  WaitOutcomeSchema2 as WaitOutcomeSchema,
+  WaitOutcomeType2 as WaitOutcomeType,
+  WaitTargetSchema2 as WaitTargetSchema,
+  WaitTargetType2 as WaitTargetType,
+  stopOutcomeSchema2 as stopOutcomeSchema
+};

package/dist/src/schema.d.ts

@@ -0,0 +1,14 @@
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+import type { StaticDecode, TSchema } from "typebox";
+import type { Validator } from "typebox/compile";
+import type { Json } from "./json.ts";
+export type Schema<T> = StandardSchemaV1<unknown, T> & StandardJSONSchemaV1<unknown, T>;
+export type Infer<S extends StandardSchemaV1> = StandardSchemaV1.InferOutput<S>;
+type Frozen<T> = [Json] extends [T] ? T : T extends string | number | boolean | bigint | symbol | null | undefined | Uint8Array ? T : {
+    readonly [K in keyof T]: Frozen<T[K]>;
+};
+/** The value a TypeBox schema decodes to, read-only all the way down: every concept's TypeScript type is this of its schema. */
+export type Decoded<S extends TSchema> = Frozen<StaticDecode<S>>;
+export declare function compile<T extends TSchema>(schema: T): Validator<{}, T>;
+export declare function standard<T extends TSchema>(schema: T): Schema<StaticDecode<T>>;
+export {};

package/dist/src/schema.js

@@ -0,0 +1,8 @@
+import {
+  compile2,
+  standard2
+} from "../chunks/browser-vzc3r2r3.js";
+export {
+  compile2 as compile,
+  standard2 as standard
+};

package/dist/src/serial.d.ts

@@ -0,0 +1,18 @@
+/** Tasks that run one at a time, in the order they were queued. */
+export interface Serial {
+    /** Runs `task` once every task queued before it has settled. An earlier failure neither skips `task` nor rejects its result. */
+    run<T>(task: () => Promise<T>): Promise<T>;
+    /** Resolves, never rejects, once every task queued so far has settled. */
+    settled(): Promise<void>;
+    /** Whether a queued task has not settled yet. */
+    readonly busy: boolean;
+}
+/** Tasks that run one at a time per key; tasks under different keys run independently. */
+export interface KeyedSerial<K> {
+    /** Runs `task` once every task queued under `key` before it has settled, as {@link Serial.run} does. */
+    run<T>(key: K, task: () => Promise<T>): Promise<T>;
+}
+/** Returns an empty {@link Serial}. */
+export declare function serial(): Serial;
+/** Returns an empty {@link KeyedSerial}. It holds a key only while that key has tasks queued. */
+export declare function keyedSerial<K>(): KeyedSerial<K>;