@nyte-ai/host 0.0.0-stage → 0.0.18

package/dist/src/deploy/vercel/server/utils/step.js

@@ -0,0 +1,6 @@
+import {
+  stepFrom2
+} from "../../../../../chunks/canvas-preview-65xqjw7f.js";
+export {
+  stepFrom2 as stepFrom
+};

package/dist/src/deploy/vercel/server/workflows/drive.d.ts

@@ -0,0 +1,14 @@
+import type { AdvanceReport, HeadName, SessionId } from "@nyte-ai/schema";
+/** Hands a head's wake to the workflow that drives it. */
+export declare function dispatchHead(target: {
+    readonly session: SessionId;
+    readonly head: HeadName;
+}): Promise<void>;
+export declare function driveHead(input: {
+    readonly session: SessionId;
+    readonly head: HeadName;
+}): Promise<void>;
+export declare function advanceHead(input: {
+    readonly session: SessionId;
+    readonly head: HeadName;
+}): Promise<AdvanceReport>;

package/dist/src/deploy/vercel/server/workflows/drive.js

@@ -0,0 +1,13 @@
+import {
+  dispatchHead2,
+  driveHead2,
+  advanceHead2
+} from "../../../../../chunks/canvas-preview-j1tnf51w.js";
+import"../../../../../chunks/canvas-preview-65xqjw7f.js";
+import"../../../../../chunks/canvas-preview-ewgspmsd.js";
+import"../../../../../chunks/canvas-preview-2zdyh9ny.js";
+export {
+  advanceHead2 as advanceHead,
+  dispatchHead2 as dispatchHead,
+  driveHead2 as driveHead
+};

package/dist/src/durable-object.d.ts

@@ -0,0 +1,14 @@
+import type { Store } from "@nyte-ai/core";
+/** Returns one value Durable Object SQL binds and answers: text, a number, a blob as an `ArrayBuffer`, or null. */
+export type SqlValue = ArrayBuffer | string | number | null;
+/** Returns the part of a Durable Object's storage `durableObjectStore` uses, structurally, so a Worker passes `state.storage` as it is and a test passes a shim: `sql.exec` runs one statement with `?` bindings and answers its rows keyed by column name, and `transactionSync` runs a synchronous closure whose writes land all together or, when it throws, not at all (Durable Object SQL refuses `BEGIN`, so this is the only transaction). */
+export type DurableObjectSql = {
+    readonly sql: {
+        exec(query: string, ...bindings: SqlValue[]): {
+            toArray(): Record<string, SqlValue>[];
+        };
+    };
+    transactionSync<T>(closure: () => T): T;
+};
+/** Returns a `Store` over a Durable Object's SQLite storage, node-free, with the sqlite store's tables, row helpers (`store-rows.ts`) and semantics (§41f): `objects(id TEXT PRIMARY KEY, body TEXT NULL, bytes BLOB NULL)`, `refs(name TEXT PRIMARY KEY, target TEXT NULL, revision TEXT NOT NULL)` and `log(session TEXT, seq INTEGER, at INTEGER, event TEXT, PRIMARY KEY (session, seq))`, brought to core's `STORE_VERSION` by `migrateStore` on first `open()`, each commit one `transactionSync` and no backup; the open rejects with `SdkError("unavailable")` for a store a newer Nyte migrated. `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 as an `ArrayBuffer`; an object and a blob that share an id share the row, each column filled once; `blob` reads the bytes back with their size and a null mime; a body, blob or logged event past the Durable Object's 2 MB row limit throws `SdkError("invalid")` before anything is written (§42k). `refs.set` runs inside one `transactionSync` with no await between its reads and writes, first rejecting with `SdkError("unavailable")` when a newer Nyte has migrated the store, with `RefStore.set`'s semantics, each revision a random UUID, any throw inside rolling the whole batch back. `list(prefix)` reads the name range from `prefix` in name order; `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. Every `open()` returns a connection over the one storage; `close()` releases nothing, the storage being the object's. In workerd, which allows code generation only while modules load, the Worker turns TypeBox acceleration off at startup (`Settings.Set({ useAcceleration: false })` from `typebox/system`, as `deploy/cloudflare/worker.ts` does), or `log`'s validation throws inside a request. */
+export declare function durableObjectStore(storage: DurableObjectSql): Store;

