@nyte-ai/schema 0.0.0-stage → 0.0.19

package/dist/src/jobs.d.ts

@@ -0,0 +1,152 @@
+import { Type } from "typebox";
+import type { Decoded, Schema } from "./schema.ts";
+export declare const EndReasonType: Type.TEnum<["exited", "terminated", "expired", "host-lost"]>;
+export type EndReason = Decoded<typeof EndReasonType>;
+export declare const JobEndType: 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">;
+}>]>;
+export type JobEnd = Decoded<typeof JobEndType>;
+export declare const JobStateType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"running">;
+}>, 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">;
+}>]>]>;
+export type JobState = Decoded<typeof JobStateType>;
+export declare const JobViewType: Type.TObject<{
+    id: Type.TUnsafe<import("./ids.ts").Id<"job">>;
+    command: Type.TString;
+    title: Type.TString;
+    session: Type.TUnion<[Type.TUnsafe<import("./ids.ts").Id<"session">>, Type.TNull]>;
+    pty: Type.TUnion<[Type.TObject<{
+        columns: Type.TNumber;
+        rows: Type.TNumber;
+        shell: Type.TString;
+    }>, Type.TNull]>;
+    state: Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"running">;
+    }>, 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">;
+    }>]>]>;
+    startedAt: Type.TNumber;
+    endedAt: Type.TUnion<[Type.TNumber, Type.TNull]>;
+    tail: Type.TString;
+}>;
+export type JobView = Decoded<typeof JobViewType>;
+/** One job's move in a workspace's job list: its new view, or its removal once the list stops keeping it. */
+export declare const JobChangeType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"job">;
+    job: Type.TObject<{
+        id: Type.TUnsafe<import("./ids.ts").Id<"job">>;
+        command: Type.TString;
+        title: Type.TString;
+        session: Type.TUnion<[Type.TUnsafe<import("./ids.ts").Id<"session">>, Type.TNull]>;
+        pty: Type.TUnion<[Type.TObject<{
+            columns: Type.TNumber;
+            rows: Type.TNumber;
+            shell: Type.TString;
+        }>, Type.TNull]>;
+        state: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"running">;
+        }>, 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">;
+        }>]>]>;
+        startedAt: Type.TNumber;
+        endedAt: Type.TUnion<[Type.TNumber, Type.TNull]>;
+        tail: Type.TString;
+    }>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"forgotten">;
+    id: Type.TUnsafe<import("./ids.ts").Id<"job">>;
+}>]>;
+export type JobChange = Decoded<typeof JobChangeType>;
+/** A frame of `jobs.watch`: the whole list first (and again after a reconnect), then each job that moved, alone. */
+export declare const JobsChangeType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"jobs">;
+    jobs: Type.TArray<Type.TObject<{
+        id: Type.TUnsafe<import("./ids.ts").Id<"job">>;
+        command: Type.TString;
+        title: Type.TString;
+        session: Type.TUnion<[Type.TUnsafe<import("./ids.ts").Id<"session">>, Type.TNull]>;
+        pty: Type.TUnion<[Type.TObject<{
+            columns: Type.TNumber;
+            rows: Type.TNumber;
+            shell: Type.TString;
+        }>, Type.TNull]>;
+        state: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"running">;
+        }>, 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">;
+        }>]>]>;
+        startedAt: Type.TNumber;
+        endedAt: Type.TUnion<[Type.TNumber, Type.TNull]>;
+        tail: Type.TString;
+    }>>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"job">;
+    job: Type.TObject<{
+        id: Type.TUnsafe<import("./ids.ts").Id<"job">>;
+        command: Type.TString;
+        title: Type.TString;
+        session: Type.TUnion<[Type.TUnsafe<import("./ids.ts").Id<"session">>, Type.TNull]>;
+        pty: Type.TUnion<[Type.TObject<{
+            columns: Type.TNumber;
+            rows: Type.TNumber;
+            shell: Type.TString;
+        }>, Type.TNull]>;
+        state: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"running">;
+        }>, 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">;
+        }>]>]>;
+        startedAt: Type.TNumber;
+        endedAt: Type.TUnion<[Type.TNumber, Type.TNull]>;
+        tail: Type.TString;
+    }>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"forgotten">;
+    id: Type.TUnsafe<import("./ids.ts").Id<"job">>;
+}>]>;
+export type JobsChange = Decoded<typeof JobsChangeType>;
+/** The job list after `change`: the whole list it carries, the moved job in its place (or last, when new), or the list without a forgotten job. Every other job keeps its view object. */
+export declare function foldJobChange(jobs: readonly JobView[], change: JobsChange): readonly JobView[];
+/** A job's output: bytes it wrote (`stream: "stderr"` for its stderr when it runs with `stdio: "protocol"`), a `gap` where a reader missed some, and its exit. */
+export declare const OutputFrameType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"bytes">;
+    data: Type.TCodec<Type.TString, Uint8Array<ArrayBufferLike>>;
+    stream: Type.TOptional<Type.TLiteral<"stderr">>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"gap">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"exit">;
+    code: Type.TUnion<[Type.TNumber, Type.TNull]>;
+}>]>;
+export type OutputFrame = Decoded<typeof OutputFrameType>;
+export declare const EndReasonSchema: Schema<EndReason>;
+export declare const JobEndSchema: Schema<JobEnd>;
+export declare const JobStateSchema: Schema<JobState>;
+export declare const JobViewSchema: Schema<JobView>;
+export declare const OutputFrameSchema: Schema<OutputFrame>;

