@nyte-ai/host 0.0.0-stage → 0.0.19

package/dist/src/mcp/hub.d.ts

@@ -0,0 +1,19 @@
+import type { McpHubFactory } from "@nyte-ai/core/server";
+import type { McpConnector } from "./connect.ts";
+/**
+ * Serves the servers in `<home>/.nyte/mcp.json`, and in a trusted local
+ * workspace's `.nyte/mcp.json`, to the host's sessions. Each file is watched
+ * (created, edited, replaced or removed) without polling, and an edit applies
+ * once the file system reports it: a changed server reconnects, an unchanged
+ * one keeps its connection. A workspace's connections close 30 seconds after its last
+ * watcher stops.
+ *
+ * @example
+ * ```ts
+ * const host = await openHost({ ...options, mcp: createMcpHub({ home: homedir() }) });
+ * ```
+ */
+export declare function createMcpHub(input: {
+    readonly home: string;
+    readonly connect?: McpConnector;
+}): McpHubFactory;

package/dist/src/mcp/hub.js

@@ -0,0 +1,11 @@
+import {
+  createMcpHub2
+} from "../../chunks/canvas-preview-g5fkjs34.js";
+import"../../chunks/canvas-preview-pkzqg96v.js";
+import"../../chunks/canvas-preview-5z63am63.js";
+import"../../chunks/canvas-preview-vaatfznm.js";
+import"../../chunks/canvas-preview-kdqgrstc.js";
+import"../../chunks/canvas-preview-mgcx2b2p.js";
+export {
+  createMcpHub2 as createMcpHub
+};

package/dist/src/mcp/oauth.d.ts

@@ -0,0 +1,46 @@
+import type { AuthProvider } from "@earendil-works/pi-mcp";
+import type { McpOAuthStateStore, OAuthChallenge } from "@earendil-works/pi-mcp/oauth";
+import type { Login, PluginStorage } from "@nyte-ai/core";
+/** A server's OAuth options with `${VAR}`s resolved. */
+export type McpOAuthSettings = {
+    readonly clientId?: string;
+    readonly clientSecret?: string;
+    readonly callbackPort?: number;
+    readonly callbackUrl?: string;
+    readonly clientName?: string;
+    readonly scope?: string;
+    readonly authServerMetadataUrl?: URL;
+};
+/** The secret a server's OAuth state lives under: by name and URL, so one URL under two names signs in twice. */
+export declare function oauthKey(server: string, url: string): string;
+/** Keeps one server's OAuth state in the host's sealed secrets. */
+export declare function oauthStore(secrets: PluginStorage["secrets"], key: string): McpOAuthStateStore;
+/**
+ * Sends a connection's stored access token and refreshes it before it
+ * expires or after a 401, one refresh at a time. It never opens a browser:
+ * when only a new sign-in helps, including a server asking for more scope,
+ * it throws `McpOAuthAuthorizationRequiredError`. `onChallenge` keeps the
+ * server's `WWW-Authenticate` challenge for the sign-in.
+ */
+export declare function createAuthProvider(input: {
+    readonly serverUrl: string;
+    readonly store: McpOAuthStateStore;
+    readonly settings: () => McpOAuthSettings;
+    onChallenge(challenge: OAuthChallenge): void;
+}): AuthProvider;
+/**
+ * Signs in to a server: refreshes stored tokens when that is enough, or
+ * runs the browser authorization code flow against a loopback callback.
+ * The returned login's steps are `open` (the authorization page), `paste`
+ * (answer with the redirect URL when the browser cannot reach this
+ * machine), then `done` or `failed`. Ending the steps cancels the sign-in.
+ */
+export declare function signIn(input: {
+    readonly server: string;
+    readonly serverUrl: string;
+    readonly store: McpOAuthStateStore;
+    readonly settings: McpOAuthSettings;
+    readonly challenge: OAuthChallenge | null;
+    signedIn(): void;
+    ended(): void;
+}): Login;