package/dist/src/durable-object.js

@@ -0,0 +1,231 @@
+import {
+  prefixEnd2,
+  mintRevision2,
+  decodeEvent2,
+  parseNumber2,
+  parseText2,
+  parseRef2,
+  parseStoredRecord2,
+  parseStoredObject2,
+  loggedRow2,
+  collect2,
+  memoryReader2
+} from "../chunks/canvas-preview-69fkk9yn.js";
+import {
+  sessionIndexChanges2,
+  sqlSessionIndex2
+} from "../chunks/canvas-preview-0cmbkp2j.js";
+
+// src/durable-object.ts
+import { asSeq, SdkError } from "@nyte-ai/schema";
+import {
+  admits,
+  fenceNames,
+  assertStoreVersion,
+  blobId,
+  decodeObject,
+  collectSessionEvents,
+  migrateStore,
+  objectId,
+  sessionIndexRef,
+  parseSessionRef
+} from "@nyte-ai/core/store";
+var ROW_LIMIT = 2000000;
+var encoder = new TextEncoder;
+function durableObjectStore(storage) {
+  let connection = null;
+  return {
+    async open() {
+      if (connection !== null)
+        return connection;
+      await migrateStore(durableObjectTarget(storage));
+      connection = connect(storage);
+      return connection;
+    },
+    async close() {
+      connection = null;
+    }
+  };
+}
+function storedVersion(storage) {
+  const stamped = storage.sql.exec("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'store_meta'").toArray();
+  if (stamped.length === 0)
+    return 0;
+  const version = storage.sql.exec("SELECT version FROM store_meta WHERE id = 1").toArray()[0]?.version;
+  return version === undefined ? 0 : parseNumber2(version);
+}
+function durableObjectTarget(storage) {
+  const rows = (query, ...bindings) => storage.sql.exec(query, ...bindings).toArray();
+  return {
+    dialect: "sqlite",
+    async stamp() {
+      const present = rows("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'refs'").length > 0;
+      return {
+        version: storedVersion(storage),
+        empty: !present || rows("SELECT 1 FROM refs LIMIT 1").length === 0
+      };
+    },
+    async records() {
+      return rows("SELECT refs.name, refs.target, refs.revision, objects.body FROM refs JOIN objects ON objects.id = refs.target WHERE objects.body IS NOT NULL").map(parseStoredRecord2);
+    },
+    async* objects(kind) {
+      yield* rows("SELECT id, body FROM objects WHERE body IS NOT NULL AND instr(body, ?) > 0", `"kind":${JSON.stringify(kind)}`).map(parseStoredObject2);
+    },
+    async* logs() {
+      if (rows("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'log'").length === 0)
+        return;
+      for (const row of rows("SELECT DISTINCT session FROM log")) {
+        const session = parseText2(row.session);
+        if (session !== null)
+          yield {
+            session,
+            events: rows("SELECT seq, event FROM log WHERE session = ? ORDER BY seq", session).map(loggedRow2)
+          };
+      }
+    },
+    async commit(change) {
+      return storage.transactionSync(() => {
+        if (storedVersion(storage) !== change.from)
+          return "moved";
+        const conflicted = change.repoints.some((moved) => rows("SELECT 1 FROM refs WHERE name = ? AND revision = ?", moved.name, moved.expect).length === 0);
+        const relogged = change.relogs.every((relog) => rows("SELECT 1 FROM log WHERE session = ? AND seq = ? AND event = ?", relog.session, relog.seq, relog.expect).length > 0);
+        if (conflicted || !relogged)
+          return "conflict";
+        for (const statement of change.sql)
+          rows(statement);
+        for (const moved of change.repoints) {
+          rows("INSERT INTO objects (id, body) VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET body = excluded.body WHERE objects.body IS NULL", moved.id, moved.body);
+          rows("UPDATE refs SET target = ?, revision = ? WHERE name = ?", moved.id, mintRevision2(), moved.name);
+          updateSessionIndex(storage, moved.name, moved.id, mintRevision2());
+        }
+        for (const created of change.creates) {
+          rows("INSERT INTO objects (id, body) VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET body = excluded.body WHERE objects.body IS NULL", created.target, created.body);
+          const revision = mintRevision2();
+          if (rows("INSERT INTO refs (name, target, revision) VALUES (?, ?, ?) ON CONFLICT (name) DO NOTHING RETURNING name", created.name, created.target, revision).length > 0)
+            updateSessionIndex(storage, created.name, created.target, revision);
+        }
+        for (const relog of change.relogs)
+          rows("UPDATE log SET event = ? WHERE session = ? AND seq = ?", relog.event, relog.session, relog.seq);
+        if (change.reindexSessions)
+          for (const row of rows("SELECT name, target, revision FROM refs")) {
+            const ref = parseRef2(row);
+            updateSessionIndex(storage, ref.name, ref.target, ref.revision);
+          }
+        rows("INSERT INTO store_meta (id, version) VALUES (1, ?) ON CONFLICT (id) DO UPDATE SET version = excluded.version", change.to);
+        return "committed";
+      });
+    }
+  };
+}
+function connect(storage) {
+  const rows = (query, ...bindings) => storage.sql.exec(query, ...bindings).toArray();
+  const tail = (session) => {
+    const value = rows("SELECT MAX(seq) AS tail FROM log WHERE session = ?", session)[0]?.tail;
+    return asSeq(value === null || value === undefined ? 0 : parseNumber2(value));
+  };
+  const ref = (name) => {
+    const row = rows("SELECT name, target, revision FROM refs WHERE name = ?", name)[0];
+    return row === undefined ? null : parseRef2(row);
+  };
+  return {
+    sessions: sqlSessionIndex2(async (text, values) => rows(text, ...values)),
+    objects: {
+      async put(object) {
+        const id = await objectId(object);
+        const body = JSON.stringify(object);
+        fits(encoder.encode(body).byteLength, `Object ${id}`);
+        rows("INSERT INTO objects (id, body) VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET body = excluded.body WHERE objects.body IS NULL", id, body);
+        return id;
+      },
+      async get(id) {
+        const body = parseText2(rows("SELECT body FROM objects WHERE id = ?", id)[0]?.body);
+        return body === null ? null : decodeObject(body);
+      },
+      async putBlob(bytes) {
+        const joined = await collect2(bytes);
+        const id = await blobId(joined);
+        fits(joined.byteLength, `Blob ${id}`);
+        rows("INSERT INTO objects (id, bytes) VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET bytes = excluded.bytes WHERE objects.bytes IS NULL", id, joined.slice().buffer);
+        return id;
+      },
+      async blob(id) {
+        const bytes = rows("SELECT bytes FROM objects WHERE id = ?", id)[0]?.bytes;
+        return bytes instanceof ArrayBuffer ? memoryReader2(new Uint8Array(bytes)) : null;
+      }
+    },
+    refs: {
+      get: async (name) => ref(name),
+      async list(prefix) {
+        const end = prefixEnd2(prefix);
+        const found = end === null ? rows("SELECT name, target, revision FROM refs WHERE name >= ? ORDER BY name", prefix) : rows("SELECT name, target, revision FROM refs WHERE name >= ? AND name < ? ORDER BY name", prefix, end);
+        return found.map(parseRef2);
+      },
+      async set(updates) {
+        const logged = collectSessionEvents(updates).map(({ session, event }) => {
+          const text = JSON.stringify(event);
+          fits(encoder.encode(text).byteLength, `An event on ${session}`);
+          return { session, text };
+        });
+        return storage.transactionSync(() => {
+          assertStoreVersion(storedVersion(storage));
+          const before = new Map;
+          for (const update of updates)
+            if (!before.has(update.name))
+              before.set(update.name, ref(update.name) ?? undefined);
+          const fenced = fenceNames(updates).find((name) => ref(name) === null);
+          if (fenced !== undefined)
+            return { kind: "fenced", name: fenced };
+          const stale = updates.find((update) => !admits(update, before.get(update.name)));
+          if (stale !== undefined)
+            return {
+              kind: "stale",
+              name: stale.name,
+              revision: before.get(stale.name)?.revision ?? null
+            };
+          const touched = new Map;
+          const revisions = updates.map((update) => {
+            const revision = mintRevision2();
+            if (update.target === null)
+              rows("DELETE FROM refs WHERE name = ?", update.name);
+            else
+              rows("INSERT INTO refs (name, target, revision) VALUES (?, ?, ?) ON CONFLICT (name) DO UPDATE SET target = excluded.target, revision = excluded.revision", update.name, update.target, revision);
+            updateSessionIndex(storage, update.name, update.target, revision);
+            const session = parseSessionRef(update.name);
+            if (session !== null)
+              touched.set(session, revision);
+            return revision;
+          });
+          for (const [session, version] of touched)
+            rows("UPDATE session_index SET version = ? WHERE session = ?", version, session);
+          const at = Date.now();
+          const tails = new Map;
+          const appended = logged.map(({ session, text }) => {
+            const seq = (tails.get(session) ?? tail(session)) + 1;
+            tails.set(session, seq);
+            rows("INSERT INTO log (session, seq, at, event) VALUES (?, ?, ?, ?)", session, seq, at, text);
+            return asSeq(seq);
+          });
+          return { kind: "set", logged: appended, at, revisions };
+        });
+      },
+      async log(session, after, limit) {
+        return rows("SELECT seq, at, event FROM log WHERE session = ? AND seq > ? ORDER BY seq LIMIT ?", session, after, limit).map((row) => decodeEvent2(parseNumber2(row.seq), parseNumber2(row.at), parseText2(row.event) ?? ""));
+      },
+      tail: async (session) => tail(session)
+    }
+  };
+}
+function updateSessionIndex(storage, name, target, revision) {
+  if (sessionIndexRef(name) === null)
+    return;
+  const body = target === null ? null : parseText2(storage.sql.exec("SELECT body FROM objects WHERE id = ?", target).toArray()[0]?.body);
+  for (const change of sessionIndexChanges2(name, body === null ? null : decodeObject(body), revision))
+    storage.sql.exec(change.text, ...change.values);
+}
+function fits(bytes, what) {
+  if (bytes > ROW_LIMIT)
+    throw new SdkError("invalid", `${what} is ${bytes} bytes, past the Durable Object store's 2 MB row limit.`);
+}
+export {
+  durableObjectStore
+};