package/dist/src/jobs.js

@@ -0,0 +1,34 @@
+import {
+  EndReasonType2,
+  JobEndType2,
+  JobStateType2,
+  JobViewType2,
+  JobChangeType2,
+  JobsChangeType2,
+  foldJobChange2,
+  OutputFrameType2,
+  EndReasonSchema2,
+  JobEndSchema2,
+  JobStateSchema2,
+  JobViewSchema2,
+  OutputFrameSchema2
+} from "../chunks/browser-40enyw9r.js";
+import"../chunks/browser-m0wzr0g8.js";
+import"../chunks/browser-4et7qtz3.js";
+import"../chunks/browser-ypez6s7v.js";
+import"../chunks/browser-vzc3r2r3.js";
+export {
+  EndReasonSchema2 as EndReasonSchema,
+  EndReasonType2 as EndReasonType,
+  JobChangeType2 as JobChangeType,
+  JobEndSchema2 as JobEndSchema,
+  JobEndType2 as JobEndType,
+  JobStateSchema2 as JobStateSchema,
+  JobStateType2 as JobStateType,
+  JobViewSchema2 as JobViewSchema,
+  JobViewType2 as JobViewType,
+  JobsChangeType2 as JobsChangeType,
+  OutputFrameSchema2 as OutputFrameSchema,
+  OutputFrameType2 as OutputFrameType,
+  foldJobChange2 as foldJobChange
+};

package/dist/src/json.d.ts

@@ -0,0 +1,24 @@
+import { Type } from "typebox";
+import type { TCyclic, TProperties, TSchema } from "typebox";
+import type { Decoded, Schema } from "./schema.ts";
+export type Json = null | boolean | number | string | readonly Json[] | {
+    readonly [key: string]: Json;
+};
+declare const JSON_DEFINITION: Type.TUnion<[Type.TNull, Type.TBoolean, Type.TNumber, Type.TString, Type.TArray<Type.TRef<"Json">>, Type.TRecord<"^.*$", Type.TRef<"Json">>]>;
+export declare const JsonType: Type.TUnsafe<Json>;
+export declare const JsonObjectType: Type.TRecord<"^.*$", Type.TUnsafe<Json>>;
+export type JsonSchema = Decoded<typeof JsonObjectType>;
+export declare function cyclicWithJson<Definitions extends TProperties, Ref extends string>(definitions: Definitions, ref: Ref): TCyclic<{
+    Json: typeof JSON_DEFINITION;
+} & Definitions, Ref>;
+export declare function withJson<T extends TSchema>(schema: T): TCyclic<{
+    Json: typeof JSON_DEFINITION;
+} & {
+    Root: T;
+}, "Root">;
+export declare const JsonValueSchema: Schema<Json>;
+export declare const JsonObjectSchema: Schema<JsonSchema>;
+/** Walked by hand: under a renderer's CSP a cyclic TypeBox check runs interpreted, tens of milliseconds over a long chat's view frame. */
+export declare function isJson(value: unknown): value is Json;
+export declare function isJsonObject(value: Json | undefined): value is JsonSchema;
+export {};

package/dist/src/json.js