package/dist/src/mcp/oauth.js

@@ -0,0 +1,12 @@
+import {
+  oauthKey2,
+  oauthStore2,
+  createAuthProvider2,
+  signIn2
+} from "../../chunks/canvas-preview-5z63am63.js";
+export {
+  createAuthProvider2 as createAuthProvider,
+  oauthKey2 as oauthKey,
+  oauthStore2 as oauthStore,
+  signIn2 as signIn
+};

package/dist/src/mcp/tools.d.ts

@@ -0,0 +1,29 @@
+import { McpClient } from "@earendil-works/pi-mcp";
+import type { CallToolResult, McpRequestOptions, Tool } from "@earendil-works/pi-mcp";
+import type { ToolDefinition } from "@nyte-ai/core";
+import type { McpExposure, ValidationIssue } from "@nyte-ai/schema";
+import type { McpServerEntry } from "./config.ts";
+/** The exposure `entry` gives `tool`: an exact `toolExposure` key, else the first matching pattern, else the server's. */
+export declare function toolExposure(entry: McpServerEntry, tool: string): McpExposure;
+/** A server's listed tools that sessions get, and why each of the others is left out. */
+export type CheckedTools = {
+    readonly usable: readonly Tool[];
+    readonly issues: readonly ValidationIssue[];
+};
+/**
+ * Splits a server's listed tools into those whose input schema is JSON Schema
+ * for an object, which providers accept, and an issue for each of the rest.
+ * A tool with a bad schema would fail every request that declares it, so no
+ * session gets it.
+ */
+export declare function checkToolSchemas(server: string, tools: readonly Tool[]): CheckedTools;
+/** Calls one of the server's tools over its live connection, its `traceparent` carried to the server; throws when the server is not connected. */
+export type McpCall = (name: string, args: Record<string, unknown>, options: McpRequestOptions & {
+    readonly traceparent?: string;
+}) => Promise<CallToolResult>;
+/** An `McpClient` whose requests carry a `traceparent` given in their options to the server in `params._meta`, where MCP's trace-context convention puts it. */
+export declare class TracingMcpClient extends McpClient {
+    request<Result = unknown>(method: string, params?: Record<string, unknown>, options?: McpRequestOptions): Promise<Result>;
+}
+/** Turns a server's listed tools into session tools named `mcp__<server>__<tool>`. */
+export declare function bridgeTools(entry: McpServerEntry, tools: readonly Tool[], call: McpCall): ToolDefinition[];

package/dist/src/mcp/tools.js

@@ -0,0 +1,12 @@
+import {
+  toolExposure2,
+  checkToolSchemas2,
+  TracingMcpClient2,
+  bridgeTools2
+} from "../../chunks/canvas-preview-vaatfznm.js";
+export {
+  TracingMcpClient2 as TracingMcpClient,
+  bridgeTools2 as bridgeTools,
+  checkToolSchemas2 as checkToolSchemas,
+  toolExposure2 as toolExposure
+};

package/dist/src/open.d.ts

@@ -0,0 +1,14 @@
+import type { Models } from "@nyte-ai/ai";
+import type { WorkspaceTarget } from "@nyte-ai/schema";
+import type { Host, OpenOptions, Plugin, Store } from "@nyte-ai/core";
+export type OpenHostOptions = Omit<OpenOptions, "store" | "workspace" | "models" | "plugins"> & {
+    readonly store?: Store;
+    readonly workspace?: WorkspaceTarget;
+    readonly models?: Models;
+    readonly plugins?: readonly Plugin<"core">[];
+    readonly home?: string;
+    readonly shell?: () => string | null;
+    readonly label?: string;
+    readonly onRevoked?: () => void;
+};
+export declare function openHost(options: OpenHostOptions): Promise<Host>;

package/dist/src/open.js

