@nyte-ai/host 0.0.0-stage → 0.0.19

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-b2v8wfnz.js";
+import"../../../../../chunks/canvas-preview-n2a35zv5.js";
+import"../../../../../chunks/canvas-preview-2zdyh9ny.js";
+import"../../../../../chunks/canvas-preview-65xqjw7f.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/images/exif.d.ts

@@ -0,0 +1 @@
+export declare function exifOrientation(bytes: Uint8Array): number;

package/dist/src/images/exif.js

@@ -0,0 +1,6 @@
+import {
+  exifOrientation2
+} from "../../chunks/canvas-preview-befkjea2.js";
+export {
+  exifOrientation2 as exifOrientation
+};

package/dist/src/images/node.d.ts

@@ -0,0 +1,37 @@
+import type { ImageLimits, ImageProcessor } from "@nyte-ai/core";
+import { Type } from "typebox";
+export interface NodeImagesOptions {
+    readonly worker?: string | URL;
+    readonly wasm?: string;
+}
+export interface PrepareRequest {
+    readonly id: number;
+    readonly bytes: Uint8Array;
+    readonly mimeType: string;
+    readonly limits: ImageLimits;
+}
+export declare const prepareReply: Type.TUnion<[Type.TObject<{
+    id: Type.TInteger;
+    result: Type.TNull;
+}>, Type.TObject<{
+    id: Type.TInteger;
+    result: Type.TObject<{
+        data: Type.TString;
+        mimeType: Type.TString;
+        resized: Type.TOptional<Type.TObject<{
+            from: Type.TObject<{
+                width: Type.TNumber;
+                height: Type.TNumber;
+            }>;
+            to: Type.TObject<{
+                width: Type.TNumber;
+                height: Type.TNumber;
+            }>;
+        }>>;
+    }>;
+}>, Type.TObject<{
+    id: Type.TInteger;
+    error: Type.TString;
+}>]>;
+export declare function nodeImages(options?: NodeImagesOptions): ImageProcessor;
+export declare function resolvePhotonWasmPath(): string;

package/dist/src/images/node.js

@@ -0,0 +1,12 @@
+import {
+  prepareReply2,
+  nodeImages2,
+  resolvePhotonWasmPath2
+} from "../../chunks/canvas-preview-y5y6ghaw.js";
+import"../../chunks/canvas-preview-ec2mt7es.js";
+import"../../chunks/canvas-preview-befkjea2.js";
+export {
+  nodeImages2 as nodeImages,
+  prepareReply2 as prepareReply,
+  resolvePhotonWasmPath2 as resolvePhotonWasmPath
+};

package/dist/src/images/photon.d.ts

@@ -0,0 +1,3 @@
+import type { SyncInitInput } from "@silvia-odwyer/photon/photon_rs.js";
+import type { ImageProcessor } from "@nyte-ai/core";
+export declare function photonImages(wasm: SyncInitInput): ImageProcessor;

package/dist/src/images/photon.js

@@ -0,0 +1,7 @@
+import {
+  photonImages2
+} from "../../chunks/canvas-preview-ec2mt7es.js";
+import"../../chunks/canvas-preview-befkjea2.js";
+export {
+  photonImages2 as photonImages
+};

package/dist/src/images/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/images/worker.js

@@ -0,0 +1,23 @@
+import"../../chunks/canvas-preview-befkjea2.js";
+import {
+  photonImages2
+} from "../../chunks/canvas-preview-ec2mt7es.js";
+
+// src/images/worker.ts
+import { parentPort, workerData } from "node:worker_threads";
+var port = parentPort;
+if (port === null)
+  throw new Error("The image worker needs a parent thread");
+var wasm = workerData;
+if (!(wasm instanceof Uint8Array))
+  throw new Error("The image worker needs Photon's WebAssembly");
+var images = photonImages2(wasm);
+port.on("message", (request) => {
+  images.prepare(request.bytes, request.mimeType, request.limits).then((result) => port.postMessage({
+    id: request.id,
+    result: result ?? null
+  }), (cause) => port.postMessage({
+    id: request.id,
+    error: cause instanceof Error ? cause.message : String(cause)
+  }));
+});

package/dist/src/index.d.ts

@@ -0,0 +1,20 @@
+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";

package/dist/src/index.js

@@ -0,0 +1,121 @@
+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-55s0y68g.js";
+import"../chunks/canvas-preview-rp4x6y1h.js";
+import"../chunks/canvas-preview-aq5j4p25.js";
+import {
+  listenFetch2
+} from "../chunks/canvas-preview-w54ymtb3.js";
+import {
+  listen2
+} from "../chunks/canvas-preview-ycepb05s.js";
+import"../chunks/canvas-preview-0nq75h9k.js";
+import"../chunks/canvas-preview-bxnqt8cd.js";
+import"../chunks/canvas-preview-yjz0f7n4.js";
+import"../chunks/canvas-preview-kn7kvbfj.js";
+import {
+  TEXT_LIMIT2,
+  localFiles2
+} from "../chunks/canvas-preview-drctegz4.js";
+import"../chunks/canvas-preview-tjhabynd.js";
+import"../chunks/canvas-preview-af86jz8t.js";
+import {
+  localGit2
+} from "../chunks/canvas-preview-5ekjx6sw.js";
+import {
+  localGitHubAccount2,
+  localGitHub2
+} from "../chunks/canvas-preview-8xc0vn7v.js";
+import {
+  folderIdentity2
+} from "../chunks/canvas-preview-1sq7z9jq.js";
+import {
+  localExec2
+} from "../chunks/canvas-preview-vm9zdp2t.js";
+import {
+  localSnapshots2
+} from "../chunks/canvas-preview-crmzxxt8.js";
+import {
+  listWorktrees2,
+  addWorktree2,
+  hasBranch2,
+  localWorktrees2
+} from "../chunks/canvas-preview-2jwbe14k.js";
+import {
+  localProvider2
+} from "../chunks/canvas-preview-e3vnkkc5.js";
+import"../chunks/canvas-preview-kdqgrstc.js";
+import"../chunks/canvas-preview-5z63am63.js";
+import"../chunks/canvas-preview-pkzqg96v.js";
+import"../chunks/canvas-preview-vaatfznm.js";
+import {
+  createMcpHub2
+} from "../chunks/canvas-preview-g5fkjs34.js";
+import"../chunks/canvas-preview-9aqczacs.js";
+import"../chunks/canvas-preview-4e0pxa32.js";
+import"../chunks/canvas-preview-befkjea2.js";
+import"../chunks/canvas-preview-ec2mt7es.js";
+import"../chunks/canvas-preview-y5y6ghaw.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 {
+  storePath2,
+  sqliteStore2
+} from "../chunks/canvas-preview-tnqe7k0b.js";
+import {
+  openHost2
+} from "../chunks/canvas-preview-cawy6vbz.js";
+import {
+  postgresStore2
+} from "../chunks/canvas-preview-4b6sayhg.js";
+export {
+  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,
+  storePath2 as storePath
+};

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-w54ymtb3.js";
+import"../chunks/canvas-preview-aq5j4p25.js";
+import"../chunks/canvas-preview-55s0y68g.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-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";
+export {
+  listen2 as listen
+};