@@ -0,0 +1,21 @@
+import {
+  JsonType2,
+  JsonObjectType2,
+  cyclicWithJson2,
+  withJson2,
+  JsonValueSchema2,
+  JsonObjectSchema2,
+  isJson2,
+  isJsonObject2
+} from "../chunks/browser-sgwxbek9.js";
+import"../chunks/browser-vzc3r2r3.js";
+export {
+  JsonObjectSchema2 as JsonObjectSchema,
+  JsonObjectType2 as JsonObjectType,
+  JsonType2 as JsonType,
+  JsonValueSchema2 as JsonValueSchema,
+  cyclicWithJson2 as cyclicWithJson,
+  isJson2 as isJson,
+  isJsonObject2 as isJsonObject,
+  withJson2 as withJson
+};

package/dist/src/mcp.d.ts

@@ -0,0 +1,212 @@
+import { Type } from "typebox";
+import type { Decoded, Schema } from "./schema.ts";
+export declare const McpExposureType: Type.TEnum<["model", "deferred", "code", "hidden"]>;
+/**
+ * How a server's tools reach the model. `model` declares them, `deferred`
+ * leaves them for tool search, `code` makes them callable only from codemode
+ * scripts (the default), and `hidden` makes them unreachable.
+ */
+export type McpExposure = Decoded<typeof McpExposureType>;
+export declare const McpScopeType: Type.TEnum<["user", "project"]>;
+/** `user` servers come from `~/.nyte/mcp.json`; `project` servers from a trusted workspace's `.nyte/mcp.json`. */
+export type McpScope = Decoded<typeof McpScopeType>;
+export declare const McpToolViewType: Type.TObject<{
+    name: Type.TString;
+    description: Type.TString;
+    exposure: Type.TEnum<["model", "deferred", "code", "hidden"]>;
+}>;
+/** One tool as the server lists it; sessions see it as `mcp__<server>__<name>`. */
+export type McpToolView = Decoded<typeof McpToolViewType>;
+export declare const McpServerStateType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"disabled">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"connecting">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"connected">;
+    tools: Type.TArray<Type.TObject<{
+        name: Type.TString;
+        description: Type.TString;
+        exposure: Type.TEnum<["model", "deferred", "code", "hidden"]>;
+    }>>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"needs-sign-in">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"failed">;
+    message: Type.TString;
+    stderr: Type.TUnion<[Type.TString, Type.TNull]>;
+}>]>;
+/**
+ * A server's connection. `needs-sign-in` waits for the user: offer
+ * `workspace(id).mcp.login(name)`, and the server connects once it is done.
+ * Show `failed` with `message`, and `stderr` when a stdio server wrote any.
+ */
+export type McpServerState = Decoded<typeof McpServerStateType>;
+export declare const McpServerViewType: Type.TObject<{
+    name: Type.TString;
+    scope: Type.TEnum<["user", "project"]>;
+    /** The `mcp.json` that defines the server. */
+    path: Type.TString;
+    /** The project `mcp.json` whose override entry changes this user-level server, or `null`. */
+    override: Type.TUnion<[Type.TString, Type.TNull]>;
+    transport: Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"stdio">;
+        command: Type.TString;
+        args: Type.TArray<Type.TString>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"http">;
+        url: Type.TString;
+    }>]>;
+    exposure: Type.TEnum<["model", "deferred", "code", "hidden"]>;
+    description: Type.TUnion<[Type.TString, Type.TNull]>;
+    state: Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"disabled">;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"connecting">;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"connected">;
+        tools: Type.TArray<Type.TObject<{
+            name: Type.TString;
+            description: Type.TString;
+            exposure: Type.TEnum<["model", "deferred", "code", "hidden"]>;
+        }>>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"needs-sign-in">;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"failed">;
+        message: Type.TString;
+        stderr: Type.TUnion<[Type.TString, Type.TNull]>;
+    }>]>;
+}>;
+/** One configured server, with where it is defined and its connection now. */
+export type McpServerView = Decoded<typeof McpServerViewType>;
+export declare const McpViewType: Type.TObject<{
+    servers: Type.TArray<Type.TObject<{
+        name: Type.TString;
+        scope: Type.TEnum<["user", "project"]>;
+        /** The `mcp.json` that defines the server. */
+        path: Type.TString;
+        /** The project `mcp.json` whose override entry changes this user-level server, or `null`. */
+        override: Type.TUnion<[Type.TString, Type.TNull]>;
+        transport: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"stdio">;
+            command: Type.TString;
+            args: Type.TArray<Type.TString>;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"http">;
+            url: Type.TString;
+        }>]>;
+        exposure: Type.TEnum<["model", "deferred", "code", "hidden"]>;
+        description: Type.TUnion<[Type.TString, Type.TNull]>;
+        state: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"disabled">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"connecting">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"connected">;
+            tools: Type.TArray<Type.TObject<{
+                name: Type.TString;
+                description: Type.TString;
+                exposure: Type.TEnum<["model", "deferred", "code", "hidden"]>;
+            }>>;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"needs-sign-in">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"failed">;
+            message: Type.TString;
+            stderr: Type.TUnion<[Type.TString, Type.TNull]>;
+        }>]>;
+    }>>;
+    issues: Type.TArray<Type.TObject<{
+        severity: Type.TEnum<["error", "warning"]>;
+        path: Type.TArray<Type.TUnion<[Type.TString, Type.TNumber]>>;
+        message: Type.TString;
+        source: Type.TOptional<Type.TObject<{
+            plugin: Type.TString;
+            file: Type.TOptional<Type.TString>;
+            line: Type.TOptional<Type.TNumber>;
+        }>>;
+    }>>;
+}>;
+/**
+ * What `workspace(id).mcp()` yields: every server the workspace sees, sorted
+ * by name, and the problems found reading its `mcp.json` files or the tools
+ * its servers list. An invalid entry appears in `issues` and not in
+ * `servers`; the others still connect. A listed tool whose input schema is
+ * not JSON Schema appears in `issues` and not in its server's tools.
+ */
+export type McpView = Decoded<typeof McpViewType>;
+export declare const McpExposureNameType: Type.TEnum<["direct", "deferred", "codemode", "codemode-deferred", "hidden"]>;
+/** An exposure as `mcp.json` names it: `direct` is `model`, `codemode` (or `codemode-deferred`) is `code`. */
+export type McpExposureName = Decoded<typeof McpExposureNameType>;
+export declare const McpOAuthConfigType: Type.TObject<{
+    clientId: Type.TOptional<Type.TString>;
+    clientSecret: Type.TOptional<Type.TString>;
+    callbackPort: Type.TOptional<Type.TInteger>;
+    callbackUrl: Type.TOptional<Type.TString>;
+    clientName: Type.TOptional<Type.TString>;
+    scope: Type.TOptional<Type.TString>;
+    authServerMetadataUrl: Type.TOptional<Type.TString>;
+}>;
+/**
+ * How Nyte signs in to a url server that uses OAuth. Without it, Nyte
+ * registers itself as "Nyte" on a free loopback port. Set `clientId` (and
+ * `clientSecret`, which may name `${VAR}`) with `callbackPort` or
+ * `callbackUrl` for a server that needs a registered client, `clientName`
+ * for one that accepts only known names, `scope` for one that does not
+ * advertise its scopes, and `authServerMetadataUrl` for one that advertises
+ * the wrong authorization server.
+ */
+export type McpOAuthConfig = Decoded<typeof McpOAuthConfigType>;
+export declare const McpServerConfigType: Type.TUnion<[Type.TObject<{
+    type: Type.TOptional<Type.TLiteral<"stdio">>;
+    command: Type.TString;
+    args: Type.TOptional<Type.TArray<Type.TString>>;
+    env: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+    cwd: Type.TOptional<Type.TString>;
+    enabled: Type.TOptional<Type.TBoolean>;
+    /** Seconds each request may take; progress notifications restart it. Default 60. */
+    timeout: Type.TOptional<Type.TNumber>;
+    description: Type.TOptional<Type.TString>;
+    exposure: Type.TOptional<Type.TEnum<["direct", "deferred", "codemode", "codemode-deferred", "hidden"]>>;
+    /** Exposure per tool name; `*` matches any characters, exact names win, then the first matching pattern. */
+    toolExposure: Type.TOptional<Type.TRecord<"^.*$", Type.TEnum<["direct", "deferred", "codemode", "codemode-deferred", "hidden"]>>>;
+}>, Type.TObject<{
+    type: Type.TOptional<Type.TEnum<["http", "streamable-http"]>>;
+    url: Type.TString;
+    headers: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+    oauth: Type.TOptional<Type.TObject<{
+        clientId: Type.TOptional<Type.TString>;
+        clientSecret: Type.TOptional<Type.TString>;
+        callbackPort: Type.TOptional<Type.TInteger>;
+        callbackUrl: Type.TOptional<Type.TString>;
+        clientName: Type.TOptional<Type.TString>;
+        scope: Type.TOptional<Type.TString>;
+        authServerMetadataUrl: Type.TOptional<Type.TString>;
+    }>>;
+    enabled: Type.TOptional<Type.TBoolean>;
+    /** Seconds each request may take; progress notifications restart it. Default 60. */
+    timeout: Type.TOptional<Type.TNumber>;
+    description: Type.TOptional<Type.TString>;
+    exposure: Type.TOptional<Type.TEnum<["direct", "deferred", "codemode", "codemode-deferred", "hidden"]>>;
+    /** Exposure per tool name; `*` matches any characters, exact names win, then the first matching pattern. */
+    toolExposure: Type.TOptional<Type.TRecord<"^.*$", Type.TEnum<["direct", "deferred", "codemode", "codemode-deferred", "hidden"]>>>;
+}>]>;
+/**
+ * One `mcpServers` entry of `mcp.json`, the format other MCP clients use: a
+ * `command` run over stdio, or a streamable HTTP `url`. `env`, `headers` and
+ * `oauth.clientSecret` may name `${VAR}` environment variables.
+ */
+export type McpServerConfig = Decoded<typeof McpServerConfigType>;
+export declare const McpChangeType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"updated">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"missing">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"invalid">;
+    message: Type.TString;
+}>]>;
+/** What an MCP action did: `missing` names no configured server, `invalid` explains a refused change. */
+export type McpChange = Decoded<typeof McpChangeType>;
+export declare const McpViewSchema: Schema<McpView>;
+export declare const McpServerConfigSchema: Schema<McpServerConfig>;
+export declare const McpChangeSchema: Schema<McpChange>;