@@ -0,0 +1,46 @@
+import {
+  openHost2
+} from "../chunks/canvas-preview-cawy6vbz.js";
+import"../chunks/canvas-preview-4e0pxa32.js";
+import"../chunks/canvas-preview-y5y6ghaw.js";
+import"../chunks/canvas-preview-ec2mt7es.js";
+import"../chunks/canvas-preview-befkjea2.js";
+import"../chunks/canvas-preview-9aqczacs.js";
+import"../chunks/canvas-preview-e3vnkkc5.js";
+import"../chunks/canvas-preview-2jwbe14k.js";
+import"../chunks/canvas-preview-5ekjx6sw.js";
+import"../chunks/canvas-preview-8xc0vn7v.js";
+import"../chunks/canvas-preview-1sq7z9jq.js";
+import"../chunks/canvas-preview-vm9zdp2t.js";
+import"../chunks/canvas-preview-crmzxxt8.js";
+import"../chunks/canvas-preview-tjhabynd.js";
+import"../chunks/canvas-preview-g5fkjs34.js";
+import"../chunks/canvas-preview-pkzqg96v.js";
+import"../chunks/canvas-preview-5z63am63.js";
+import"../chunks/canvas-preview-vaatfznm.js";
+import"../chunks/canvas-preview-drctegz4.js";
+import"../chunks/canvas-preview-kn7kvbfj.js";
+import"../chunks/canvas-preview-yjz0f7n4.js";
+import"../chunks/canvas-preview-af86jz8t.js";
+import"../chunks/canvas-preview-s94ebwf5.js";
+import"../chunks/canvas-preview-kdqgrstc.js";
+import"../chunks/canvas-preview-tnqe7k0b.js";
+import"../chunks/canvas-preview-zaaj99wd.js";
+import"../chunks/canvas-preview-ycepb05s.js";
+import"../chunks/canvas-preview-w54ymtb3.js";
+import"../chunks/canvas-preview-aq5j4p25.js";
+import"../chunks/canvas-preview-55s0y68g.js";
+import"../chunks/canvas-preview-rp4x6y1h.js";
+import"../chunks/canvas-preview-skzwvw4d.js";
+import"../chunks/canvas-preview-bxnqt8cd.js";
+import"../chunks/canvas-preview-518dh8by.js";
+import"../chunks/canvas-preview-0cmbkp2j.js";
+import"../chunks/canvas-preview-69fkk9yn.js";
+import"../chunks/canvas-preview-0nq75h9k.js";
+import"../chunks/canvas-preview-5mex725c.js";
+import"../chunks/canvas-preview-31w7xm8z.js";
+import"../chunks/canvas-preview-wg80rbc2.js";
+import"../chunks/canvas-preview-mgcx2b2p.js";
+export {
+  openHost2 as openHost
+};

package/dist/src/plugins/loader.d.ts

