trellis 3.1.35 → 3.2.2

package/dist/chunk-TCKXSOBP.js

@@ -0,0 +1,123 @@
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/server/node-adapter.ts
+async function startNodeServer(opts) {
+  const http = await import("http");
+  const httpServer = http.createServer(
+    async (req, res) => {
+      try {
+        const fetchReq = await toFetchRequest(req);
+        const fetchRes = await opts.fetch(fetchReq);
+        await writeFetchResponse(res, fetchRes);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Internal Server Error", message: msg }));
+      }
+    }
+  );
+  let wss = null;
+  try {
+    const { WebSocketServer } = await import("ws");
+    wss = new WebSocketServer({ noServer: true });
+    httpServer.on("upgrade", (req, socket, head) => {
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit("connection", ws, req);
+      });
+    });
+    wss.on("connection", (ws) => {
+      Promise.resolve(opts.websocket.open(ws)).catch(() => {
+      });
+      ws.on("message", (raw) => {
+        const data = Array.isArray(raw) ? Buffer.concat(raw).toString() : raw instanceof ArrayBuffer ? Buffer.from(raw).toString() : raw.toString();
+        Promise.resolve(opts.websocket.message(ws, data)).catch(() => {
+        });
+      });
+      ws.on("close", () => opts.websocket.close(ws));
+    });
+  } catch {
+    httpServer.on("upgrade", (_req, socket) => {
+      socket.destroy();
+    });
+  }
+  await new Promise(
+    (resolve) => httpServer.listen(opts.port, opts.hostname, resolve)
+  );
+  const addr = httpServer.address();
+  const boundPort = typeof addr === "object" && addr ? addr.port : opts.port;
+  const boundHost = typeof addr === "object" && addr ? addr.address : opts.hostname;
+  return wrapNodeServer(httpServer, wss, boundPort, boundHost);
+}
+async function toFetchRequest(req) {
+  const host = req.headers.host ?? "localhost";
+  const protocol = req.socket?.encrypted ? "https" : "http";
+  const url = `${protocol}://${host}${req.url ?? "/"}`;
+  const method = req.method ?? "GET";
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) {
+      for (const v of value) headers.append(key, v);
+    } else if (value != null) {
+      headers.set(key, value);
+    }
+  }
+  const hasBody = method !== "GET" && method !== "HEAD";
+  const body = hasBody ? new Uint8Array(await readBody(req)) : void 0;
+  return new Request(url, { method, headers, body });
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+async function writeFetchResponse(res, fetchRes) {
+  res.statusCode = fetchRes.status;
+  fetchRes.headers.forEach((value, key) => res.setHeader(key, value));
+  if (!fetchRes.body) {
+    res.end();
+    return;
+  }
+  const reader = fetchRes.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    res.write(value);
+  }
+  res.end();
+}
+function wrapNodeServer(httpServer, wss, port, hostname) {
+  return {
+    port,
+    hostname: hostname ?? "localhost",
+    stop(closeActiveConnections) {
+      return new Promise((resolve, reject) => {
+        const closeHttp = () => {
+          httpServer.close((err) => err ? reject(err) : resolve());
+        };
+        if (!wss) {
+          closeHttp();
+          return;
+        }
+        if (closeActiveConnections) {
+          for (const client of wss.clients) client.terminate();
+        }
+        wss.close(() => closeHttp());
+      });
+    }
+  };
+}
+var init_node_adapter = __esm({
+  "src/server/node-adapter.ts"() {
+  }
+});
+
+export {
+  startNodeServer,
+  init_node_adapter
+};

package/dist/chunk-UBGUDMUV.js

@@ -0,0 +1,59 @@
+// src/client/reactive.ts
+var Signal = class {
+  _value;
+  _subs = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this._value = initial;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(v) {
+    if (Object.is(this._value, v)) return;
+    this._value = v;
+    for (const fn of this._subs) {
+      try {
+        fn(v);
+      } catch {
+      }
+    }
+  }
+  /** Subscribe to changes. Immediately called with current value. */
+  subscribe(fn) {
+    this._subs.add(fn);
+    try {
+      fn(this._value);
+    } catch {
+    }
+    return () => {
+      this._subs.delete(fn);
+    };
+  }
+  /** Read without tracking. */
+  peek() {
+    return this._value;
+  }
+  /** Whether any subscriber is registered. */
+  hasSubscribers() {
+    return this._subs.size > 0;
+  }
+};
+var BatchSignal = class extends Signal {
+  _raf = null;
+  constructor(initial) {
+    super(initial);
+  }
+  set value(v) {
+    if (Object.is(this.peek(), v)) return;
+    if (this._raf !== null) cancelAnimationFrame(this._raf);
+    this._raf = requestAnimationFrame(() => {
+      this._raf = null;
+      super.value = v;
+    });
+  }
+};
+
+export {
+  Signal,
+  BatchSignal
+};