package/dist/src/mcp.js

@@ -0,0 +1,34 @@
+import {
+  McpExposureType2,
+  McpScopeType2,
+  McpToolViewType2,
+  McpServerStateType2,
+  McpServerViewType2,
+  McpViewType2,
+  McpExposureNameType2,
+  McpOAuthConfigType2,
+  McpServerConfigType2,
+  McpChangeType2,
+  McpViewSchema2,
+  McpServerConfigSchema2,
+  McpChangeSchema2
+} from "../chunks/browser-b519jtez.js";
+import"../chunks/browser-1sfp0bcx.js";
+import"../chunks/browser-4et7qtz3.js";
+import"../chunks/browser-ypez6s7v.js";
+import"../chunks/browser-vzc3r2r3.js";
+export {
+  McpChangeSchema2 as McpChangeSchema,
+  McpChangeType2 as McpChangeType,
+  McpExposureNameType2 as McpExposureNameType,
+  McpExposureType2 as McpExposureType,
+  McpOAuthConfigType2 as McpOAuthConfigType,
+  McpScopeType2 as McpScopeType,
+  McpServerConfigSchema2 as McpServerConfigSchema,
+  McpServerConfigType2 as McpServerConfigType,
+  McpServerStateType2 as McpServerStateType,
+  McpServerViewType2 as McpServerViewType,
+  McpToolViewType2 as McpToolViewType,
+  McpViewSchema2 as McpViewSchema,
+  McpViewType2 as McpViewType
+};