@@ -0,0 +1,21 @@
+import type { ValidationIssue } from "@nyte-ai/schema";
+import type { Plugin } from "@nyte-ai/core";
+import type { ComposeOptions } from "@nyte-ai/core/server";
+/** Returns the core plugins in a plugin directory (`~/.nyte/plugins`, a workspace's `.nyte/plugins`), by file name: each `.ts`, `.mts`, `.js` or `.mjs` file directly in it and each subdirectory's `index` of those, loaded with a dynamic `import()` of its file URL. That `import()` is one of the two dynamic loads the rewrite allows (§41a), host-only, because a plugin file is code the owner placed there and its path is known only at run time; Node strips `.ts` types natively (erasable syntax only). The URL carries the file's modification time and size as a query, so a replaced file loads fresh instead of from the module cache. The default export must be a core plugin (an object with a string `id`, and, where present, `contribute` and `hooks` objects, an `activate` function and an `environment` with a string `kind` and `inspect` and `attach` functions); every file that does not load or export one is reported, together, as `SdkError("invalid")` with an issue per file naming it. A missing directory has none. */
+export declare function loadPluginFiles(dir: string): Promise<readonly {
+    readonly plugin: Plugin<"core">;
+    readonly path: string;
+}[]>;
+/** Returns a plugin directory's plugins as `loadPluginFiles` finds and imports them, but file by file: every file that loads, with its path, and every file that does not, with its path and one `error` issue (its `path` the file, `source.file` the file, the message `loadPluginFiles` would have put in its `invalid`), never rejecting for a bad file; a missing directory has neither. What `openHost` loads `~/.nyte/plugins` and a local workspace's `.nyte/plugins` through, so one bad file is reported on `HostView.plugins` instead of failing the open (§41j); `loadPluginFiles` becomes this, throwing its one `invalid` when anything failed. */
+export declare function loadPluginDirectory(dir: string): Promise<{
+    readonly loaded: readonly {
+        readonly plugin: Plugin<"core">;
+        readonly path: string;
+    }[];
+    readonly failed: readonly {
+        readonly path: string;
+        readonly issue: ValidationIssue;
+    }[];
+}>;
+/** Returns the host's `loadPlugins` (`composeHost({ loadPlugins })`), which `plugins.replace` and `plugins.check` load their files through (§40b, §47m): each path, resolved to its real path, must lie inside one of `dirs` (else `SdkError("denied")`) and is imported as `loadPluginFiles` imports a file; the plugins come back in path order. */
+export declare function pluginLoader(dirs: readonly string[]): NonNullable<ComposeOptions["loadPlugins"]>;

package/dist/src/plugins/loader.js

@@ -0,0 +1,11 @@
+import {
+  loadPluginFiles2,
+  loadPluginDirectory2,
+  pluginLoader2
+} from "../../chunks/canvas-preview-s94ebwf5.js";
+import"../../chunks/canvas-preview-mgcx2b2p.js";
+export {
+  loadPluginDirectory2 as loadPluginDirectory,
+  loadPluginFiles2 as loadPluginFiles,
+  pluginLoader2 as pluginLoader
+};

package/dist/src/postgres.d.ts

@@ -0,0 +1,19 @@
+import type { Store } from "@nyte-ai/core";
+/** Returns one pooled client: what `PostgresPool.connect` lends, a query at a time, released once. */
+export type PostgresClient = {
+    query(text: string, values?: readonly unknown[]): Promise<{
+        readonly rows: readonly Record<string, unknown>[];
+    }>;
+    release(): void;
+};
+/** Returns the pool `postgresStore` queries through, structurally, so `pg.Pool` and a pglite adapter both fit (§41c). */
+export type PostgresPool = {
+    connect(): Promise<PostgresClient>;
+    end(): Promise<void>;
+};
+/** Returns a `Store` over Postgres: a `pg` `Pool` of its own from `connectionString`, ended by `close()`, or the caller's `pool` (any `PostgresPool`, §41c), left open. The first `open()` brings it to core's `STORE_VERSION` with `migrateStore`, the sqlite store's tables with `bytes` as `BYTEA`, `seq`/`at` as `BIGINT` and `refs.name` collated `"C"` so `list` ranges and orders by code point as the other stores do; each commit is one transaction under an exclusive advisory lock, so instances opening at once serialize, and the open rejects with `SdkError("unavailable")` for a store a newer Nyte migrated. There is no backup. Semantics are the sqlite store's (§41f); each `refs.set` is one transaction on one pooled client that shares the migration's advisory lock, rejects with `SdkError("unavailable")` when a newer Nyte has migrated the store, then takes `pg_advisory_xact_lock` on every ref name and session it touches, in sorted order (a row lock cannot hold an absent ref or a session's next seq), then reads those refs and applies `RefStore.set`, rolling back on any error. Every `open()` returns a connection whose reads go through the pool. */
+export declare function postgresStore(input: {
+    readonly connectionString: string;
+} | {
+    readonly pool: PostgresPool;
+}): Store;

package/dist/src/postgres.js