package/dist/src/hash.d.ts

@@ -0,0 +1 @@
+export declare function sha256(data: string | Uint8Array): string;

package/dist/src/hash.js

@@ -0,0 +1,6 @@
+import {
+  sha2562
+} from "../chunks/canvas-preview-0nq75h9k.js";
+export {
+  sha2562 as sha256
+};

package/dist/src/identity-key.d.ts

@@ -0,0 +1,11 @@
+import type { HostId } from "@nyte-ai/schema";
+import type { ListenOptions } from "@nyte-ai/core";
+/**
+ * Returns the Node host's identity signer (§50a): `seedSigner` over the
+ * Ed25519 seed in `<home>/.nyte/identity.key`, 32 raw bytes minted `0600` by
+ * `link` on first use as the secrets key is. The file is not encrypted; it is
+ * a signing key, protected as ssh protects one, and it never touches the
+ * secrets key. Named apart from core's `hostIdentity(store)`, which reads or
+ * mints the host's id.
+ */
+export declare function identitySigner(id: HostId, home: string): Promise<NonNullable<ListenOptions["identity"]>>;

package/dist/src/identity-key.js

@@ -0,0 +1,9 @@
+import {
+  identitySigner2
+} from "../chunks/canvas-preview-5mex725c.js";
+import"../chunks/canvas-preview-31w7xm8z.js";
+import"../chunks/canvas-preview-wg80rbc2.js";
+import"../chunks/canvas-preview-mgcx2b2p.js";
+export {
+  identitySigner2 as identitySigner
+};

