@nyte-ai/host 0.0.0-stage → 0.0.19

package/dist/chunks/canvas-preview-wg80rbc2.js

@@ -0,0 +1,46 @@
+import {
+  readErrorCode2
+} from "./canvas-preview-mgcx2b2p.js";
+
+// src/key-file.ts
+import { link, mkdir, open, readFile, unlink } from "node:fs/promises";
+import { dirname } from "node:path";
+import { SdkError } from "@nyte-ai/schema";
+async function readKeyFile2(path, name) {
+  const bytes = await readFile(path).then((stored) => new Uint8Array(stored), (error) => {
+    if (readErrorCode2(error) === "ENOENT")
+      return mintKeyFile(path);
+    throw error;
+  }).catch((error) => {
+    throw new SdkError("unavailable", `The ${name} at ${path} cannot be read: ${error instanceof Error ? error.message : String(error)}`);
+  });
+  if (bytes.length !== 32)
+    throw new SdkError("invalid", `The ${name} at ${path} is ${bytes.length} bytes, not 32.`);
+  return bytes;
+}
+async function mintKeyFile(path) {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  const bytes = crypto.getRandomValues(new Uint8Array(32));
+  const temp = `${path}.${crypto.randomUUID()}`;
+  const file = await open(temp, "wx", 384);
+  try {
+    await file.writeFile(bytes);
+    await file.sync();
+  } finally {
+    await file.close();
+  }
+  try {
+    await link(temp, path);
+    return bytes;
+  } catch (error) {
+    if (readErrorCode2(error) !== "EEXIST")
+      throw error;
+    return new Uint8Array(await readFile(path));
+  } finally {
+    await unlink(temp).catch(() => {
+      return;
+    });
+  }
+}
+
+export { readKeyFile2 };

package/dist/chunks/canvas-preview-y5y6ghaw.js

@@ -0,0 +1,125 @@
+import {
+  photonImages2
+} from "./canvas-preview-ec2mt7es.js";
+
+// src/images/node.ts
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var size = Type.Object({ width: Type.Number(), height: Type.Number() });
+var prepareReply2 = Type.Union([
+  Type.Object({ id: Type.Integer(), result: Type.Null() }),
+  Type.Object({
+    id: Type.Integer(),
+    result: Type.Object({
+      data: Type.String(),
+      mimeType: Type.String(),
+      resized: Type.Optional(Type.Object({ from: size, to: size }))
+    })
+  }),
+  Type.Object({ id: Type.Integer(), error: Type.String() })
+]);
+var IDLE_MS = 30000;
+function nodeImages2(options = {}) {
+  const worker = options.worker ?? new URL(import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.js", import.meta.url);
+  let wasm;
+  const loadWasm = () => wasm ??= readFile(options.wasm ?? resolvePhotonWasmPath2());
+  let thread;
+  let inProcess;
+  return {
+    async prepare(bytes, mimeType, limits) {
+      if (inProcess !== undefined)
+        return inProcess.prepare(bytes, mimeType, limits);
+      const module = await loadWasm();
+      try {
+        thread ??= new PhotonThread(worker, module, (ended) => {
+          if (thread === ended)
+            thread = undefined;
+        });
+        return await thread.prepare(bytes, mimeType, limits);
+      } catch (cause) {
+        if (!(cause instanceof WorkerUnavailable))
+          throw cause;
+        inProcess ??= photonImages2(module);
+        return inProcess.prepare(bytes, mimeType, limits);
+      }
+    }
+  };
+}
+function resolvePhotonWasmPath2() {
+  return fileURLToPath(import.meta.resolve("@silvia-odwyer/photon/photon_rs_bg.wasm"));
+}
+
+class WorkerUnavailable extends Error {
+}
+
+class PhotonThread {
+  #worker;
+  #pending = new Map;
+  #onExit;
+  #nextId = 0;
+  #idle;
+  #started = false;
+  constructor(entry, wasm, onExit) {
+    this.#onExit = onExit;
+    try {
+      this.#worker = new Worker(entry, { workerData: wasm });
+    } catch (cause) {
+      throw new WorkerUnavailable("The image worker cannot start", { cause });
+    }
+    this.#worker.on("message", (reply) => {
+      if (!Value.Check(prepareReply2, reply)) {
+        this.#fail(new Error("Malformed image worker reply"));
+        this.#worker.terminate();
+        return;
+      }
+      this.#started = true;
+      const request = this.#pending.get(reply.id);
+      if (request === undefined)
+        return;
+      this.#pending.delete(reply.id);
+      if ("error" in reply)
+        request.reject(new Error(reply.error));
+      else
+        request.resolve(reply.result ?? undefined);
+      this.#settled();
+    });
+    this.#worker.on("error", (cause) => this.#fail(cause));
+    this.#worker.on("exit", (code) => this.#fail(new Error(`The image worker exited with code ${String(code)}`)));
+  }
+  prepare(bytes, mimeType, limits) {
+    const id = this.#nextId++;
+    const request = Promise.withResolvers();
+    this.#pending.set(id, request);
+    clearTimeout(this.#idle);
+    this.#idle = undefined;
+    this.#worker.ref();
+    const copy = bytes.slice();
+    this.#worker.postMessage({ id, bytes: copy, mimeType, limits }, [
+      copy.buffer
+    ]);
+    return request.promise;
+  }
+  #settled() {
+    if (this.#pending.size > 0)
+      return;
+    this.#worker.unref();
+    this.#idle = setTimeout(() => {
+      this.#onExit(this);
+      this.#worker.terminate();
+    }, IDLE_MS);
+    this.#idle.unref();
+  }
+  #fail(cause) {
+    const failure = this.#started ? cause : new WorkerUnavailable("The image worker cannot start", { cause });
+    for (const request of this.#pending.values())
+      request.reject(failure);
+    this.#pending.clear();
+    clearTimeout(this.#idle);
+    this.#onExit(this);
+  }
+}
+
+export { prepareReply2, nodeImages2, resolvePhotonWasmPath2 };