@@ -0,0 +1,8 @@
+import {
+  postgresStore2
+} from "../chunks/canvas-preview-4b6sayhg.js";
+import"../chunks/canvas-preview-0cmbkp2j.js";
+import"../chunks/canvas-preview-69fkk9yn.js";
+export {
+  postgresStore2 as postgresStore
+};

package/dist/src/providers.d.ts

@@ -0,0 +1,16 @@
+import type { WorkspaceTarget } from "@nyte-ai/schema";
+import type { EnvironmentProvider, ExecutionEnv, GitApi, SnapshotsApi } from "@nyte-ai/core";
+/** Returns one booted or joined sandbox, what `sandboxProvider`'s `boot` answers: its identity (the one the provider's `inspect` answers for its target), its working directory, its files over the remote `FilesApi` contract (paths relative to `cwd`, §41j), its processes as jobs, `destroy`, which tears the sandbox down with its files and processes, and the optional `git` and `snapshots` seams of a sandbox that can serve them (§42c, §42n; paths relative to `cwd` too). */
+export type SandboxHandle = Pick<ExecutionEnv, "identity" | "cwd" | "files" | "exec"> & {
+    readonly git?: GitApi;
+    readonly snapshots?: SnapshotsApi;
+    destroy(): Promise<void>;
+};
+/** Returns the chat-only environment provider (`kind: "chat-only"`), node-free: a workspace with no files and no processes, for a host that only chats (a Durable Object). `inspect` answers any target with identity `"chat-only"`, `available` and no project sources; `attach` answers an `ExecutionEnv` with that identity and `cwd` `/` whose `files` see nothing — `read` answers `missing`, `stat` null, `bytes` throws `SdkError("unknown")`, `scan` and `search` answer `complete` alone, `find` no entries, `watch` yields nothing until its caller returns, `format` answers `unavailable { reason: "unsupported" }` — and refuse every change (`write`, `remove`, `upload` and a batch's `apply` throw `SdkError("unavailable")`), whose `exec` throws `SdkError("unavailable")`, and whose `close` resolves. No `git`, `snapshots`, `browser` or `destroy`. */
+export declare function chatOnlyProvider(): EnvironmentProvider;
+/** Returns an environment provider over remote sandboxes (`kind` default `"sandbox"`), node-free. `inspect` is `options.inspect`, else it answers the content hash of the target (core's `objectId`) as its identity, `available` and no project sources, booting nothing. `attach(target)` joins the sandbox this provider already booted for the target or boots it with `boot(target)` (one boot in flight per target, keyed by that hash; a failed boot is forgotten so the next attach boots again) and answers an `ExecutionEnv` with the handle's `identity`, `cwd`, `files` and `exec`, whose `close` detaches and leaves the sandbox running. `git` and `snapshots` are on the provider, `(env) => handle.git` and `(env) => handle.snapshots` for the handle behind an environment it attached, found by the environment's identity, which core's wraps pass through (§42c, §42o): a handle that has a seam serves it (`git` `available` to the workspace, snapshots taken around each run), and one without answers `undefined`, which the workspace sees as `git` `unsupported` and no snapshots — the baseline's "required for local and sandbox" unmet for that sandbox. `destroy(target)` calls the handle's `destroy` (joining the sandbox through `boot` first when this provider holds none for the target) and forgets it. No `browser`. */
+export declare function sandboxProvider(options: {
+    readonly kind?: string;
+    boot(target: WorkspaceTarget): Promise<SandboxHandle>;
+    readonly inspect?: EnvironmentProvider["inspect"];
+}): EnvironmentProvider;

package/dist/src/providers.js