package/dist/src/messages.d.ts

@@ -0,0 +1,114 @@
+import { Type } from "typebox";
+import type { Decoded, Schema } from "./schema.ts";
+export declare const DeliveryType: Type.TEnum<["steer", "queue", "attach"]>;
+export type Delivery = Decoded<typeof DeliveryType>;
+export declare const ExcerptSourceType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"diff">;
+    path: Type.TString;
+    side: Type.TEnum<["old", "new"]>;
+    start: Type.TNumber;
+    end: Type.TNumber;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"terminal">;
+    command: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"browser">;
+    url: Type.TString;
+    selector: Type.TString;
+}>]>;
+/**
+ * Where an excerpt was taken from. A `diff` range names the file and the
+ * lines `start` to `end` on one side of its change: `new` counts in the file
+ * as it is now, `old` as it was before. A `terminal` selection names the
+ * command line its output followed, when one is known. A `browser` element
+ * names the page `url` and a CSS `selector` that finds it there.
+ */
+export type ExcerptSource = Decoded<typeof ExcerptSourceType>;
+export declare const UserContentType: Type.TUnion<[Type.TString, Type.TArray<Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"text">;
+    text: Type.TString;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"file">;
+    blob: Type.TUnsafe<import("./ids.ts").Id<"blob">>;
+    mime: Type.TString;
+    name: Type.TString;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"reference">;
+    path: Type.TString;
+    blob: Type.TOptional<Type.TUnsafe<import("./ids.ts").Id<"blob">>>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"skill">;
+    name: Type.TString;
+    location: Type.TString;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"excerpt">;
+    source: Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"diff">;
+        path: Type.TString;
+        side: Type.TEnum<["old", "new"]>;
+        start: Type.TNumber;
+        end: Type.TNumber;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"terminal">;
+        command: Type.TOptional<Type.TString>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"browser">;
+        url: Type.TString;
+        selector: Type.TString;
+    }>]>;
+    text: Type.TString;
+}>]>>]>;
+/**
+ * What a message says: text, or parts. A `file` is an attachment the client
+ * uploaded. A `reference` mentions a workspace file by `path`; the host reads
+ * it once when the message is sent and keeps that text as `blob`, so every
+ * request shows the model the file as it was then (a folder, or a file it
+ * cannot read, stays a bare mention). A `skill` asks the model to follow the
+ * skill at `location`. An `excerpt` is text the user took from a workbench
+ * panel, kept exactly as taken: a diff range's hunk, a terminal selection, or a
+ * page element's HTML; the model reads it with its `source`. Clients draw
+ * `reference`, `skill` and `excerpt` as chips.
+ */
+export type UserContent = Decoded<typeof UserContentType>;
+export declare const PositionType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"start">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"commit">;
+    id: Type.TUnsafe<import("./ids.ts").Id<"commit">>;
+}>]>;
+export type Position = Decoded<typeof PositionType>;
+export declare const MessageSourceType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"user">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"child">;
+    session: Type.TUnsafe<import("./ids.ts").Id<"session">>;
+    end: Type.TEnum<["completed", "stopped", "failed"]>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"job">;
+    job: Type.TUnsafe<import("./ids.ts").Id<"job">>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"shell">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"action">;
+    label: Type.TString;
+    command: Type.TOptional<Type.TString>;
+}>]>;
+export type MessageSource = Decoded<typeof MessageSourceType>;
+export declare const ScheduleType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"joined">;
+    run: Type.TUnsafe<import("./ids.ts").Id<"run">>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"next-turn">;
+    reason: Type.TEnum<["requested", "idle", "run-ended", "configuration"]>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"attached">;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"deciding">;
+}>]>;
+/** When an admitted input runs. `deciding` is a chat's first message, admitted with the chat while its before_send hooks decide it; nothing on its head runs until they do. */
+export type Schedule = Decoded<typeof ScheduleType>;
+export declare const DeliverySchema: Schema<Delivery>;
+export declare const UserContentSchema: Schema<UserContent>;
+export declare const PositionSchema: Schema<Position>;
+export declare const MessageSourceSchema: Schema<MessageSource>;
+export declare const ScheduleSchema: Schema<Schedule>;