package/dist/src/identity.d.ts

@@ -0,0 +1,12 @@
+import type { HostId } from "@nyte-ai/schema";
+import type { ListenOptions } from "@nyte-ai/core";
+/**
+ * Returns the signer a listener answers `GET /.nyte/identity?nonce=` with
+ * (`ListenOptions.identity`, §43a), over a 32-byte Ed25519 seed: `id` the
+ * host's id and `sign(nonce)` a signature over the UTF-8 bytes of
+ * `nyte/identity\n<id>\n<nonce>`, answered with the raw public key, both
+ * base64url without padding (§43k). The Node host reads the seed from
+ * `<home>/.nyte/identity.key` (`identitySigner`); a deploy passes one from its
+ * environment (§50a). Web Crypto only, no `node:*` (the `./identity` subpath).
+ */
+export declare function seedSigner(id: HostId, seed: Uint8Array): Promise<NonNullable<ListenOptions["identity"]>>;

package/dist/src/identity.js

@@ -0,0 +1,6 @@
+import {
+  seedSigner2
+} from "../chunks/canvas-preview-31w7xm8z.js";
+export {
+  seedSigner2 as seedSigner
+};

package/dist/src/index.d.ts

@@ -0,0 +1,21 @@
+export * from "./credentials.ts";
+export * from "./identity.ts";
+export { identitySigner } from "./identity-key.ts";
+export * from "./listen.ts";
+export * from "./listen-fetch.ts";
+export * from "./local/files.ts";
+export * from "./local/git.ts";
+export * from "./local/github.ts";
+export * from "./local/identity.ts";
+export * from "./local/jobs.ts";
+export * from "./local/provider.ts";
+export { createMcpHub } from "./mcp/hub.ts";
+export type { McpConnector } from "./mcp/connect.ts";
+export * from "./local/snapshots.ts";
+export * from "./local/worktrees.ts";
+export * from "./open.ts";
+export * from "./plugins/loader.ts";
+export * from "./postgres.ts";
+export * from "./secrets.ts";
+export * from "./sqlite.ts";
+export { StoreOwned } from "./store-owner.ts";