@@ -0,0 +1,112 @@
+// src/providers.ts
+import { asId, SdkError } from "@nyte-ai/schema";
+import { closable } from "@nyte-ai/core";
+import { objectId } from "@nyte-ai/core/store";
+var CHAT_ONLY = asId("chat-only");
+function chatOnlyProvider() {
+  const env = {
+    identity: CHAT_ONLY,
+    cwd: "/",
+    files: chatOnlyFiles(),
+    async exec() {
+      throw new SdkError("unavailable", "A chat-only workspace runs no processes.");
+    },
+    close: async () => {
+      return;
+    }
+  };
+  return {
+    kind: "chat-only",
+    inspect: async () => ({
+      identity: CHAT_ONLY,
+      availability: { kind: "available" },
+      projectSources: []
+    }),
+    attach: async () => env
+  };
+}
+function sandboxProvider(options) {
+  const booted = new Map;
+  const attached = new Map;
+  const boot = async (target) => {
+    const key = await objectId(target);
+    const known = booted.get(key);
+    if (known !== undefined)
+      return known;
+    const booting = options.boot(target);
+    booted.set(key, booting);
+    booting.catch(() => {
+      if (booted.get(key) === booting)
+        booted.delete(key);
+    });
+    return booting;
+  };
+  return {
+    kind: options.kind ?? "sandbox",
+    inspect: options.inspect ?? (async (target) => ({
+      identity: asId(await objectId(target)),
+      availability: { kind: "available" },
+      projectSources: []
+    })),
+    async attach(target) {
+      const handle = await boot(target);
+      attached.set(handle.identity, handle);
+      return {
+        identity: handle.identity,
+        cwd: handle.cwd,
+        files: handle.files,
+        exec: (command, run) => handle.exec(command, run),
+        close: async () => {
+          return;
+        }
+      };
+    },
+    git: (env) => attached.get(env.identity)?.git,
+    snapshots: (env) => attached.get(env.identity)?.snapshots,
+    async destroy(target) {
+      const key = await objectId(target);
+      const handle = await (booted.get(key) ?? options.boot(target));
+      booted.delete(key);
+      if (attached.get(handle.identity) === handle)
+        attached.delete(handle.identity);
+      await handle.destroy();
+    }
+  };
+}
+function chatOnlyFiles() {
+  const refuse = async () => {
+    throw new SdkError("unavailable", "A chat-only workspace has no files to change.");
+  };
+  const plan = { put: () => plan, remove: () => plan, apply: refuse };
+  return {
+    read: async (path) => ({ kind: "missing", path }),
+    async bytes(path) {
+      throw new SdkError("unknown", `No file is at ${path}.`);
+    },
+    stat: async () => null,
+    write: refuse,
+    remove: refuse,
+    batch: () => plan,
+    format: async () => ({ kind: "unavailable", reason: "unsupported" }),
+    async* scan() {
+      yield { kind: "complete" };
+    },
+    find: async () => [],
+    async* search() {
+      yield { kind: "complete" };
+    },
+    watch: () => closable(() => ({
+      pull: () => new Promise(() => {
+        return;
+      }),
+      close: () => {
+        return;
+      }
+    })),
+    upload: refuse
+  };
+}
+export {
+  chatOnlyProvider,
+  sandboxProvider
+};

package/dist/src/secrets.d.ts

@@ -0,0 +1,12 @@
+import type { OpenOptions } from "@nyte-ai/core";
+/** Returns where a host gets the 32-byte key core encrypts secrets with: `OpenOptions.secrets` (decision 10). */
+export type SecretsSource = NonNullable<OpenOptions["secrets"]>;
+/**
+ * Returns the Node host's default secrets key: `<home>/.nyte/secret.key`, 32
+ * raw bytes read or minted by `readKeyFile` (decision 10; §43d as amended by
+ * §43i). The source memoises a resolved answer itself; a rejected one is not
+ * kept, so the next call reads again (§43k). The key is for secrets only: the
+ * host's identity has its own file (§50a). There is no keychain here, and
+ * the desktop uses this file as the tui and cli do (§55).
+ */
+export declare function defaultSecrets(home: string): SecretsSource;

package/dist/src/secrets.js

