@nyte-ai/host 0.0.0-stage → 0.0.19

package/dist/src/canvas-preview.js

@@ -0,0 +1,271 @@
+import {
+  killTree2
+} from "../chunks/canvas-preview-bxnqt8cd.js";
+
+// src/canvas-preview.ts
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import { Readable, Writable } from "node:stream";
+import { runCanvasPreview } from "@nyte-ai/plugin/core/canvas-preview";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var ORIGIN = "https://canvas.preview/";
+var SHELL_POLICY = "default-src 'none'; script-src 'self' blob:; style-src 'self' 'unsafe-inline'; img-src data: blob:; font-src 'self'; connect-src 'none'; base-uri 'none'; form-action 'none'; sandbox allow-scripts";
+var SHELL_TYPES = new Map([
+  ["html", "text/html; charset=utf-8"],
+  ["js", "text/javascript; charset=utf-8"],
+  ["css", "text/css; charset=utf-8"],
+  ["woff2", "font/woff2"]
+]);
+function playwrightBrowser(prefix, executables) {
+  const cache = process.env["PLAYWRIGHT_BROWSERS_PATH"] ?? (process.platform === "darwin" ? join(homedir(), "Library", "Caches", "ms-playwright") : process.platform === "win32" ? join(process.env["LOCALAPPDATA"] ?? homedir(), "ms-playwright") : join(homedir(), ".cache", "ms-playwright"));
+  if (!existsSync(cache))
+    return;
+  const versions = readdirSync(cache).filter((name) => name.startsWith(`${prefix}-`)).toSorted((left, right) => Number(right.slice(prefix.length + 1)) - Number(left.slice(prefix.length + 1)));
+  return versions.flatMap((version) => executables.map((executable) => join(cache, version, executable))).find((path) => existsSync(path));
+}
+function findChromium() {
+  const named = process.env["NYTE_CANVAS_CHROMIUM"];
+  if (named !== undefined && named !== "")
+    return existsSync(named) ? named : undefined;
+  const arch = process.arch === "arm64" ? "arm64" : "x64";
+  return playwrightBrowser("chromium_headless_shell", [
+    `chrome-headless-shell-mac-${arch}/chrome-headless-shell`,
+    "chrome-headless-shell-linux64/chrome-headless-shell",
+    "chrome-headless-shell-win64/chrome-headless-shell.exe"
+  ]) ?? playwrightBrowser("chromium", [
+    `chrome-mac-${arch}/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing`,
+    "chrome-mac/Chromium.app/Contents/MacOS/Chromium",
+    "chrome-linux64/chrome",
+    "chrome-linux/chrome",
+    "chrome-win64/chrome.exe"
+  ]) ?? [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium",
+    "/usr/bin/chromium-browser",
+    join(process.env["PROGRAMFILES"] ?? "C:\\Program Files", "Google/Chrome/Application/chrome.exe")
+  ].find((path) => existsSync(path));
+}
+var Reply = Type.Object({
+  id: Type.Number(),
+  result: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+  error: Type.Optional(Type.Object({ message: Type.String() }))
+});
+var Event = Type.Object({
+  method: Type.String(),
+  params: Type.Record(Type.String(), Type.Unknown()),
+  sessionId: Type.Optional(Type.String())
+});
+var Paused = Type.Object({
+  requestId: Type.String(),
+  request: Type.Object({ url: Type.String() })
+});
+function read(schema, value, what) {
+  if (!Value.Check(schema, value))
+    throw new Error(`Chromium answered ${what} unreadably.`);
+  return value;
+}
+
+class Pipe {
+  #write;
+  #waiting = new Map;
+  #listeners = new Set;
+  #next = 0;
+  #buffer = "";
+  #closed;
+  constructor(write, readable) {
+    this.#write = write;
+    readable.setEncoding("utf8");
+    readable.on("data", (chunk) => this.#receive(chunk));
+    readable.on("close", () => this.close(new Error("Chromium closed its DevTools pipe.")));
+    write.on("error", (error) => this.close(error));
+  }
+  send(method, params = {}, sessionId) {
+    if (this.#closed !== undefined)
+      return Promise.reject(this.#closed);
+    this.#next += 1;
+    const id = this.#next;
+    return new Promise((resolve, reject) => {
+      this.#waiting.set(id, { resolve, reject });
+      this.#write.write(`${JSON.stringify({ id, method, params, sessionId })}\x00`);
+    });
+  }
+  listen(listener) {
+    this.#listeners.add(listener);
+  }
+  close(error) {
+    this.#closed ??= error;
+    for (const waiting of this.#waiting.values())
+      waiting.reject(error);
+    this.#waiting.clear();
+  }
+  #receive(chunk) {
+    this.#buffer += chunk;
+    const messages = this.#buffer.split("\x00");
+    this.#buffer = messages.pop() ?? "";
+    for (const text of messages) {
+      const message = JSON.parse(text);
+      if (Value.Check(Reply, message)) {
+        const waiting = this.#waiting.get(message.id);
+        this.#waiting.delete(message.id);
+        if (message.error === undefined)
+          waiting?.resolve(message.result ?? {});
+        else
+          waiting?.reject(new Error(message.error.message));
+      } else if (Value.Check(Event, message))
+        for (const listener of this.#listeners)
+          listener(message.method, message.params);
+    }
+  }
+}
+function serve(pipe, shell, sessionId) {
+  pipe.listen((method, params) => {
+    if (method !== "Fetch.requestPaused" || !Value.Check(Paused, params))
+      return;
+    const { requestId, request } = params;
+    const requested = request.url.startsWith(ORIGIN) ? request.url.slice(ORIGIN.length).split(/[?#]/u)[0] : undefined;
+    const path = requested === "" ? "index.html" : requested;
+    const body = path !== undefined && Object.hasOwn(shell, path) ? shell[path] : undefined;
+    const type = SHELL_TYPES.get(path?.split(".").at(-1) ?? "");
+    if (path === undefined || body === undefined || type === undefined) {
+      pipe.send("Fetch.failRequest", { requestId, errorReason: "BlockedByClient" }, sessionId).catch(() => {
+        return;
+      });
+      return;
+    }
+    pipe.send("Fetch.fulfillRequest", {
+      requestId,
+      responseCode: 200,
+      responseHeaders: [
+        { name: "Content-Type", value: type },
+        { name: "Access-Control-Allow-Origin", value: "*" },
+        ...path === "index.html" ? [{ name: "Content-Security-Policy", value: SHELL_POLICY }] : []
+      ],
+      body
+    }, sessionId).catch(() => {
+      return;
+    });
+  });
+}
+async function previewIn(pipe, shell, request) {
+  const target = read(Type.Object({ targetId: Type.String() }), await pipe.send("Target.createTarget", { url: "about:blank" }), "a new page");
+  const { sessionId } = read(Type.Object({ sessionId: Type.String() }), await pipe.send("Target.attachToTarget", { targetId: target.targetId, flatten: true }), "an attach");
+  const send = (method, params = {}) => pipe.send(method, params, sessionId);
+  serve(pipe, shell, sessionId);
+  const loaded = new Promise((resolve) => pipe.listen((method) => {
+    if (method === "Page.loadEventFired")
+      resolve();
+  }));
+  await send("Fetch.enable", { patterns: [{ urlPattern: "*" }] });
+  await send("Page.enable");
+  await send("Page.navigate", { url: ORIGIN });
+  await loaded;
+  const page = {
+    async evaluate(expression) {
+      const answer = read(Type.Object({
+        result: Type.Object({ value: Type.Optional(Type.Unknown()) }),
+        exceptionDetails: Type.Optional(Type.Object({ text: Type.String() }))
+      }), await send("Runtime.evaluate", { expression, awaitPromise: true, returnByValue: true }), "an evaluation");
+      if (answer.exceptionDetails !== undefined)
+        throw new Error(`The preview page threw: ${answer.exceptionDetails.text}`);
+      return answer.result.value;
+    },
+    async resize(width, height) {
+      await send("Emulation.setDeviceMetricsOverride", {
+        width,
+        height,
+        deviceScaleFactor: 1,
+        mobile: false
+      });
+    },
+    async capture() {
+      const { data } = read(Type.Object({ data: Type.String() }), await send("Page.captureScreenshot", { format: "png" }), "a screenshot");
+      return new Uint8Array(Buffer.from(data, "base64"));
+    }
+  };
+  return { kind: "rendered", report: await runCanvasPreview(page, request) };
+}
+function stop(child) {
+  if (child.exitCode !== null || child.signalCode !== null)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    const kill = setTimeout(() => killTree2(child, "SIGKILL"), 2000);
+    child.once("exit", () => {
+      clearTimeout(kill);
+      resolve();
+    });
+    killTree2(child, "SIGTERM");
+  });
+}
+function chromiumCanvasPreview(shell, executable = findChromium) {
+  return async (request, signal) => {
+    const path = executable();
+    if (path === undefined)
+      return {
+        kind: "unavailable",
+        reason: "No Chrome or Chromium was found on this machine."
+      };
+    const profile = await mkdtemp(join(tmpdir(), "nyte-canvas-preview-"));
+    const child = spawn(path, [
+      "--headless",
+      "--remote-debugging-pipe",
+      `--user-data-dir=${profile}`,
+      "--no-first-run",
+      "--no-default-browser-check",
+      "--disable-extensions",
+      "--disable-background-networking",
+      "--disable-sync",
+      "--mute-audio",
+      "--deny-permission-prompts",
+      "--force-webrtc-ip-handling-policy=disable_non_proxied_udp",
+      "--webrtc-ip-handling-policy=disable_non_proxied_udp",
+      "--proxy-server=socks5://127.0.0.1:9",
+      "--proxy-bypass-list=<-loopback>",
+      "--host-resolver-rules=MAP * ~NOTFOUND",
+      "--hide-scrollbars",
+      "--enable-unsafe-swiftshader",
+      "--use-mock-keychain",
+      "--password-store=basic",
+      "about:blank"
+    ], { stdio: ["ignore", "ignore", "ignore", "pipe", "pipe"] });
+    const [, , , input, output] = child.stdio;
+    try {
+      if (!(input instanceof Writable) || !(output instanceof Readable))
+        return { kind: "unavailable", reason: "Chromium did not open its DevTools pipe." };
+      const pipe = new Pipe(input, output);
+      child.once("error", (error) => pipe.close(error));
+      const stopped = Promise.withResolvers();
+      const stop = () => stopped.reject(new Error("The preview was stopped."));
+      signal.addEventListener("abort", stop, { once: true });
+      try {
+        signal.throwIfAborted();
+        return await Promise.race([previewIn(pipe, shell, request), stopped.promise]);
+      } catch (error) {
+        return {
+          kind: "unavailable",
+          reason: `Chromium could not render the preview: ${error instanceof Error ? error.message : String(error)}`
+        };
+      } finally {
+        signal.removeEventListener("abort", stop);
+        pipe.send("Browser.close").catch(() => {
+          return;
+        });
+        pipe.close(new Error("The preview finished."));
+      }
+    } finally {
+      await stop(child);
+      await rm(profile, { recursive: true, force: true, maxRetries: 10 });
+    }
+  };
+}
+export {
+  chromiumCanvasPreview,
+  findChromium
+};

package/dist/src/credentials.d.ts

@@ -0,0 +1,44 @@
+import type { CredentialStore } from "@nyte-ai/ai/auth/types";
+import type { Store } from "@nyte-ai/core";
+import { Type } from "typebox";
+import type { Static } from "typebox";
+import type { SecretsSource } from "./secrets.ts";
+declare const SealedCredentialSchema: Type.TUnion<[Type.TObject<{
+    type: Type.TUnion<[Type.TLiteral<"api_key">, Type.TLiteral<"oauth">]>;
+    iv: Type.TString;
+    ciphertext: Type.TString;
+}>, Type.TObject<{
+    active: Type.TUnion<[Type.TString, Type.TNull]>;
+    accounts: Type.TArray<Type.TObject<{
+        id: Type.TString;
+        label: Type.TString;
+        type: Type.TUnion<[Type.TLiteral<"api_key">, Type.TLiteral<"oauth">]>;
+    }>>;
+    iv: Type.TString;
+    ciphertext: Type.TString;
+}>]>;
+export type SealedCredential = Static<typeof SealedCredentialSchema>;
+/**
+ * Returns `@nyte-ai/ai`'s `CredentialStore` over a host `Store`, so a host's
+ * model logins live with its sessions and pass to
+ * `createModels({ credentials })` (§42e); a Durable Object and a Vercel
+ * instance keep theirs.
+ *
+ * Each call opens a store connection and closes it when done; the `Store` is
+ * the caller's. `read` is `unsealCredential` over the record, `list` answers
+ * non-secret account metadata per ref under `kv/secret/models/`, `modify` is
+ * `modifyCredential`, and `delete` sets the ref to null, serialised as
+ * `modify` is. Building it touches nothing, `list` never calls `key()` and
+ * `read` calls it only when that provider's record exists (§50b, §55); the
+ * imported key is kept once `key()` resolves, a rejection is not (§43k). While `key()` rejects (a deploy
+ * without `NYTE_SECRET_KEY`), `read` answers undefined, `list` and `delete`
+ * work (they need no key) and `modify` rejects that error, so provider keys
+ * from the environment still resolve and logins answer `unavailable`. Web
+ * Crypto only, no `node:*` (the `./credentials` subpath).
+ */
+export declare function credentialStore(store: Store, secrets: SecretsSource): CredentialStore;
+/** Returns `plain` sealed under the secrets key as `<iv>.<ciphertext>`, both base64; a desktop keeps its account token this way (§55). */
+export declare function sealSecret(secrets: SecretsSource, plain: string): Promise<string>;
+/** Returns the text `sealSecret` sealed; rejects when it was sealed under another key or is not such a text. */
+export declare function openSecret(secrets: SecretsSource, sealed: string): Promise<string>;
+export {};

package/dist/src/credentials.js

@@ -0,0 +1,10 @@
+import {
+  credentialStore2,
+  sealSecret2,
+  openSecret2
+} from "../chunks/canvas-preview-518dh8by.js";
+export {
+  credentialStore2 as credentialStore,
+  openSecret2 as openSecret,
+  sealSecret2 as sealSecret
+};

package/dist/src/deploy/cloudflare/worker.d.ts

@@ -0,0 +1,50 @@
+import type { AdvanceReport } from "@nyte-ai/schema";
+import type { Models } from "@nyte-ai/ai";
+import type { Host } from "@nyte-ai/core";
+import type { ServerHost } from "@nyte-ai/core/server";
+import type { DurableObjectSql } from "@nyte-ai/host/durable-object";
+/** Returns the parts of a Durable Object's `state` `NyteHost` uses, structurally: the storage `durableObjectStore` reads with the object's one alarm, and `blockConcurrencyWhile` to hold requests until the host is composed. */
+export type WorkerState = {
+    readonly storage: DurableObjectSql & {
+        getAlarm(): Promise<number | null>;
+        setAlarm(scheduledTime: number): Promise<void>;
+        deleteAlarm(): Promise<void>;
+    };
+    blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+};
+/** Returns the Worker's bindings: the `NyteHost` namespace `wrangler.jsonc` binds, the listener token it requires as a secret (`secrets.required`, set with `wrangler secret put NYTE_TOKEN`, at least 16 characters; §42l), the optional base64 secrets key (decision 10; absent, see `secretsFrom`), and the optional base64 identity seed (§50a; absent, the host answers no identity challenge). */
+export type WorkerEnv = {
+    readonly NYTE_HOST: {
+        getByName(name: string): {
+            fetch(request: Request): Promise<Response>;
+        };
+    };
+    readonly NYTE_TOKEN: string;
+    readonly NYTE_SECRET_KEY?: string;
+    readonly NYTE_IDENTITY_KEY?: string;
+};
+export type PassBudget = {
+    readonly heads: number;
+    readonly ms: number;
+    readonly repair: boolean;
+};
+export type PassHost = Pick<Host, "execution"> & {
+    readonly server: Pick<ServerHost, "tick">;
+};
+export declare function scheduleFrom(report: AdvanceReport, now: number): number | null;
+export declare function pass(host: PassHost, storage: Pick<DurableObjectSql, "sql">, budget: PassBudget): Promise<number | null>;
+/** The Durable Object that is one Nyte host, importing only the node-free subpaths (§41j): composed once per object over its own SQLite storage with a chat-only workspace, served through `listenFetch`, and driven by its alarm. */
+export declare class NyteHost {
+    #private;
+    constructor(state: WorkerState, env: WorkerEnv, options?: {
+        readonly models?: Models;
+    });
+    /** Answers one request through the listener once the host is composed; an object whose composition failed answers its encoded `SdkError` (`unavailable`, 503) and composes again on the next request. */
+    fetch(request: Request): Promise<Response>;
+    alarm(): Promise<void>;
+}
+/** The Worker: routes every request to the one `NyteHost` object, `env.NYTE_HOST.getByName("host")`. */
+declare const _default: {
+    fetch(request: Request, env: WorkerEnv): Promise<Response>;
+};
+export default _default;

package/dist/src/deploy/cloudflare/worker.js

@@ -0,0 +1,196 @@
+import {
+  package_default
+} from "../../../chunks/canvas-preview-jeddjex8.js";
+
+// src/deploy/cloudflare/worker.ts
+import { asId, SdkError } from "@nyte-ai/schema";
+import { createModels } from "@nyte-ai/ai/models";
+import { composeHost } from "@nyte-ai/core/server";
+import { encodeError, errorStatus } from "@nyte-ai/protocol";
+import { Settings } from "typebox/system";
+import { credentialStore } from "@nyte-ai/host/credentials";
+import { durableObjectStore } from "@nyte-ai/host/durable-object";
+import { seedSigner } from "@nyte-ai/host/identity";
+import { listenFetch } from "@nyte-ai/host/listen-fetch";
+import { chatOnlyProvider } from "@nyte-ai/host/providers";
+Settings.Set({ useAcceleration: false });
+var PASS_BUDGET = { heads: 32, ms: 1e4 };
+var REPAIR_EVERY = 60;
+var RETRY_MS = 30000;
+var PAGE = 100;
+function scheduleFrom(report, now) {
+  switch (report.kind) {
+    case "continue":
+      return now;
+    case "waiting":
+      return report.until;
+    case "retry":
+    case "busy":
+      return report.until;
+    case "idle":
+    case "fenced":
+      return null;
+  }
+}
+async function pass(host, storage, budget) {
+  const began = Date.now();
+  const schedule = openSchedule(storage);
+  await host.server.tick(began);
+  if (budget.repair) {
+    let cursor;
+    do {
+      cursor = (await host.execution.repair({ cursor, limit: PAGE })).next ?? undefined;
+    } while (cursor !== undefined);
+  }
+  const advances = [];
+  for (const entry of schedule.due(Date.now())) {
+    if (advances.length >= budget.heads || Date.now() - began >= budget.ms) {
+      schedule.write(entry.session, entry.head, began);
+      continue;
+    }
+    advances.push(host.execution.advance({ session: entry.session, head: entry.head }).then((report) => schedule.settle(entry, scheduleFrom(report, Date.now())), (error) => {
+      console.error(`Advancing ${entry.session}/${entry.head} failed:`, error);
+      schedule.settle(entry, Date.now() + RETRY_MS);
+    }));
+  }
+  await Promise.all(advances);
+  return schedule.earliest();
+}
+
+class NyteHost {
+  #state;
+  #env;
+  #models;
+  #served = null;
+  #passes = 0;
+  constructor(state, env, options) {
+    this.#state = state;
+    this.#env = env;
+    this.#models = options?.models;
+    state.blockConcurrencyWhile(async () => {
+      await this.#serve().catch(() => {
+        return;
+      });
+    });
+  }
+  async fetch(request) {
+    let served;
+    try {
+      served = await this.#serve();
+    } catch (error) {
+      const failure = new SdkError("unavailable", `The host did not start: ${error instanceof Error ? error.message : String(error)}`);
+      return new Response(JSON.stringify(encodeError(failure)), {
+        status: errorStatus[failure.code],
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return served.listener.fetch(request);
+  }
+  async alarm() {
+    const served = await this.#serve();
+    const repair = this.#passes % REPAIR_EVERY === 0;
+    this.#passes += 1;
+    const next = await pass(served.host, this.#state.storage, { ...PASS_BUDGET, repair });
+    if (next === null)
+      await this.#state.storage.deleteAlarm();
+    else
+      await this.#state.storage.setAlarm(next);
+  }
+  #serve() {
+    const served = this.#served ??= compose(this.#state, this.#env, this.#models);
+    served.catch(() => {
+      if (this.#served === served)
+        this.#served = null;
+    });
+    return served;
+  }
+}
+var worker_default = {
+  async fetch(request, env) {
+    return env.NYTE_HOST.getByName("host").fetch(request);
+  }
+};
+async function compose(state, env, models) {
+  const { storage } = state;
+  const store = durableObjectStore(storage);
+  const secrets = secretsFrom(env.NYTE_SECRET_KEY);
+  const description = { name: "nyte-host", platform: "cloudflare", version: package_default.version };
+  const host = await composeHost({
+    store,
+    models: models ?? createModels({ credentials: credentialStore(store, secrets) }),
+    plugins: [{ id: "chat-only", environment: chatOnlyProvider() }],
+    workspace: { kind: "chat-only", locator: null },
+    execution: { kind: "admit-only" },
+    secrets,
+    home: null,
+    description
+  });
+  try {
+    const coverage = await host.execution.cover({ kind: "all" });
+    const schedule = openSchedule(storage);
+    host.server.onWake((session, head) => {
+      const now = Date.now();
+      schedule.write(session, head, now);
+      storage.setAlarm(now);
+    });
+    const listener = await listenFetch(host, {
+      transport: { kind: "fetch" },
+      auth: { kind: "token", token: env.NYTE_TOKEN },
+      execution: { kind: "admit-only" },
+      describe: () => description,
+      ...env.NYTE_IDENTITY_KEY === undefined || env.NYTE_IDENTITY_KEY === "" ? {} : {
+        identity: await seedSigner(host.hostId, Uint8Array.fromBase64(env.NYTE_IDENTITY_KEY))
+      }
+    });
+    await storage.setAlarm(Date.now());
+    return { host, listener, coverage };
+  } catch (error) {
+    await host.close();
+    throw error;
+  }
+}
+function secretsFrom(key) {
+  if (key === undefined || key === "")
+    return {
+      key: async () => {
+        throw new SdkError("unavailable", "Set NYTE_SECRET_KEY to a base64 32-byte key.");
+      }
+    };
+  const bytes = Uint8Array.from(atob(key), (character) => character.charCodeAt(0));
+  return { key: async () => bytes };
+}
+function openSchedule(storage) {
+  const rows = (query, ...bindings) => storage.sql.exec(query, ...bindings).toArray();
+  rows("CREATE TABLE IF NOT EXISTS nyte_schedule (session TEXT NOT NULL, head TEXT NOT NULL, at INTEGER NOT NULL, PRIMARY KEY (session, head))");
+  const readAt = (session, head) => {
+    const at = rows("SELECT at FROM nyte_schedule WHERE session = ? AND head = ?", session, head)[0]?.at;
+    return typeof at === "number" ? at : null;
+  };
+  const write = (session, head, at) => {
+    rows("INSERT INTO nyte_schedule (session, head, at) VALUES (?, ?, ?) ON CONFLICT (session, head) DO UPDATE SET at = excluded.at", session, head, at);
+  };
+  return {
+    write,
+    due(now) {
+      return rows("SELECT session, head, at FROM nyte_schedule WHERE at <= ? ORDER BY at", now).flatMap((row) => typeof row.session === "string" && typeof row.head === "string" && typeof row.at === "number" ? [{ session: asId(row.session), head: asId(row.head), at: row.at }] : []);
+    },
+    settle(entry, next) {
+      if (readAt(entry.session, entry.head) !== entry.at)
+        return;
+      if (next === null)
+        rows("DELETE FROM nyte_schedule WHERE session = ? AND head = ?", entry.session, entry.head);
+      else
+        write(entry.session, entry.head, next);
+    },
+    earliest() {
+      const at = rows("SELECT MIN(at) AS at FROM nyte_schedule")[0]?.at;
+      return typeof at === "number" ? at : null;
+    }
+  };
+}
+export {
+  NyteHost,
+  worker_default as default,
+  pass,
+  scheduleFrom
+};

package/dist/src/deploy/vercel/nitro.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Omit<import("nitro/types").NitroConfig, "rootDir">;
+export default _default;

package/dist/src/deploy/vercel/nitro.config.js

@@ -0,0 +1,30 @@
+// src/deploy/vercel/nitro.config.ts
+import process from "node:process";
+import { defineConfig } from "nitro";
+var config = {
+  serverDir: "./server",
+  modules: ["workflow/nitro"],
+  workflow: {
+    runtime: "nodejs24.x",
+    dirs: ["./server/workflows"]
+  },
+  vercel: {
+    functions: {
+      runtime: "nodejs24.x",
+      maxDuration: 300
+    },
+    config: {
+      version: 3,
+      crons: [
+        {
+          path: "/.nyte/repair",
+          schedule: process.env.NYTE_REPAIR_SCHEDULE ?? "* * * * *"
+        }
+      ]
+    }
+  }
+};
+var nitro_config_default = defineConfig(config);
+export {
+  nitro_config_default as default
+};

package/dist/src/deploy/vercel/server/routes/[...].d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitro/h3").EventHandlerWithFetch<import("nitro/h3").EventHandlerRequest, Promise<Response>>;
+export default _default;

package/dist/src/deploy/vercel/server/routes/[...].js

@@ -0,0 +1,18 @@
+import"../../../../../chunks/canvas-preview-2zdyh9ny.js";
+import {
+  vercelHost2
+} from "../../../../../chunks/canvas-preview-n2a35zv5.js";
+import"../../../../../chunks/canvas-preview-65xqjw7f.js";
+import {
+  dispatchHead2
+} from "../../../../../chunks/canvas-preview-b2v8wfnz.js";
+
+// src/deploy/vercel/server/routes/[...].ts
+import { defineHandler } from "nitro/h3";
+async function serve(event) {
+  return (await vercelHost2(dispatchHead2)).listener.fetch(event.req);
+}
+var ___default = defineHandler(serve);
+export {
+  ___default as default
+};

package/dist/src/deploy/vercel/server/utils/host.d.ts

@@ -0,0 +1,13 @@
+import type { Listener, OpenOptions } from "@nyte-ai/core";
+import type { ServedHost } from "@nyte-ai/core/server";
+type Served = {
+    readonly host: ServedHost;
+    readonly listener: Listener;
+};
+/** Starts the workflow that drives a head; the host hands each wake to it. */
+type Dispatch = Extract<NonNullable<OpenOptions["execution"]>, {
+    readonly kind: "dispatch";
+}>["dispatch"];
+/** This process's host, composed once, handing each wake to `dispatch`. */
+export declare function vercelHost(dispatch: Dispatch): Promise<Served>;
+export {};

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

@@ -0,0 +1,7 @@
+import {
+  vercelHost2
+} from "../../../../../chunks/canvas-preview-n2a35zv5.js";
+import"../../../../../chunks/canvas-preview-2zdyh9ny.js";
+export {
+  vercelHost2 as vercelHost
+};

package/dist/src/deploy/vercel/server/utils/repair.d.ts

@@ -0,0 +1 @@
+export declare function answerRepair(request: Request, secret: string | undefined, repair: () => Promise<void>): Promise<Response | undefined>;

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

@@ -0,0 +1,6 @@
+import {
+  answerRepair2
+} from "../../../../../chunks/canvas-preview-2zdyh9ny.js";
+export {
+  answerRepair2 as answerRepair
+};

package/dist/src/deploy/vercel/server/utils/step.d.ts

@@ -0,0 +1,10 @@
+import type { AdvanceReport } from "@nyte-ai/schema";
+export type DriveStep = {
+    readonly kind: "advance";
+} | {
+    readonly kind: "sleep";
+    readonly ms: number;
+} | {
+    readonly kind: "stop";
+};
+export declare function stepFrom(report: AdvanceReport, now: number): DriveStep;