package/dist/chunks/canvas-preview-ycepb05s.js

@@ -0,0 +1,176 @@
+import {
+  listenFetch2
+} from "./canvas-preview-w54ymtb3.js";
+
+// src/listen.ts
+import { createServer } from "node:http";
+import { SdkError } from "@nyte-ai/schema";
+import { encodeError, errorStatus } from "@nyte-ai/protocol";
+async function listen2(host, options) {
+  const inner = await listenFetch2(host, { ...options, transport: { kind: "fetch" } });
+  if (options.transport.kind === "fetch")
+    return inner;
+  const responses = new Set;
+  const bound = await bind(options.transport, (request) => inner.fetch(request), responses).catch(async (error) => {
+    await inner.close();
+    throw new SdkError("unavailable", `Cannot listen: ${error instanceof Error ? error.message : String(error)}`);
+  });
+  const disconnectClients = () => {
+    inner.disconnectClients();
+    for (const response of responses)
+      response.destroy();
+  };
+  let closing = null;
+  const close = () => {
+    closing ??= (async () => {
+      disconnectClients();
+      await inner.close();
+      await new Promise((done) => {
+        bound.server.close(() => done());
+        bound.server.closeAllConnections();
+      });
+    })();
+    return closing;
+  };
+  return {
+    address: bound.address,
+    fetch: (request) => inner.fetch(request),
+    disconnectClients,
+    close,
+    [Symbol.asyncDispose]: close
+  };
+}
+async function bind(transport, fetch, responses) {
+  let origin = "http://127.0.0.1";
+  const server = createServer({ noDelay: true }, (incoming, outgoing) => {
+    respond(incoming, outgoing, origin, fetch, responses);
+  });
+  await new Promise((listening, failed) => {
+    server.once("error", failed);
+    server.listen(transport.port ?? 0, transport.hostname ?? "127.0.0.1", () => {
+      server.off("error", failed);
+      listening();
+    });
+  });
+  const info = server.address();
+  if (info === null || typeof info === "string") {
+    server.close();
+    throw new Error("the socket has no address");
+  }
+  const hostname = info.address.includes(":") ? `[${info.address}]` : info.address;
+  origin = `http://${hostname}:${info.port}`;
+  return { server, address: origin };
+}
+async function respond(incoming, outgoing, origin, fetch, responses) {
+  const controller = new AbortController;
+  responses.add(outgoing);
+  outgoing.on("close", () => {
+    responses.delete(outgoing);
+    if (!outgoing.writableFinished)
+      controller.abort();
+  });
+  let request;
+  try {
+    request = readRequest(incoming, origin, controller.signal);
+  } catch (error) {
+    await write(failure(new SdkError("invalid", error instanceof Error ? error.message : String(error))), outgoing);
+    return;
+  }
+  await write(await fetch(request), outgoing);
+}
+function readRequest(incoming, origin, signal) {
+  const headers = new Headers;
+  for (const [name, value] of Object.entries(incoming.headers)) {
+    if (name.startsWith(":") || value === undefined)
+      continue;
+    if (Array.isArray(value))
+      for (const each of value)
+        headers.append(name, each);
+    else
+      headers.set(name, value);
+  }
+  const host = incoming.headers.host;
+  const url = new URL(incoming.url ?? "/", host === undefined ? origin : `http://${host}`);
+  const method = incoming.method ?? "GET";
+  const body = method === "GET" || method === "HEAD" ? {} : { body: streamBody(incoming), duplex: "half" };
+  return new Request(url.href, { method, headers, signal, ...body });
+}
+function streamBody(incoming) {
+  return new ReadableStream({
+    start(controller) {
+      incoming.on("data", (chunk) => {
+        controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+        if ((controller.desiredSize ?? 0) <= 0)
+          incoming.pause();
+      });
+      incoming.on("end", () => controller.close());
+      incoming.on("error", (error) => controller.error(error));
+    },
+    pull() {
+      incoming.resume();
+    },
+    cancel() {
+      incoming.destroy();
+    }
+  });
+}
+async function write(response, outgoing) {
+  if (outgoing.destroyed) {
+    await response.body?.cancel().catch(() => {
+      return;
+    });
+    return;
+  }
+  const headers = {};
+  response.headers.forEach((value, name) => {
+    headers[name] = value;
+  });
+  const cookies = response.headers.getSetCookie();
+  if (cookies.length > 0)
+    headers["set-cookie"] = cookies;
+  outgoing.writeHead(response.status, headers);
+  outgoing.flushHeaders();
+  if (response.body === null) {
+    outgoing.end();
+    return;
+  }
+  const reader = response.body.getReader();
+  const cancel = () => {
+    reader.cancel().catch(() => {
+      return;
+    });
+  };
+  outgoing.on("close", cancel);
+  try {
+    for (;; ) {
+      const read = await reader.read();
+      if (read.done)
+        break;
+      if (!outgoing.write(read.value))
+        await new Promise((drained) => {
+          const done = () => {
+            outgoing.off("drain", done);
+            outgoing.off("close", done);
+            drained();
+          };
+          outgoing.on("drain", done);
+          outgoing.on("close", done);
+        });
+      if (outgoing.destroyed)
+        return;
+    }
+    outgoing.end();
+  } catch {
+    outgoing.destroy();
+  } finally {
+    outgoing.off("close", cancel);
+  }
+}
+function failure(error) {
+  return new Response(JSON.stringify(encodeError(error)), {
+    status: errorStatus[error.code],
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+export { listen2 };

package/dist/chunks/canvas-preview-yjz0f7n4.js

@@ -0,0 +1,50 @@
+// src/local/feed.ts
+import { closable } from "@nyte-ai/core";
+function feed2(start, merge = (_waiting, next) => next) {
+  return closable(() => {
+    const state = { slot: null, outcome: null, wake: null };
+    const signal = () => {
+      const resolve = state.wake;
+      state.wake = null;
+      resolve?.();
+    };
+    const dispose = start({
+      push(value) {
+        if (state.outcome !== null)
+          return;
+        state.slot = { value: state.slot === null ? value : merge(state.slot.value, value) };
+        signal();
+      },
+      fail(error) {
+        state.outcome ??= { kind: "failed", error };
+        signal();
+      },
+      end() {
+        state.outcome ??= { kind: "ended" };
+        signal();
+      }
+    });
+    return {
+      async pull() {
+        for (;; ) {
+          const held = state.slot;
+          if (held !== null) {
+            state.slot = null;
+            return { done: false, value: held.value };
+          }
+          const outcome = state.outcome;
+          if (outcome?.kind === "failed")
+            throw outcome.error;
+          if (outcome?.kind === "ended")
+            return { done: true, value: undefined };
+          await new Promise((resolve) => {
+            state.wake = resolve;
+          });
+        }
+      },
+      close: () => dispose()
+    };
+  });
+}
+
+export { feed2 };

package/dist/chunks/canvas-preview-zaaj99wd.js

@@ -0,0 +1,244 @@
+// src/sqlite-workers.ts
+import { Worker } from "node:worker_threads";
+import { dev } from "@nyte-ai/core";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var rowSchema = Type.Record(Type.String(), Type.Union([Type.Null(), Type.String(), Type.Number(), Type.BigInt()]));
+var replySchema = Type.Union([
+  Type.Object({ ready: Type.Literal(true) }),
+  Type.Object({ id: Type.Integer(), rows: Type.Array(rowSchema), executionMs: Type.Number() }),
+  Type.Object({
+    id: Type.Integer(),
+    error: Type.String(),
+    code: Type.Optional(Type.String()),
+    errcode: Type.Optional(Type.Number()),
+    errstr: Type.Optional(Type.String())
+  })
+]);
+var source = String.raw`
+const { parentPort, workerData } = require("node:worker_threads");
+const { DatabaseSync } = require("node:sqlite");
+const db = new DatabaseSync(workerData.path, {
+  readOnly: workerData.role === "reader",
+  timeout: 5000,
+});
+if (String(db.prepare("PRAGMA journal_mode").get().journal_mode).toLowerCase() !== "wal")
+  throw new Error("SQLite workers require WAL mode");
+if (workerData.role === "checkpoint") {
+  const version = db.prepare("SELECT sqlite_version() AS version").get().version;
+  const [major, minor] = version.split(".").map(Number);
+  if (major < 3 || (major === 3 && minor < 51))
+    throw new Error("SQLite " + version + " has no NOOP checkpoint");
+  db.exec("PRAGMA synchronous = NORMAL; PRAGMA checkpoint_fullfsync = ON");
+}
+const statements = new Map();
+const frames = workerData.role === "checkpoint" ? db.prepare("PRAGMA wal_checkpoint(NOOP)") : null;
+const checkpoint = workerData.role === "checkpoint" ? db.prepare("PRAGMA wal_checkpoint(PASSIVE)") : null;
+let idle;
+parentPort.on("message", ({ id, sql, params }) => {
+  const started = performance.now();
+  try {
+    let rows = [];
+    if (workerData.role === "checkpoint") {
+      const { log, checkpointed } = frames.get();
+      if (log - checkpointed >= 1000) checkpoint.get();
+      clearTimeout(idle);
+      idle = setTimeout(() => {
+        const { log, checkpointed } = frames.get();
+        if (log >= 1000 && checkpointed < log) checkpoint.get();
+      }, 100);
+    } else {
+      const size = params.reduce((total, value) => total + (typeof value === "string" ? value.length : ArrayBuffer.isView(value) ? value.byteLength : 0), 0);
+      let statement = size > 65536 ? undefined : statements.get(sql);
+      if (statement === undefined) {
+        statement = db.prepare(sql);
+        if (size <= 65536) {
+          if (statements.size >= 16) statements.delete(statements.keys().next().value);
+          statements.set(sql, statement);
+        }
+      }
+      rows = statement.all(...params);
+    }
+    parentPort.postMessage({ id, rows, executionMs: performance.now() - started });
+  } catch (error) {
+    parentPort.postMessage({ id, error: String(error.message), code: error.code, errcode: error.errcode, errstr: error.errstr });
+  }
+});
+parentPort.postMessage({ ready: true });
+`;
+
+class SqliteWorker {
+  ready;
+  worker;
+  nextId = 0;
+  pending = new Map;
+  stop;
+  constructor(path, role, unavailable) {
+    const worker = new Worker(source, { eval: true, workerData: { path, role } });
+    this.worker = worker;
+    let started = false;
+    let announce = () => {
+      return;
+    };
+    this.ready = new Promise((resolve) => {
+      announce = resolve;
+    });
+    const timeout = setTimeout(() => {
+      this.stop(new Error("SQLite worker did not start within 10 seconds"), true);
+    }, 1e4);
+    timeout.unref();
+    this.stop = (cause, notify) => {
+      if (this.worker === null)
+        return;
+      this.worker = null;
+      clearTimeout(timeout);
+      announce(false);
+      for (const request of this.pending.values())
+        request.reject(cause);
+      this.pending.clear();
+      if (notify)
+        unavailable(cause, started);
+      return worker.terminate();
+    };
+    worker.on("message", (reply) => {
+      if (!Value.Check(replySchema, reply)) {
+        this.stop(new Error("Malformed SQLite worker reply"), true);
+        return;
+      }
+      if ("ready" in reply) {
+        clearTimeout(timeout);
+        started = true;
+        announce(true);
+        if (this.pending.size === 0)
+          worker.unref();
+        return;
+      }
+      const request = this.pending.get(reply.id);
+      if (request === undefined)
+        return;
+      this.pending.delete(reply.id);
+      if (this.pending.size === 0)
+        worker.unref();
+      if ("error" in reply) {
+        request.reject(Object.assign(new Error(reply.error), reply));
+      } else {
+        dev("sqlite", "query", {
+          connection: role,
+          durationMs: performance.now() - request.at,
+          executionMs: reply.executionMs
+        });
+        request.resolve(reply.rows);
+      }
+    });
+    worker.on("error", (cause) => {
+      this.stop(cause instanceof Error ? cause : new Error(String(cause)), true);
+    });
+    worker.on("exit", (code) => {
+      this.stop(new Error(`SQLite ${role} worker exited with code ${code}`), true);
+    });
+    if (role === "checkpoint")
+      worker.unref();
+  }
+  async query(sql, params) {
+    if (!await this.ready)
+      return;
+    const worker = this.worker;
+    if (worker === null)
+      throw new Error("SQLite worker stopped");
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject, at: performance.now() });
+      worker.ref();
+      try {
+        worker.postMessage({ id, sql, params });
+      } catch (cause) {
+        this.pending.delete(id);
+        if (this.pending.size === 0)
+          worker.unref();
+        reject(cause);
+      }
+    });
+  }
+  async close() {
+    await this.stop(new Error("SQLite worker closed"), false);
+  }
+}
+function sqliteWorkers2(database, path) {
+  let reader = null;
+  let readerUnavailable = false;
+  let closed = false;
+  let checking = false;
+  let checkAgain = false;
+  let checkpoint = null;
+  const warn = (role, cause) => {
+    process.emitWarning(`SQLite ${role} worker unavailable; using the main connection: ${cause.message}`, {
+      code: "NYTE_SQLITE_WORKER_UNAVAILABLE"
+    });
+  };
+  const handBack = (cause) => {
+    const stopped = checkpoint;
+    checkpoint = null;
+    stopped?.close();
+    if (closed)
+      return;
+    database.exec("PRAGMA wal_autocheckpoint = 1000");
+    warn("checkpoint", cause);
+  };
+  try {
+    checkpoint = new SqliteWorker(path, "checkpoint", handBack);
+    checkpoint.ready.then((ready) => {
+      if (ready && !closed)
+        database.exec("PRAGMA wal_autocheckpoint = 10000");
+    });
+  } catch (cause) {
+    warn("checkpoint", cause instanceof Error ? cause : new Error(String(cause)));
+  }
+  const check = () => {
+    if (checkpoint === null || closed)
+      return;
+    if (checking) {
+      checkAgain = true;
+      return;
+    }
+    checking = true;
+    checkpoint.query("", []).catch((cause) => {
+      if (checkpoint !== null)
+        handBack(cause instanceof Error ? cause : new Error(String(cause)));
+    }).finally(() => {
+      checking = false;
+      if (checkAgain) {
+        checkAgain = false;
+        check();
+      }
+    });
+  };
+  return {
+    check,
+    async read(sql, params) {
+      if (closed)
+        throw new Error("SQLite store closed");
+      if (readerUnavailable)
+        return;
+      if (reader === null) {
+        try {
+          reader = new SqliteWorker(path, "reader", (cause, started) => {
+            reader = null;
+            readerUnavailable = !started;
+            warn("reader", cause);
+          });
+        } catch (cause) {
+          readerUnavailable = true;
+          warn("reader", cause instanceof Error ? cause : new Error(String(cause)));
+          return;
+        }
+      }
+      return reader.query(sql, params);
+    },
+    async close() {
+      closed = true;
+      await Promise.all([reader?.close(), checkpoint?.close()]);
+    }
+  };
+}
+
+export { sqliteWorkers2 };