@@ -0,0 +1,8 @@
+import {
+  defaultSecrets2
+} from "../chunks/canvas-preview-skzwvw4d.js";
+import"../chunks/canvas-preview-wg80rbc2.js";
+import"../chunks/canvas-preview-mgcx2b2p.js";
+export {
+  defaultSecrets2 as defaultSecrets
+};

package/dist/src/serve/binding.d.ts

@@ -0,0 +1,39 @@
+import type { ByteReader, OutputFrame } from "@nyte-ai/schema";
+import type { Connection } from "@nyte-ai/core";
+import type { ServerHost } from "@nyte-ai/core/server";
+import type { ByteName, CallName, FrameName, OperationInput, OperationOutput } from "@nyte-ai/protocol";
+/** Returns what a row's binding receives besides its input: the request's body (the bytes of `files.write`, `job.write` and `files.upload`) and the client's abort signal. */
+export type BindingRequest = {
+    readonly body: ReadableStream<Uint8Array> | null;
+    readonly signal: AbortSignal;
+};
+/** Returns a byte row's answer: the reader and the headers the response adds (`X-Nyte-Version` for `files.bytes`, §40p). */
+type ByteBody = {
+    readonly reader: ByteReader;
+    readonly headers?: Readonly<Record<string, string>>;
+};
+/** Returns the bindings of the rows answered once. */
+export type CallBinding = {
+    readonly [N in CallName]: (input: OperationInput<N>, request: BindingRequest) => Promise<OperationOutput<N>>;
+};
+/** Returns the bindings of the rows answered with JSON frames. */
+export type FrameBinding = {
+    readonly [N in FrameName]: (input: OperationInput<N>, request: BindingRequest) => Promise<AsyncIterable<OperationOutput<N>>>;
+};
+/** Returns the bindings of the rows answered with bytes. */
+export type ByteBinding = {
+    readonly [N in ByteName]: (input: OperationInput<N>, request: BindingRequest) => Promise<ByteBody>;
+};
+/** Returns the binding of `job.output`, whose frames are framed bytes and control frames (§40h). */
+type OutputBinding = {
+    readonly "job.output": (input: OperationInput<"job.output">, request: BindingRequest) => Promise<AsyncIterable<OutputFrame>>;
+};
+/** Returns the server side of the table for one connection: each row takes its decoded input and the request's body and abort signal, and answers its output, its frames, or a byte reader; setup failures (authority, capability, unknown ids) reject before any frame. */
+export type Binding = CallBinding & FrameBinding & ByteBinding & OutputBinding;
+/** Describes what a binding needs beyond the connection: the server port, for the rows that carry a wire-only id (§40o) and `parts.create`. */
+export type BindingOptions = {
+    readonly server: ServerHost;
+};
+/** Returns each row bound to the call it names: ids bind handles on the connection, handles returned become ids, `Set`s and `Map`s become their wire forms; `head.move`, `files.batch` and `browser.open` go through the server port's wire operations with their wire id (§40o, §40x). `head.watch` sends the head's view from the host's fold whole, then each later view as its changes (`viewFrames`), the core watch marking the principal's seen tip (§40a, §54a). Authority is the caller's gate: the server checks each row's before binding. */
+export declare function bindConnection(connection: Connection, options: BindingOptions): Binding;
+export {};

package/dist/src/serve/binding.js

@@ -0,0 +1,6 @@
+import {
+  bindConnection2
+} from "../../chunks/canvas-preview-55s0y68g.js";
+export {
+  bindConnection2 as bindConnection
+};

package/dist/src/serve/handler.d.ts