package/dist/src/messages.js

@@ -0,0 +1,28 @@
+import {
+  DeliveryType2,
+  ExcerptSourceType2,
+  UserContentType2,
+  PositionType2,
+  MessageSourceType2,
+  ScheduleType2,
+  DeliverySchema2,
+  UserContentSchema2,
+  PositionSchema2,
+  MessageSourceSchema2,
+  ScheduleSchema2
+} from "../chunks/browser-hq5q56sf.js";
+import"../chunks/browser-ypez6s7v.js";
+import"../chunks/browser-vzc3r2r3.js";
+export {
+  DeliverySchema2 as DeliverySchema,
+  DeliveryType2 as DeliveryType,
+  ExcerptSourceType2 as ExcerptSourceType,
+  MessageSourceSchema2 as MessageSourceSchema,
+  MessageSourceType2 as MessageSourceType,
+  PositionSchema2 as PositionSchema,
+  PositionType2 as PositionType,
+  ScheduleSchema2 as ScheduleSchema,
+  ScheduleType2 as ScheduleType,
+  UserContentSchema2 as UserContentSchema,
+  UserContentType2 as UserContentType
+};

package/dist/src/model/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./message.ts";
+export * from "./model.ts";
+export * from "./text.ts";
+export * from "./tool.ts";
+export * from "./transcript.ts";
+export { typed } from "./typed.ts";