package/dist/src/canvas-preview.d.ts

@@ -0,0 +1,29 @@
+import type { CanvasPreviewer } from "@nyte-ai/plugin/core/canvas-preview";
+/**
+ * Returns the shell a previewer serves: every file of the canvas package's
+ * `dist/shell`, base64 by its path from it (`index.html`,
+ * `libraries/three.js`), as `@nyte-ai/canvas/shell-files` exports them.
+ *
+ * @category host
+ * @since 0.1.0
+ */
+export type CanvasShellFiles = Readonly<Record<string, string>>;
+/**
+ * Finds a Chromium to preview with: `NYTE_CANVAS_CHROMIUM`, then
+ * Playwright's headless shell or Chromium, then an installed Chrome or
+ * Chromium. Undefined when there is none.
+ *
+ * @category host
+ * @since 0.1.0
+ */
+export declare function findChromium(): string | undefined;
+/**
+ * Returns a previewer over a headless Chromium on this machine
+ * (`findChromium`), serving `shell`; it answers `unavailable` when there is
+ * no Chromium or it fails to start, and stops the browser when the
+ * preview's signal aborts.
+ *
+ * @category host
+ * @since 0.1.0
+ */
+export declare function chromiumCanvasPreview(shell: CanvasShellFiles, executable?: () => string | undefined): CanvasPreviewer;