package/dist/src/index.js

@@ -0,0 +1,120 @@
+import {
+  credentialStore2,
+  sealSecret2,
+  openSecret2
+} from "../chunks/canvas-preview-518dh8by.js";
+import {
+  seedSigner2
+} from "../chunks/canvas-preview-31w7xm8z.js";
+import"../chunks/canvas-preview-mgcx2b2p.js";
+import"../chunks/canvas-preview-wg80rbc2.js";
+import {
+  identitySigner2
+} from "../chunks/canvas-preview-5mex725c.js";
+import"../chunks/canvas-preview-m02v4yy6.js";
+import"../chunks/canvas-preview-rp4x6y1h.js";
+import"../chunks/canvas-preview-d9wwhbtz.js";
+import {
+  listenFetch2
+} from "../chunks/canvas-preview-76fwvd6e.js";
+import {
+  listen2
+} from "../chunks/canvas-preview-98aj5p34.js";
+import"../chunks/canvas-preview-0nq75h9k.js";
+import"../chunks/canvas-preview-azg56359.js";
+import"../chunks/canvas-preview-yjz0f7n4.js";
+import"../chunks/canvas-preview-kn7kvbfj.js";
+import {
+  TEXT_LIMIT2,
+  localFiles2
+} from "../chunks/canvas-preview-ymgz0937.js";
+import"../chunks/canvas-preview-tjhabynd.js";
+import"../chunks/canvas-preview-zn2d0k9d.js";
+import {
+  localGit2
+} from "../chunks/canvas-preview-xn10d4f8.js";
+import {
+  localGitHubAccount2,
+  localGitHub2
+} from "../chunks/canvas-preview-75db60xy.js";
+import {
+  folderIdentity2
+} from "../chunks/canvas-preview-1sq7z9jq.js";
+import {
+  localExec2
+} from "../chunks/canvas-preview-ehf3vp31.js";
+import {
+  localSnapshots2
+} from "../chunks/canvas-preview-senpjwep.js";
+import {
+  listWorktrees2,
+  addWorktree2,
+  hasBranch2,
+  localWorktrees2
+} from "../chunks/canvas-preview-rp6fz0w5.js";
+import {
+  localProvider2
+} from "../chunks/canvas-preview-yrfz2ak6.js";
+import"../chunks/canvas-preview-kdqgrstc.js";
+import"../chunks/canvas-preview-5z63am63.js";
+import"../chunks/canvas-preview-h8hshnff.js";
+import"../chunks/canvas-preview-vaatfznm.js";
+import {
+  createMcpHub2
+} from "../chunks/canvas-preview-8xgt67ka.js";
+import"../chunks/canvas-preview-9aqczacs.js";
+import"../chunks/canvas-preview-4e0pxa32.js";
+import {
+  loadPluginFiles2,
+  loadPluginDirectory2,
+  pluginLoader2
+} from "../chunks/canvas-preview-s94ebwf5.js";
+import {
+  defaultSecrets2
+} from "../chunks/canvas-preview-skzwvw4d.js";
+import"../chunks/canvas-preview-69fkk9yn.js";
+import"../chunks/canvas-preview-zaaj99wd.js";
+import"../chunks/canvas-preview-0cmbkp2j.js";
+import {
+  StoreOwned2
+} from "../chunks/canvas-preview-a3yw0j70.js";
+import {
+  sqliteStore2
+} from "../chunks/canvas-preview-evh92ywd.js";
+import {
+  openHost2
+} from "../chunks/canvas-preview-vax9ne4e.js";
+import {
+  postgresStore2
+} from "../chunks/canvas-preview-4b6sayhg.js";
+export {
+  StoreOwned2 as StoreOwned,
+  TEXT_LIMIT2 as TEXT_LIMIT,
+  addWorktree2 as addWorktree,
+  createMcpHub2 as createMcpHub,
+  credentialStore2 as credentialStore,
+  defaultSecrets2 as defaultSecrets,
+  folderIdentity2 as folderIdentity,
+  hasBranch2 as hasBranch,
+  identitySigner2 as identitySigner,
+  listWorktrees2 as listWorktrees,
+  listen2 as listen,
+  listenFetch2 as listenFetch,
+  loadPluginDirectory2 as loadPluginDirectory,
+  loadPluginFiles2 as loadPluginFiles,
+  localExec2 as localExec,
+  localFiles2 as localFiles,
+  localGit2 as localGit,
+  localGitHub2 as localGitHub,
+  localGitHubAccount2 as localGitHubAccount,
+  localProvider2 as localProvider,
+  localSnapshots2 as localSnapshots,
+  localWorktrees2 as localWorktrees,
+  openHost2 as openHost,
+  openSecret2 as openSecret,
+  pluginLoader2 as pluginLoader,
+  postgresStore2 as postgresStore,
+  sealSecret2 as sealSecret,
+  seedSigner2 as seedSigner,
+  sqliteStore2 as sqliteStore
+};