@@ -0,0 +1,15 @@
+import type { Authority } from "@nyte-ai/schema";
+import type { Connection } from "@nyte-ai/core";
+import type { BindingOptions } from "./binding.ts";
+/** Describes the handler: how a request authenticates to a connection (with the headers its answer carries, such as a pairing's `X-Nyte-Credential`, §40j), what the binding needs, the body limit and the allowed origins. */
+export type HandlerOptions = BindingOptions & {
+    connection(request: Request): Promise<{
+        readonly connection: Connection;
+        readonly authority: ReadonlySet<Authority>;
+        readonly headers?: Readonly<Record<string, string>>;
+    }>;
+    readonly maxBodyBytes?: number;
+    readonly origins?: readonly string[];
+};
+/** Returns the whole protocol as one fetch handler: `POST /<name>` per row (anything else `unknown`), CORS for `origins`, the row's authority over the connection the request authenticates to, and the body limit (413). Calls answer JSON, watches and JSON streams server-sent events, byte rows an octet stream and `job.output` framed octets (§40h, §40w); the request's abort ends every stream. An error answers its encoded `SdkError` at the status `errorStatus` gives its code. */
+export declare function createHandler(options: HandlerOptions): (request: Request) => Promise<Response>;

package/dist/src/serve/handler.js

@@ -0,0 +1,8 @@
+import {
+  createHandler2
+} from "../../chunks/canvas-preview-aq5j4p25.js";
+import"../../chunks/canvas-preview-55s0y68g.js";
+import"../../chunks/canvas-preview-rp4x6y1h.js";
+export {
+  createHandler2 as createHandler
+};

package/dist/src/serve/stream-server.d.ts

@@ -0,0 +1,6 @@
+import type { Connection } from "@nyte-ai/core";
+export declare function createStreamChannels(): {
+    open(connection: Connection, signal: AbortSignal, deflate: boolean): Response;
+    start(connection: Connection, channelId: string, streamId: string, request: AbortSignal, serve: (signal: AbortSignal) => Promise<Response>): Promise<Response>;
+    cancel(connection: Connection, channelId: string, streamId: string): void;
+};

package/dist/src/serve/stream-server.js

@@ -0,0 +1,6 @@
+import {
+  createStreamChannels2
+} from "../../chunks/canvas-preview-rp4x6y1h.js";
+export {
+  createStreamChannels2 as createStreamChannels
+};

package/dist/src/session-index.d.ts

@@ -0,0 +1,11 @@
+import type { SessionIndex } from "@nyte-ai/core";
+import type { Json, Revision } from "@nyte-ai/schema";
+type Binding = string | number | null;
+interface Statement {
+    readonly text: string;
+    readonly values: readonly Binding[];
+}
+export declare function sessionIndexChanges(name: string, object: Json | null, revision: Revision): readonly Statement[];
+export declare function sqlSessionIndex(read: (text: string, values: readonly Binding[]) => Promise<readonly Record<string, unknown>[]>): SessionIndex;
+export declare function postgresSessionIndexQuery(text: string): string;
+export {};

package/dist/src/session-index.js

@@ -0,0 +1,11 @@
+import {
+  sessionIndexChanges2,
+  sqlSessionIndex2,
+  postgresSessionIndexQuery2
+} from "../chunks/canvas-preview-0cmbkp2j.js";
+import"../chunks/canvas-preview-69fkk9yn.js";
+export {
+  postgresSessionIndexQuery2 as postgresSessionIndexQuery,
+  sessionIndexChanges2 as sessionIndexChanges,
+  sqlSessionIndex2 as sqlSessionIndex
+};

package/dist/src/shell-env.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Starts reading the login shell's environment into `process.env`, once per process, and holds
+ * every child spawn and provider auth env read (`processEnvironment()`) until it lands. The
+ * process itself goes on: a desktop app opened from the Dock inherits launchd's bare PATH and
+ * none of the rc files' API keys, and only what it spawns and what auth reads need the shell's.
+ * The read gives up after 10 s and keeps the inherited environment.
+ */
+export declare function completeShellEnvironment(): Promise<void>;
+/** Returns a repair that merges the login shell's environment into `env` on its first call; later calls share that attempt. */
+export declare function createShellEnvironmentRepair({ env, platform, timeoutMs, }?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    timeoutMs?: number;
+}): () => Promise<void>;