@nyte-ai/host 0.0.0-stage → 0.0.18

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,42 @@
+import type { Models } from "@nyte-ai/ai";
+import type { WorkspaceTarget } from "@nyte-ai/schema";
+import type { Host, OpenOptions, Plugin, Store } from "@nyte-ai/core";
+/**
+ * Describes what `openHost` takes: `OpenOptions` with `store`, `workspace`,
+ * `models` and `plugins` optional, `secrets` defaulting to this machine's key,
+ * and the home directory holding `.nyte`. Every `OpenOptions` is one, so the
+ * sdk's Node `open` passes its options straight through.
+ */
+export type OpenHostOptions = Omit<OpenOptions, "store" | "workspace" | "models" | "plugins"> & {
+    /** The host's store; absent, `sqliteStore` at `<home>/.nyte/nyte.db`, which the host then closes with itself (§51c). */
+    readonly store?: Store;
+    /** Where a root session acts when `create` names none; default the local folder `process.cwd()` (§51c). */
+    readonly workspace?: WorkspaceTarget;
+    /** The `@nyte-ai/ai` catalog; absent, `nyteModels` over this host's encrypted credential store (§42e). */
+    readonly models?: Models;
+    /** Core plugins loaded after the first-party built-ins and before the plugin files; default none. One with a built-in's id replaces that built-in, as a bundled client's `codemode` runtime does, and a `local` environment provider among them replaces the default one. */
+    readonly plugins?: readonly Plugin<"core">[];
+    /** The directory whose `.nyte` holds the store, settings, plugins, secrets key and identity key; default `os.homedir()`. */
+    readonly home?: string;
+    /** The login shell the default local provider's pty jobs run, read at each start; absent or null is `$SHELL`. */
+    readonly shell?: () => string | null;
+};
+/**
+ * Opens the Node host the sdk's Node `open` calls: `composeHost` with
+ * `home` (default `os.homedir()`), `store` (default `<home>/.nyte/nyte.db`,
+ * checked every 500 ms for another process's commits, which are then read so
+ * a second process on the file sees the first one's runs live),
+ * `workspace` (default the local folder `process.cwd()`), `secrets` (default
+ * `defaultSecrets(home)`), `models` (default `nyteModels`), `localProvider`
+ * unless a plugin provides the `local` environment, every first-party plugin
+ * of `@nyte-ai/plugin` that `plugins` does not replace by id, then `plugins`
+ * and `filePlugins`' files, `settingsSeed`'s seed and
+ * `hostDescription()`; each file that did not load becomes a
+ * `server.report` row. The host's `loadPlugins` is `pluginLoader` over
+ * the plugin directories (§47l), which `watchPlugins` watches for hot reload
+ * (§49a). `listen` defaults `identity` to `identitySigner(host.hostId, home)`
+ * and `describe` to the description; nothing here reads the secrets key, even
+ * with a credential stored (§50d, §55). `close()` stops the watch, closes the
+ * open listeners, the host, then a store it opened.
+ */
+export declare function openHost(options: OpenHostOptions): Promise<Host>;

package/dist/src/open.js

@@ -0,0 +1,44 @@
+import {
+  openHost2
+} from "../chunks/canvas-preview-vax9ne4e.js";
+import"../chunks/canvas-preview-4e0pxa32.js";
+import"../chunks/canvas-preview-9aqczacs.js";
+import"../chunks/canvas-preview-yrfz2ak6.js";
+import"../chunks/canvas-preview-rp6fz0w5.js";
+import"../chunks/canvas-preview-xn10d4f8.js";
+import"../chunks/canvas-preview-75db60xy.js";
+import"../chunks/canvas-preview-1sq7z9jq.js";
+import"../chunks/canvas-preview-ehf3vp31.js";
+import"../chunks/canvas-preview-senpjwep.js";
+import"../chunks/canvas-preview-tjhabynd.js";
+import"../chunks/canvas-preview-8xgt67ka.js";
+import"../chunks/canvas-preview-h8hshnff.js";
+import"../chunks/canvas-preview-5z63am63.js";
+import"../chunks/canvas-preview-vaatfznm.js";
+import"../chunks/canvas-preview-ymgz0937.js";
+import"../chunks/canvas-preview-kn7kvbfj.js";
+import"../chunks/canvas-preview-azg56359.js";
+import"../chunks/canvas-preview-yjz0f7n4.js";
+import"../chunks/canvas-preview-zn2d0k9d.js";
+import"../chunks/canvas-preview-s94ebwf5.js";
+import"../chunks/canvas-preview-kdqgrstc.js";
+import"../chunks/canvas-preview-evh92ywd.js";
+import"../chunks/canvas-preview-zaaj99wd.js";
+import"../chunks/canvas-preview-a3yw0j70.js";
+import"../chunks/canvas-preview-98aj5p34.js";
+import"../chunks/canvas-preview-76fwvd6e.js";
+import"../chunks/canvas-preview-d9wwhbtz.js";
+import"../chunks/canvas-preview-m02v4yy6.js";
+import"../chunks/canvas-preview-rp4x6y1h.js";
+import"../chunks/canvas-preview-skzwvw4d.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-m02v4yy6.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-d9wwhbtz.js";
+import"../../chunks/canvas-preview-m02v4yy6.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>;