package/dist/src/key-file.d.ts

@@ -0,0 +1 @@
+export declare function readKeyFile(path: string, name: string): Promise<Uint8Array>;

package/dist/src/key-file.js

@@ -0,0 +1,7 @@
+import {
+  readKeyFile2
+} from "../chunks/canvas-preview-wg80rbc2.js";
+import"../chunks/canvas-preview-mgcx2b2p.js";
+export {
+  readKeyFile2 as readKeyFile
+};

package/dist/src/listen-fetch.d.ts

@@ -0,0 +1,8 @@
+import type { ListenOptions, Listener } from "@nyte-ai/core";
+import type { ServedHost } from "@nyte-ai/core/server";
+/** Serves a composed host as a bare fetch handler with no socket and no `node:*` import, so a Worker can serve it (§41j): `before`, the unauthenticated identity and describe routes, then `createHandler` over one cached connection per principal and authority, every response carrying `X-Nyte-Host` (§43a, §43j). A request authenticates by a pairing code, then the listener token (compared in constant time over SHA-256 digests) or a device token remembered until a commit from another process moves the host's principals, then `authorize` under `custom`; a revoke aborts that principal's open requests and streams. A `token` shorter than 16 characters throws `SdkError("invalid")`; `execution` (default: run covering all) drives covered sessions in process on an `admit-only` host, covers their leases otherwise and takes nothing on a `dispatch` host (§42v); `close()` disconnects the clients and releases the execution once, after which every request answers `unavailable`. */
+export declare function listenFetch(host: ServedHost, options: ListenOptions & {
+    readonly transport: {
+        readonly kind: "fetch";
+    };
+}): Promise<Listener>;

package/dist/src/listen-fetch.js

@@ -0,0 +1,9 @@
+import {
+  listenFetch2
+} from "../chunks/canvas-preview-76fwvd6e.js";
+import"../chunks/canvas-preview-d9wwhbtz.js";
+import"../chunks/canvas-preview-m02v4yy6.js";
+import"../chunks/canvas-preview-rp4x6y1h.js";
+export {
+  listenFetch2 as listenFetch
+};

package/dist/src/listen.d.ts