package/dist/{index-wt8rz4gn.js → chunk-UQISRW6T.js}

@@ -1,30 +1,83 @@
-// @bun
 import {
+  assertSpriteCli,
   runSpriteCmd,
   runSpriteCopy
-} from "./index-y6a4kj0p.js";
+} from "./chunk-FF36CQHZ.js";
 import {
   updateConfig
-} from "./index-xzym9w0m.js";
+} from "./chunk-JA7AIHRK.js";
+import {
+  __require
+} from "./chunk-KFQGP6VL.js";
 
 // src/server/deploy.ts
 import { existsSync, writeFileSync, mkdirSync } from "fs";
 import { join, resolve } from "path";
+
+// src/server/deploy-meta.ts
+var DEPLOY_NAME_RE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+var MIN_LEN = 3;
+var MAX_LEN = 32;
+var DeployNameError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DeployNameError";
+  }
+};
+function normalizeDeployName(name) {
+  return name.trim().toLowerCase();
+}
+function validateDeployName(name) {
+  const normalized = normalizeDeployName(name);
+  if (!normalized) {
+    throw new DeployNameError("Deploy name is required.");
+  }
+  if (normalized.length < MIN_LEN || normalized.length > MAX_LEN) {
+    throw new DeployNameError(
+      `Deploy name must be ${MIN_LEN}\u2013${MAX_LEN} characters (got ${normalized.length}).`
+    );
+  }
+  if (normalized.includes("--")) {
+    throw new DeployNameError(
+      "Deploy name cannot contain consecutive hyphens."
+    );
+  }
+  if (!DEPLOY_NAME_RE.test(normalized)) {
+    throw new DeployNameError(
+      "Deploy name must start with a letter and use only lowercase letters, numbers, and single hyphens (e.g. my-app)."
+    );
+  }
+  return normalized;
+}
+function buildDeployUrl(name) {
+  const slug = validateDeployName(name);
+  return `https://${slug}.sprites.app`;
+}
+
+// src/server/deploy.ts
 async function deploy(opts) {
-  const { name, port = 3000, configDir = ".", onProgress = () => {} } = opts;
+  const { port = 3e3, configDir = ".", onProgress = () => {
+  } } = opts;
+  const name = validateDeployName(opts.name);
   const apiKey = opts.apiKey ?? generateSecret("spk_");
   const jwtSecret = opts.jwtSecret ?? generateSecret("jws_");
-  const url = `https://${name}.sprites.app`;
+  const url = buildDeployUrl(name);
+  if (opts.stub) {
+    onProgress("Stub deploy \u2014 skipping Sprites provisioning");
+    onProgress("Writing .trellis-db.json...");
+    writeRemoteDeployConfig({ name, url, apiKey, configDir });
+    return { url, name, apiKey };
+  }
   onProgress("Checking Sprites CLI...");
-  await runSpriteCmd(["--version"]).catch(() => {
-    throw new Error("`sprite` CLI not found. Install it from https://docs.sprites.dev and authenticate.");
-  });
+  await assertSpriteCli();
   onProgress("Writing server entrypoint...");
   const tmpDir = resolve(configDir, ".trellis-deploy");
-  if (!existsSync(tmpDir))
-    mkdirSync(tmpDir, { recursive: true });
+  if (!existsSync(tmpDir)) mkdirSync(tmpDir, { recursive: true });
   const entrypoint = join(tmpDir, "server-entry.ts");
-  writeFileSync(entrypoint, generateServerEntrypoint({ port, apiKey, jwtSecret }));
+  writeFileSync(
+    entrypoint,
+    generateServerEntrypoint({ port, apiKey, jwtSecret })
+  );
   onProgress("Bundling server with Bun...");
   const bundlePath = join(tmpDir, "server.js");
   await runBun([
@@ -55,7 +108,8 @@ async function deploy(opts) {
     "bash",
     "-c",
     "which bun || curl -fsSL https://bun.sh/install | bash"
-  ]).catch(() => {});
+  ]).catch(() => {
+  });
   onProgress("Starting server...");
   await runSpriteCmd([
     "exec",
@@ -64,7 +118,8 @@ async function deploy(opts) {
     "bash",
     "-c",
     "sprite sessions list 2>/dev/null | grep trellis-db | awk '{print $1}' | xargs -r sprite sessions kill"
-  ]).catch(() => {});
+  ]).catch(() => {
+  });
   await runSpriteCmd([
     "exec",
     "--sprite",
@@ -78,15 +133,21 @@ async function deploy(opts) {
     `cd /home/sprite/trellis-db && ~/.bun/bin/bun run server.js`
   ]);
   onProgress("Writing .trellis-db.json...");
-  updateConfig({
-    mode: "remote",
-    url,
-    apiKey,
-    spriteName: name,
-    deployedAt: new Date().toISOString()
-  }, configDir);
+  writeRemoteDeployConfig({ name, url, apiKey, configDir });
   return { url, name, apiKey };
 }