package/dist/src/shell-env.js

@@ -0,0 +1,108 @@
+// src/shell-env.ts
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { holdProcessEnvironment } from "@nyte-ai/core/server";
+var TIMEOUT_MS = 1e4;
+var OUTPUT_LIMIT = 64 * 1024;
+var SHELL_LOCAL = new Set(["PWD", "OLDPWD", "SHLVL", "_"]);
+var shared;
+function completeShellEnvironment() {
+  if (shared === undefined) {
+    shared = createShellEnvironmentRepair();
+    holdProcessEnvironment(shared());
+  }
+  return shared();
+}
+function createShellEnvironmentRepair({
+  env = process.env,
+  platform = process.platform,
+  timeoutMs = TIMEOUT_MS
+} = {}) {
+  let attempt;
+  return () => {
+    attempt ??= repairShellEnvironment({ env, platform, timeoutMs });
+    return attempt;
+  };
+}
+async function repairShellEnvironment({
+  env,
+  platform,
+  timeoutMs
+}) {
+  const shell = env.SHELL || "/bin/sh";
+  if (platform === "win32" || !isAbsolute(shell))
+    return;
+  const inheritedPath = env.PATH;
+  const loaded = await readLoginShellEnvironment({ shell, env, timeoutMs });
+  if (loaded === undefined)
+    return;
+  for (const [name, value] of loaded) {
+    if (name !== "PATH" && !SHELL_LOCAL.has(name))
+      env[name] = value;
+  }
+  const path = loaded.get("PATH");
+  if (path === undefined || path === "")
+    return;
+  env.PATH = inheritedPath ? `${path}:${inheritedPath}` : path;
+}
+function readLoginShellEnvironment({
+  shell,
+  env,
+  timeoutMs
+}) {
+  return new Promise((resolve) => {
+    const marker = `nyte-env-${randomUUID()}`;
+    const fence = `\x00${marker}\x00`;
+    const printFence = `printf '\\000${marker}\\000'`;
+    const child = spawn(shell, ["-ilc", `${printFence}; /usr/bin/env -0; ${printFence}`], {
+      env,
+      detached: true,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const chunks = [];
+    let bytes = 0;
+    let settled = false;
+    const finish = (loaded) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      child.stdout.destroy();
+      child.kill("SIGKILL");
+      resolve(loaded);
+    };
+    const timer = setTimeout(() => finish(undefined), timeoutMs);
+    child.on("error", () => finish(undefined));
+    child.stdout.on("error", () => finish(undefined));
+    child.stdout.on("data", (chunk) => {
+      bytes += chunk.byteLength;
+      if (bytes > OUTPUT_LIMIT) {
+        finish(undefined);
+        return;
+      }
+      chunks.push(chunk);
+    });
+    child.on("close", (code) => {
+      const [, fenced, ...after] = Buffer.concat(chunks).toString("utf8").split(fence);
+      if (code !== 0 || fenced === undefined || after.length === 0) {
+        finish(undefined);
+        return;
+      }
+      finish(parseEnvironment(fenced));
+    });
+  });
+}
+function parseEnvironment(output) {
+  const loaded = new Map;
+  for (const entry of output.split("\x00")) {
+    const [name = "", ...value] = entry.split("=");
+    if (name !== "" && value.length > 0)
+      loaded.set(name, value.join("="));
+  }
+  return loaded;
+}
+export {
+  completeShellEnvironment,
+  createShellEnvironmentRepair
+};

package/dist/src/sqlite-workers.d.ts

@@ -0,0 +1,6 @@
+import type { DatabaseSync, SQLInputValue } from "node:sqlite";
+export declare function sqliteWorkers(database: DatabaseSync, path: string): {
+    check: () => void;
+    read(sql: string, params: readonly SQLInputValue[]): Promise<readonly Record<string, string | number | bigint | null>[] | undefined>;
+    close(): Promise<void>;
+};

package/dist/src/sqlite-workers.js

@@ -0,0 +1,6 @@
+import {
+  sqliteWorkers2
+} from "../chunks/canvas-preview-zaaj99wd.js";
+export {
+  sqliteWorkers2 as sqliteWorkers
+};

package/dist/src/sqlite.d.ts

@@ -0,0 +1,7 @@
+import type { Store } from "@nyte-ai/core";
+/** Returns a `Store` over one `node:sqlite` `DatabaseSync`: a file at `path` (WAL mode, opened only by the process that `claimStore` makes its owner, so a second process rejects with `SdkError("unavailable")` before it reads or migrates the file) or an in-memory database. The first `open()` brings it to core's `STORE_VERSION` with `migrateStore` (core's `objects`, `refs`, `log` and `store_meta` tables; each commit one `BEGIN IMMEDIATE`), a file store whose migration rewrites records first saving those refs' rows (name, target, revision; objects are never deleted, so the rows restore them) to `backups/store-<time>-<pid>-<uuid>-v<from>-v<to>.json` beside it, keeping the newest three backups, and rejects with `SdkError("unavailable")` for a store a newer Nyte migrated; a `migrations` table an older Nyte left is kept and ignored. `put` ids the value with core's `objectId` and stores its JSON once; `putBlob` buffers the stream, ids it with `blobId` and stores the bytes once; an object and a blob that share an id share the row, each column filled once (§41f); `blob` reads the bytes back with their size and a null mime. `refs.set` is one `BEGIN IMMEDIATE` transaction with `RefStore.set`'s semantics, each revision a random UUID, that first rejects with `SdkError("unavailable")` when a newer Nyte has migrated the store since it opened. `list(prefix)` reads the name range from `prefix` in name order (BINARY, by code point); `log` returns the events after `after` in seq order up to `limit`, each validated as a `SessionEvent`; `tail` is the session's last seq, or 0; `commitMark` is the writer connection's `PRAGMA data_version`, which moves only for another connection's commit. `checkpoints` keeps one fold checkpoint per session in `fold_checkpoints`, a write at a lower seq leaving the kept one, and `gap` counts a session's events past a seq and sums their UTF-8 bytes. File stores run `list` and `log` on a read-only worker and WAL checkpoints on a separate worker, checking at 1,000 frames and after 100 ms idle with a 10,000-frame writer backstop; unavailable workers warn and fall back to the main connection. Checkpoints use fullfsync on macOS, WAL reuse retains at most 32 MiB, and opening refreshes planner statistics. Writes binding more than 64 KiB use uncached statements. Every `open()` returns a connection over the one writer; `close()` waits for opening and worker shutdown before closing it, and an open during close waits to reopen. */
+export declare function sqliteStore(input: {
+    readonly path: string;
+} | {
+    readonly memory: true;
+}): Store;

package/dist/src/sqlite.js

@@ -0,0 +1,10 @@
+import {
+  sqliteStore2
+} from "../chunks/canvas-preview-evh92ywd.js";
+import"../chunks/canvas-preview-zaaj99wd.js";
+import"../chunks/canvas-preview-a3yw0j70.js";
+import"../chunks/canvas-preview-0cmbkp2j.js";
+import"../chunks/canvas-preview-69fkk9yn.js";
+export {
+  sqliteStore2 as sqliteStore
+};

package/dist/src/store-owner.d.ts

@@ -0,0 +1,15 @@
+import { SdkError } from "@nyte-ai/schema";
+/** Another live process owns the store, so this one can't open it; the message names the owner. */
+export declare class StoreOwned extends SdkError {
+    constructor(message: string);
+}
+/**
+ * Makes this process the one owner of the file store at `path`, which alone opens,
+ * migrates and writes it, and returns what gives the claim up. The claim is a write lock
+ * this process holds on `<path>.owner`, a SQLite file whose one row names the owner's pid,
+ * program and store version; the operating system drops the lock when the process exits,
+ * so a crashed owner leaves no claim to clear. Claims of one path in this process share
+ * the lock until the last is given up. Throws `StoreOwned`, an `SdkError("unavailable")`
+ * naming the owner, when another process holds the claim.
+ */
+export declare function claimStore(path: string): () => void;

package/dist/src/store-owner.js

@@ -0,0 +1,9 @@
+import {
+  StoreOwned2,
+  claimStore2
+} from "../chunks/canvas-preview-a3yw0j70.js";
+import"../chunks/canvas-preview-69fkk9yn.js";
+export {
+  StoreOwned2 as StoreOwned,
+  claimStore2 as claimStore
+};