@@ -0,0 +1,4 @@
+import type { ListenOptions, Listener } from "@nyte-ai/core";
+import type { ServedHost } from "@nyte-ai/core/server";
+/** Serves a composed host, the `Host.listen` `openHost` attaches: everything but the socket is `listenFetch`'s, and the `fetch` transport answers with it directly. The `http` transport binds `node:http` on `hostname` (default 127.0.0.1) and `port` (default 0), streaming each request body in and each response body out chunk by chunk, with a client gone aborting its request; a failed bind throws `SdkError("unavailable")` after releasing the execution. `disconnectClients()` also destroys every open Node response, and `close()` closes the socket once. */
+export declare function listen(host: ServedHost, options: ListenOptions): Promise<Listener>;

package/dist/src/listen.js

@@ -0,0 +1,10 @@
+import {
+  listen2
+} from "../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";
+export {
+  listen2 as listen
+};

package/dist/src/local/command.d.ts

@@ -0,0 +1,15 @@
+export type Ran = {
+    readonly code: number | null;
+    readonly stdout: Buffer;
+    readonly stderr: string;
+    readonly truncated: boolean;
+};
+export declare function run(file: string, args: readonly string[], options: {
+    readonly cwd: string;
+    readonly env?: Readonly<Record<string, string>>;
+    readonly input?: string | Uint8Array;
+    readonly limit?: number;
+    /** Kills the command after this long; it then ends with a null code. */
+    readonly timeoutMs?: number;
+}): Promise<Ran>;
+export declare function findExecutable(name: string, directories?: readonly string[]): Promise<string | null>;

package/dist/src/local/command.js

@@ -0,0 +1,8 @@
+import {
+  run2,
+  findExecutable2
+} from "../../chunks/canvas-preview-azg56359.js";
+export {
+  findExecutable2 as findExecutable,
+  run2 as run
+};

package/dist/src/local/feed.d.ts

@@ -0,0 +1,7 @@
+import type { Disposer } from "@nyte-ai/schema";
+export type FeedSink<T> = {
+    push(value: T): void;
+    fail(error: unknown): void;
+    end(): void;
+};
+export declare function feed<T>(start: (sink: FeedSink<T>) => Disposer, merge?: (waiting: T, next: T) => T): AsyncIterable<T>;

package/dist/src/local/feed.js

@@ -0,0 +1,6 @@
+import {
+  feed2
+} from "../../chunks/canvas-preview-yjz0f7n4.js";
+export {
+  feed2 as feed
+};

package/dist/src/local/files.d.ts