+function writeRemoteDeployConfig(opts) {
+  updateConfig(
+    {
+      mode: "remote",
+      url: opts.url,
+      apiKey: opts.apiKey,
+      spriteName: opts.name,
+      deployedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    opts.configDir
+  );
+}
 function generateSecret(prefix) {
   const bytes = new Uint8Array(24);
   crypto.getRandomValues(bytes);
@@ -94,11 +155,15 @@ function generateSecret(prefix) {
   return `${prefix}${b64}`;
 }
 async function runBun(args) {
-  const proc = Bun.spawn(["bun", ...args], { stdout: "pipe", stderr: "pipe" });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const err = await new Response(proc.stderr).text();
-    throw new Error(`bun ${args[0]} failed (exit ${exitCode}): ${err}`);
+  const { execFile } = __require("child_process");
+  const { promisify } = __require("util");
+  const execFileAsync = promisify(execFile);
+  try {
+    await execFileAsync("bun", args);
+  } catch (err) {
+    throw new Error(
+      `bun ${args[0]} failed (exit ${err.code ?? "?"}): ${err.stderr ?? err.message}`
+    );
   }
 }
 function generateServerEntrypoint(opts) {
@@ -129,4 +194,10 @@ console.log('URL: https://\${process.env.SPRITE_NAME ?? 'localhost'}.sprites.app
 `;
 }
 
-export { deploy };
+export {
+  DeployNameError,
+  normalizeDeployName,
+  validateDeployName,
+  buildDeployUrl,
+  deploy
+};

package/dist/chunk-USEINYUL.js

@@ -0,0 +1,12 @@
+// src/schema/mutations.ts
+function entityMutations(client, schema) {
+  return {
+    create: (attrs) => client.create(schema.type, attrs),
+    update: (id, attrs) => client.update(id, attrs),
+    remove: (id) => client.delete(id)
+  };
+}
+
+export {
+  entityMutations
+};

package/dist/{index-bmyt7k8n.js → chunk-UZRUP7QW.js}

@@ -1,4 +1,3 @@
-// @bun
 // src/server/vm-config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
@@ -43,7 +42,7 @@ function setActiveSprite(spriteName) {
   if (!config.sprites[spriteName]) {
     config.sprites[spriteName] = {
       name: spriteName,
-      createdAt: new Date().toISOString(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       url: `https://${spriteName}.sprites.app`,
       hasTrellis: false
     };
@@ -55,7 +54,7 @@ function trackSprite(spriteName, opts = {}) {
   const config = loadVmConfig();
   const existing = config.sprites[spriteName] ?? {
     name: spriteName,
-    createdAt: new Date().toISOString(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     url: `https://${spriteName}.sprites.app`,
     hasTrellis: false
   };
@@ -87,4 +86,13 @@ function getSprite(spriteName) {
   return config.sprites[spriteName] ?? null;
 }
 
-export { loadVmConfig, saveVmConfig, getActiveSprite, setActiveSprite, trackSprite, untrackSprite, isSpriteTracked, getSprite };
+export {
+  loadVmConfig,
+  saveVmConfig,
+  getActiveSprite,
+  setActiveSprite,
+  trackSprite,
+  untrackSprite,
+  isSpriteTracked,
+  getSprite
+};