@@ -0,0 +1,18 @@
+import type { ByteReader, FileVersion } from "@nyte-ai/schema";
+import type { FilesApi } from "@nyte-ai/core";
+/** Returns a byte reader that carries the version of the file it read, which the server answers as `X-Nyte-Version` (§40h, §40p). */
+export type VersionedReader = ByteReader & {
+    readonly version: FileVersion;
+};
+/** Returns the local `FilesApi`, its `bytes` typed with the version it read. */
+export type LocalFiles = Omit<FilesApi, "bytes"> & {
+    bytes(path: string): Promise<VersionedReader>;
+};
+/** The size past which `read` answers `large`: 1 MiB. */
+export declare const TEXT_LIMIT: number;
+/** Returns a folder's files over `node:fs`: a relative path resolves against `root`, an absolute one is taken as given (the ancestor context files are read through it, §37g). A version is the SHA-256 of what is there, never an mtime: a file's contents (through a symlink, its target's), a directory's sorted entry names, and, for `stat` of a symlink itself, its target path. `read` answers `text` for UTF-8 without NUL up to 1 MiB, `large` above, `binary` otherwise, `missing` when absent (`SdkError("invalid")` for a directory); `bytes` streams the file with its size, a null mime and its version (`SdkError("unknown")` when absent); `stat` uses `lstat` (a symlink with its `target`), null when absent. `write` compares `expect` with the current version first (`stale { current }`, `absent` needing no file), answers `missing-parent` unless `parents`, and writes through a temporary file renamed into place (through a symlink, at its target), keeping an existing file's mode; `remove` compares `expect` the same way (`stale { current: null }` when nothing is there) and answers `saved` with the version it removed. `batch()` returns a plan whose `apply` and `upload()` reject with `SdkError("unavailable")`: core lays its own over them (`wrapFiles`). `format` runs `formatter`, else the first of `oxfmt`, `prettier` and `biome` under `<root>/node_modules/.bin`, then on the `PATH`, with the contents on stdin and the path for its config, answering `unchanged` when equal and `unavailable { reason }` when there is none or it fails. `scan` walks `directory` (default the root; an absolute one is walked as its own root and answered with absolute paths) breadth-first in pages of 500 entries, skipping `.git` and, unless `ignored: "include"` or the directory is itself ignored, what `.gitignore` files and `.git/info/exclude` ignore (`ignore`), then `complete`, or `incomplete` with `limit` after 50,000 entries or `permission` after an unreadable directory; entries carry no version. `find` matches the query against the scanned file paths, case-insensitively: exact name, name prefix, name substring, path substring, then a fuzzy subsequence, shorter first, at most `limit` (default 20, capped at 50), the scan reused for 5 s. `search` runs `ripgrep` (else `rg` on the PATH; with neither, a scan of the text files up to 1 MiB with a JavaScript regex) for the query, literal unless `regex`, with smart case unless `caseSensitive` is given, whole words alone when `wholeWord`, over the files the `include` globs pick (all when none) less the `exclude` globs; a file with a draft is searched in its draft's contents instead of on disk. It yields a `match` per matching line (1-based line and column and the first match's length, the line cut at 500 characters), drafts first, then `complete`, or `truncated` at `limit` (default 200); a regex or glob `rg` cannot read throws `SdkError("invalid")`. `watch` uses a recursive `fs.watch` on the root (a 1 s poll where there is none) or, given `paths`, a watch on each of them alone that waits for a missing one to appear and never polls, without ignored paths or directories, coalescing changes over 100 ms into `created`, `modified` and `removed` events with the version after (null when removed), a path's last change winning while the reader is behind. `signal` ends every open `watch`. */
+export declare function localFiles(root: string, options?: {
+    readonly ripgrep?: string;
+    readonly formatter?: string;
+    readonly signal?: AbortSignal;
+}): LocalFiles;

package/dist/src/local/files.js

@@ -0,0 +1,13 @@
+import {
+  TEXT_LIMIT2,
+  localFiles2
+} from "../../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-0nq75h9k.js";
+import"../../chunks/canvas-preview-mgcx2b2p.js";
+export {
+  TEXT_LIMIT2 as TEXT_LIMIT,
+  localFiles2 as localFiles
+};

package/dist/src/local/git-watch.d.ts

@@ -0,0 +1,15 @@
+import type { Disposer, GitStatus } from "@nyte-ai/schema";
+import type { FeedSink } from "./feed.ts";
+/** Where `localGit` found the repository holding its workspace: the worktree root, its git directory, the common directory linked worktrees share (the git directory otherwise), and the workspace's path below the root (`""` or ending in `/`). */
+export type Repository = {
+    readonly root: string;
+    readonly gitDir: string;
+    readonly commonDir: string;
+    readonly prefix: string;
+};
+/** One status watch shared by `localGit`'s feeds. */
+export type GitWatcher = {
+    subscribe(listener: (status: GitStatus) => void, fail: FeedSink<GitStatus>["fail"]): Disposer;
+};
+/** Returns the status watch `localGit` shares among its watchers: the first subscriber starts it and the last one stops it, and each gets the status at once, then again whenever a change could move it. A recursive `fs.watch` on the workspace hears worktree paths that `.gitignore` and `.git/info/exclude` do not ignore, and, in the git directory and the common directory, only HEAD, the index, branch and remote refs, `packed-refs`, `config` and the merge, cherry-pick, revert and rebase state, so object writes, logs and Nyte's snapshot refs read nothing; the `.git` entry itself appearing or going drops the remembered repository and starts over. Only where `fs.watch` is unavailable does it poll, every 2 s. */
+export declare function createWatcher(cwd: string, read: () => Promise<GitStatus>, repository: () => Promise<Repository | null>, forget: () => void): GitWatcher;

package/dist/src/local/git-watch.js

@@ -0,0 +1,7 @@
+import {
+  createWatcher2
+} from "../../chunks/canvas-preview-zn2d0k9d.js";
+import"../../chunks/canvas-preview-mgcx2b2p.js";
+export {
+  createWatcher2 as createWatcher
+};