wirl 0.1.1 → 0.2.0

package/package.json

@@ -1,42 +1,40 @@
 {
   "name": "wirl",
-  "version": "0.1.1",
-  "description": "Wirl SDK for email sequence automation",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
-    }
+  "version": "0.2.0",
+  "description": "Deploy an internal app somewhere real, privately. One command; sharing by email; API keys declared, never pasted.",
+  "keywords": [
+    "deploy",
+    "internal-tools",
+    "cli",
+    "mcp",
+    "claude-code",
+    "agents",
+    "cloudflare-workers"
+  ],
+  "homepage": "https://wirl.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Brycce/wirl-platform.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/Brycce/wirl-platform/issues"
+  },
+  "type": "module",
+  "bin": {
+    "wirl": "./bin.js"
   },
   "files": [
-    "dist",
+    "bin.js",
+    "serve-module.mjs",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
-    "lint": "eslint src",
-    "prepublishOnly": "npm run build"
+  "engines": {
+    "node": ">=22.13"
   },
-  "keywords": [
-    "email",
-    "automation",
-    "sequences",
-    "marketing",
-    "wirl"
-  ],
-  "author": "",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "tsup": "^8.0.0",
-    "typescript": "^5.0.0"
+  "dependencies": {
+    "tar": "^7.5.22",
+    "esbuild": "^0.28.2"
   },
-  "engines": {
-    "node": ">=18.0.0"
-  }
+  "license": "UNLICENSED"
 }

package/serve-module.mjs

@@ -0,0 +1,537 @@
+// packages/runtime/src/serve-module.mjs
+import fs from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { syncBuiltinESMExports } from "node:module";
+import { join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// packages/runtime/src/local-db.ts
+import { DatabaseSync } from "node:sqlite";
+var D1_MAX_BOUND_PARAMETERS = 100;
+var D1_MAX_VALUE_BYTES = 2e6;
+var asBytes = (view) => {
+  if (view.byteLength === 0) return new Uint8Array(0);
+  return view instanceof Uint8Array ? view : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+};
+var d1TypeError = (value) => new Error(`D1_TYPE_ERROR: Type '${typeof value}' not supported for value '${String(value)}'`, {
+  cause: new Error(`Type '${typeof value}' not supported for value '${String(value)}'`)
+});
+function toSql(value, index) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (typeof value === "number" || typeof value === "bigint" || typeof value === "string") return value;
+  if (value instanceof Uint8Array || value instanceof Uint8ClampedArray) return asBytes(value);
+  if (value instanceof ArrayBuffer) return asBytes(new Uint8Array(value));
+  const place = `bound value ${String(index + 1)}`;
+  if (ArrayBuffer.isView(value)) {
+    const kind = value.constructor?.name ?? "view";
+    throw new Error(
+      `wirl dev refuses ${place}, ${/^[AEIO]/.test(kind) ? "an" : "a"} ${kind}: D1 binds a view as the list of its elements, not its bytes, and what it stores for this one has not been measured. To store the view's bytes, bind new Uint8Array(value.buffer, value.byteOffset, value.byteLength).`
+    );
+  }
+  if (Array.isArray(value)) {
+    if (!value.every((item) => typeof item === "number" && item >= 0 && item < 256)) throw d1TypeError(value);
+    if (!value.every((item) => Number.isInteger(item))) {
+      throw new Error(
+        `wirl dev refuses ${place}, an array holding a number that is not a whole byte: D1 passes it on as it is, and what it stores for a fraction has not been measured. Bind whole numbers from 0 to 255.`
+      );
+    }
+    return Uint8Array.from(value);
+  }
+  throw d1TypeError(value);
+}
+function fromSql(value) {
+  return value instanceof Uint8Array ? Array.from(value) : value;
+}
+function d1Row(row) {
+  return Object.fromEntries(Object.entries(row).map(([name, value]) => [name, fromSql(value)]));
+}
+var now = () => performance.now();
+function offsetOfNthPlaceholder(sql, n) {
+  let seen = 0;
+  for (let index = 0; index < sql.length; index += 1) {
+    if (sql[index] === "?") {
+      seen += 1;
+      if (seen === n) return index;
+    }
+  }
+  return 0;
+}
+function assertBoundParamLimit(sql, paramCount) {
+  if (paramCount <= D1_MAX_BOUND_PARAMETERS) return;
+  const offset = offsetOfNthPlaceholder(sql, D1_MAX_BOUND_PARAMETERS + 1);
+  throw new Error(`D1_ERROR: too many SQL variables at offset ${offset}: SQLITE_ERROR`);
+}
+function valueBytes(value) {
+  if (typeof value === "string") return Buffer.byteLength(value, "utf8");
+  if (value instanceof Uint8Array) return value.byteLength;
+  return 0;
+}
+function assertValueSizes(params) {
+  for (const [index, value] of params.entries()) {
+    const bytes = valueBytes(value);
+    if (bytes <= D1_MAX_VALUE_BYTES) continue;
+    throw new Error(
+      `D1_ERROR: string or blob too big: SQLITE_TOOBIG. wirl dev refuses this statement because bound value ${String(index + 1)} is ${bytes.toLocaleString("en-US")} bytes, over ${D1_MAX_VALUE_BYTES.toLocaleString("en-US")} bytes, the limit Cloudflare publishes for a D1 string, BLOB or row. Store a larger file in chunks, one row each.`
+    );
+  }
+}
+var meta = (over) => ({
+  duration: 0,
+  changes: 0,
+  last_row_id: 0,
+  rows_read: 0,
+  rows_written: 0,
+  served_by: "local",
+  changed_db: false,
+  size_after: 0,
+  ...over
+});
+var Statement = class _Statement {
+  #db;
+  #sql;
+  #params;
+  constructor(db, sql, params = []) {
+    this.#db = db;
+    this.#sql = sql;
+    this.#params = params;
+  }
+  /** A new statement, as D1 does. The original stays unbound and reusable. */
+  bind(...values) {
+    return new _Statement(this.#db, this.#sql, values.map((value, index) => toSql(value, index)));
+  }
+  /** Synchronous inside, because node:sqlite is; wrapped so the shape is D1's. */
+  execute() {
+    assertBoundParamLimit(this.#sql, this.#params.length);
+    assertValueSizes(this.#params);
+    const began = now();
+    const prepared = this.#db.prepare(this.#sql);
+    const returnsRows = prepared.columns().length > 0;
+    if (returnsRows) {
+      const results = prepared.all(...this.#params).map(
+        (row) => d1Row(row)
+      );
+      return {
+        success: true,
+        results,
+        meta: meta({ duration: now() - began, rows_read: results.length })
+      };
+    }
+    const outcome = prepared.run(...this.#params);
+    const changes = Number(outcome.changes);
+    return {
+      success: true,
+      results: [],
+      meta: meta({
+        duration: now() - began,
+        changes,
+        last_row_id: Number(outcome.lastInsertRowid),
+        rows_written: changes,
+        changed_db: changes > 0
+      })
+    };
+  }
+  async all() {
+    return this.execute();
+  }
+  async run() {
+    return this.execute();
+  }
+  async first(column) {
+    const row = this.execute().results[0];
+    if (row === void 0) return null;
+    if (column === void 0) return row;
+    return row[column] ?? null;
+  }
+  async raw(options = {}) {
+    assertBoundParamLimit(this.#sql, this.#params.length);
+    assertValueSizes(this.#params);
+    const prepared = this.#db.prepare(this.#sql);
+    const names = prepared.columns().map((column) => column.name);
+    const rows = prepared.all(...this.#params);
+    const values = rows.map((row) => names.map((name) => fromSql(row[name])));
+    return options.columnNames ? [names, ...values] : values;
+  }
+};
+function createLocalDatabase(path) {
+  const db = new DatabaseSync(path);
+  return {
+    prepare: (sql) => new Statement(db, sql),
+    async batch(statements) {
+      db.exec("BEGIN");
+      try {
+        const results = [];
+        for (const statement of statements) results.push(statement.execute());
+        db.exec("COMMIT");
+        return results;
+      } catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+      }
+    },
+    async exec(sql) {
+      const began = now();
+      const lines = sql.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+      for (const [index, line] of lines.entries()) {
+        try {
+          db.exec(line);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          throw new Error(`D1_EXEC_ERROR: Error in line ${index + 1}: ${line}: ${message}: SQLITE_ERROR`);
+        }
+      }
+      return { count: lines.length, duration: now() - began };
+    }
+  };
+}
+
+// packages/runtime/src/serve-module.mjs
+var modulePath = process.env.WIRL_MODULE;
+var port = Number(process.env.PORT);
+var die = (message) => {
+  process.stderr.write(`${message}
+`);
+  process.exit(1);
+};
+if (!modulePath) die("WIRL_MODULE is not set, so there is no module to serve.");
+if (!Number.isInteger(port) || port <= 0) die(`PORT is not a usable port: ${process.env.PORT}`);
+var STATUS_TEXT = { 502: "Bad Gateway", 504: "Gateway Timeout" };
+var brokerUrl = process.env.WIRL_BROKER_URL;
+var brokerToken = process.env.WIRL_BROKER_TOKEN;
+if (brokerUrl && brokerToken) {
+  const brokerOrigin = new URL(brokerUrl).origin;
+  const direct = globalThis.fetch;
+  const NOT_FORWARDED = /* @__PURE__ */ new Set(["host", "content-length", "authorization", "x-wirl-target"]);
+  globalThis.fetch = async (input, init) => {
+    const request = new Request(input, init);
+    let target;
+    try {
+      target = new URL(request.url);
+    } catch {
+      return direct(input, init);
+    }
+    const local = target.hostname === "127.0.0.1" || target.hostname === "localhost" || target.hostname === "[::1]";
+    if (target.origin === brokerOrigin || local || target.protocol !== "https:" && target.protocol !== "http:") {
+      return direct(input, init);
+    }
+    const headers = new Headers();
+    request.headers.forEach((value, name) => {
+      if (!NOT_FORWARDED.has(name.toLowerCase())) headers.set(name, value);
+    });
+    headers.set("authorization", `Bearer ${brokerToken}`);
+    headers.set("x-wirl-target", request.url);
+    const hasBody = request.method !== "GET" && request.method !== "HEAD";
+    const brokered = await direct(`${brokerUrl}/_/`, {
+      method: request.method,
+      headers,
+      ...hasBody ? { body: await request.arrayBuffer() } : {},
+      redirect: "manual",
+      // The app's own abort, carried to the broker: a stop button or a
+      // timeout closes this connection, which is what tells the broker to
+      // stop the vendor's call and give back its stream slot, as the
+      // platform's fetch does deployed. The app's read then rejects with its
+      // AbortError here too, rather than going on as if nothing happened.
+      signal: request.signal
+    });
+    const carried = brokered.headers.get("x-wirl-status");
+    if (carried === null) return brokered;
+    const restoredHeaders = new Headers(brokered.headers);
+    restoredHeaders.delete("x-wirl-status");
+    const named = Number(carried);
+    const status = brokered.status === 500 && (named === 502 || named === 504) ? named : brokered.status;
+    return new Response(brokered.body, { status, statusText: STATUS_TEXT[status] ?? brokered.statusText, headers: restoredHeaders });
+  };
+}
+if (process.env.WIRL_DEV_FS_WARN === "1") {
+  const WARNING_PREFIX = "wirl dev: the app is writing ";
+  const WROTE_PREFIX = "wirl dev wrote: ";
+  const NAMED_EVERY_MS = 250;
+  const named = /* @__PURE__ */ new Map();
+  const { O_WRONLY, O_RDWR, O_CREAT, O_APPEND, O_TRUNC } = fs.constants;
+  const forWriting = (flags) => typeof flags === "string" ? /[wa+]/.test(flags) : typeof flags === "number" && (flags & (O_WRONLY | O_RDWR | O_CREAT | O_APPEND | O_TRUNC)) !== 0;
+  const pathOf = (target) => {
+    if (typeof target === "string") return target;
+    if (Buffer.isBuffer(target)) return target.toString("utf8");
+    if (target instanceof URL) {
+      try {
+        return fileURLToPath(target);
+      } catch {
+        return target.href;
+      }
+    }
+    return null;
+  };
+  let told = false;
+  const tell = (target) => {
+    const path = pathOf(target);
+    if (path === null) return;
+    const absolute = resolve(path);
+    const now2 = Date.now();
+    const last = named.get(absolute);
+    if (last === void 0 || now2 - last >= NAMED_EVERY_MS) {
+      if (last === void 0 && named.size >= 1e3) named.clear();
+      named.set(absolute, now2);
+      process.stderr.write(`${WROTE_PREFIX}${JSON.stringify(absolute)}
+`);
+    }
+    if (told) return;
+    told = true;
+    const shown = path.length > 200 ? `${path.slice(0, 200)}...` : path;
+    process.stderr.write(
+      `${WARNING_PREFIX}${JSON.stringify(shown)} through node:fs. Here it stays on disk; deployed, it will not be there by the next request. Keep what must last in env.DB.
+`
+    );
+  };
+  const WRITES = [
+    ["writeFile", 0],
+    ["appendFile", 0],
+    ["mkdir", 0],
+    ["copyFile", 1],
+    ["cp", 1],
+    ["rename", 1],
+    ["open", 0, 1]
+  ];
+  const watch = (target, name, at, flagsAt) => {
+    const original = target[name];
+    if (typeof original !== "function") return;
+    target[name] = function(...args) {
+      if (flagsAt === void 0 || forWriting(args[flagsAt])) tell(args[at]);
+      return original.apply(this, args);
+    };
+  };
+  for (const [name, at, flagsAt] of WRITES) {
+    watch(fs, name, at, flagsAt);
+    watch(fs, `${name}Sync`, at, flagsAt);
+    watch(fs.promises, name, at, flagsAt);
+  }
+  watch(fs, "createWriteStream", 0);
+  syncBuiltinESMExports();
+}
+var loaded = await import(pathToFileURL(modulePath).href).catch(
+  (error) => die(`Could not import ${modulePath}: ${error instanceof Error ? error.message : String(error)}`)
+);
+var handler = loaded?.default?.fetch;
+if (typeof handler !== "function") die(`${modulePath} has no default export with a fetch.`);
+var localDb = process.env.WIRL_LOCAL_DB;
+var env = localDb ? { DB: createLocalDatabase(localDb) } : {};
+var devIdentity = null;
+if (process.env.WIRL_DEV_IDENTITY) {
+  try {
+    devIdentity = JSON.parse(process.env.WIRL_DEV_IDENTITY);
+  } catch {
+    die("WIRL_DEV_IDENTITY is not valid JSON.");
+  }
+}
+var SCHEDULE_PREFIX = "/__wirl/schedule/";
+var FLOW_PREFIX = "/__wirl/flow/";
+var FLOW_ONLY_HEADERS = ["x-wirl-flow", "x-wirl-step", "x-wirl-n", "x-wirl-idempotency-key"];
+var STEP_WORD = /^[A-Za-z0-9_-]{1,100}$/;
+function flowStepOf(body) {
+  let posted = null;
+  try {
+    posted = JSON.parse(body.toString("utf8"));
+  } catch {
+    posted = null;
+  }
+  const fields = posted !== null && typeof posted === "object" && !Array.isArray(posted) ? posted : {};
+  const word = (value, fallback) => typeof value === "string" && STEP_WORD.test(value) ? value : fallback;
+  const count = (value, least, fallback) => Number.isSafeInteger(value) && value >= least ? value : fallback;
+  return { run: word(fields.run, "dev"), step: word(fields.step, "start"), n: count(fields.n, 0, 0), attempt: count(fields.attempt, 1, 1) };
+}
+function idempotencyKeyOf(appId, { run, n, step }) {
+  return step === "failed" || step === "cancelled" ? `${appId}:${run}:${n}:${step}` : `${appId}:${run}:${n}`;
+}
+var VISITOR_HEADERS = ["x-wirl-user-id", "x-wirl-user-email", "x-wirl-user-name", "x-wirl-role"];
+var publicPaths = [];
+if (process.env.WIRL_DEV_PUBLIC_PATHS) {
+  try {
+    publicPaths = JSON.parse(process.env.WIRL_DEV_PUBLIC_PATHS);
+  } catch {
+    die("WIRL_DEV_PUBLIC_PATHS is not valid JSON.");
+  }
+}
+var isPublicPath = (pathname) => publicPaths.some(
+  (path) => path.endsWith("/*") ? pathname.startsWith(path.slice(0, -1)) : pathname === path
+);
+var staticFiles = null;
+if (process.env.WIRL_DEV_STATIC) {
+  try {
+    staticFiles = JSON.parse(process.env.WIRL_DEV_STATIC);
+  } catch {
+    die("WIRL_DEV_STATIC is not valid JSON.");
+  }
+}
+var CONTENT_TYPES = {
+  html: "text/html; charset=utf-8",
+  css: "text/css; charset=utf-8",
+  js: "text/javascript; charset=utf-8",
+  mjs: "text/javascript; charset=utf-8",
+  json: "application/json",
+  map: "application/json",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  ico: "image/x-icon",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  txt: "text/plain; charset=utf-8",
+  xml: "application/xml",
+  pdf: "application/pdf",
+  wasm: "application/wasm",
+  webmanifest: "application/manifest+json"
+};
+function staticKey(pathname) {
+  let path;
+  try {
+    path = decodeURIComponent(pathname);
+  } catch {
+    return null;
+  }
+  if (/[\u0000-\u001f\u007f]/.test(path) || path.includes("\\")) return null;
+  if (path === "" || path.endsWith("/")) path += "index.html";
+  const parts = [];
+  for (const segment of path.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") return null;
+    parts.push(segment);
+  }
+  return parts.length === 0 ? "index.html" : parts.join("/");
+}
+async function staticResponse(method, pathname, accept) {
+  if (staticFiles === null || method !== "GET" && method !== "HEAD") return null;
+  const key = staticKey(pathname);
+  if (key === null) return null;
+  const read = (name2) => readFile(join(staticFiles.root, name2)).catch(() => null);
+  let name = key;
+  let body = await read(name);
+  if (body === null && staticFiles.spa && !/\.[a-z0-9]{1,8}$/i.test(key) && accept.includes("text/html")) {
+    name = "index.html";
+    body = await read(name);
+  }
+  if (body === null) return null;
+  const extension = name.includes(".") ? name.slice(name.lastIndexOf(".") + 1).toLowerCase() : "";
+  return { body, contentType: CONTENT_TYPES[extension] ?? "application/octet-stream" };
+}
+var verbose = process.env.WIRL_DEV_VERBOSE === "1";
+createServer(async (incoming, outgoing) => {
+  if (verbose) {
+    const began = Date.now();
+    const path = (incoming.url ?? "/").split("?")[0] ?? "/";
+    outgoing.once("close", () => {
+      process.stdout.write(`${incoming.method} ${path}  ${outgoing.statusCode} \xB7 ${Date.now() - began} ms
+`);
+    });
+  }
+  try {
+    {
+      const path = (incoming.url ?? "/").split("?")[0] ?? "/";
+      if (!path.startsWith(SCHEDULE_PREFIX) && !path.startsWith(FLOW_PREFIX) && !isPublicPath(path)) {
+        const file = await staticResponse(incoming.method ?? "GET", path, String(incoming.headers.accept ?? ""));
+        if (file !== null) {
+          outgoing.writeHead(200, { "content-type": file.contentType, "content-length": String(file.body.byteLength) });
+          outgoing.end(incoming.method === "HEAD" ? void 0 : file.body);
+          return;
+        }
+      }
+    }
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(incoming.headers)) {
+      if (Array.isArray(value)) for (const each of value) headers.append(name, each);
+      else if (typeof value === "string") headers.set(name, value);
+    }
+    const chunks = [];
+    for await (const chunk of incoming) chunks.push(chunk);
+    const hasBody = incoming.method !== "GET" && incoming.method !== "HEAD" && chunks.length > 0;
+    if (devIdentity) {
+      const fillIn = (name, value) => {
+        if (!headers.has(name)) headers.set(name, String(value));
+      };
+      const pathname = (incoming.url ?? "/").split("?")[0] ?? "/";
+      let flowStep = null;
+      for (const name of FLOW_ONLY_HEADERS) headers.delete(name);
+      if (pathname.startsWith(SCHEDULE_PREFIX)) {
+        for (const name of VISITOR_HEADERS) headers.set(name, "");
+        headers.set("x-wirl-schedule", pathname.slice(SCHEDULE_PREFIX.length));
+        headers.set("x-wirl-run", "dev");
+        headers.set("x-wirl-attempt", "1");
+      } else if (pathname.startsWith(FLOW_PREFIX)) {
+        for (const name of VISITOR_HEADERS) headers.set(name, "");
+        flowStep = flowStepOf(Buffer.concat(chunks));
+        headers.set("x-wirl-flow", pathname.slice(FLOW_PREFIX.length));
+        headers.set("x-wirl-run", flowStep.run);
+        headers.set("x-wirl-step", flowStep.step);
+        headers.set("x-wirl-n", String(flowStep.n));
+        headers.set("x-wirl-attempt", String(flowStep.attempt));
+      } else if (isPublicPath(pathname)) {
+        for (const name of VISITOR_HEADERS) headers.set(name, "");
+        headers.set("x-wirl-public", "1");
+      } else {
+        fillIn("x-wirl-user-id", devIdentity.userId ?? "");
+        fillIn("x-wirl-user-email", devIdentity.email ?? "");
+        fillIn("x-wirl-user-name", devIdentity.name ?? "");
+        fillIn("x-wirl-role", devIdentity.role ?? "");
+      }
+      fillIn("x-wirl-org", devIdentity.org ?? "");
+      fillIn("x-wirl-app-id", devIdentity.appId ?? "local");
+      if (flowStep !== null) headers.set("x-wirl-idempotency-key", idempotencyKeyOf(headers.get("x-wirl-app-id") ?? "", flowStep));
+    }
+    const request = new Request(`http://${incoming.headers.host ?? "localhost"}${incoming.url ?? "/"}`, {
+      method: incoming.method,
+      headers,
+      ...hasBody ? { body: Buffer.concat(chunks) } : {}
+    });
+    const response = await handler(request, env, {});
+    response.headers.forEach((value, name) => {
+      if (name.toLowerCase() !== "set-cookie") outgoing.setHeader(name, value);
+    });
+    const cookies = response.headers.getSetCookie();
+    if (cookies.length > 0) outgoing.setHeader("set-cookie", cookies);
+    outgoing.writeHead(response.status);
+    if (response.body === null) {
+      outgoing.end();
+    } else {
+      outgoing.flushHeaders();
+      const reader = response.body.getReader();
+      const gone = new Promise((resolve2) => {
+        outgoing.once("close", () => {
+          resolve2();
+          void reader.cancel().catch(() => {
+          });
+        });
+      });
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (!outgoing.write(value)) {
+          let resume;
+          const drained = new Promise((resolve2) => {
+            resume = resolve2;
+            outgoing.once("drain", resolve2);
+          });
+          await Promise.race([drained, gone]);
+          outgoing.off("drain", resume);
+        }
+      }
+      outgoing.end();
+    }
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}
+`);
+    if (outgoing.headersSent) {
+      outgoing.destroy();
+      return;
+    }
+    outgoing.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+    outgoing.end(`Internal error: ${error instanceof Error ? error.message : String(error)}
+`);
+  }
+}).listen(port, "0.0.0.0", () => {
+  process.stdout.write(`serving ${modulePath} on ${port}
+`);
+});

package/dist/index.d.mts

@@ -1,73 +0,0 @@
-interface WirlOptions {
-    apiKey: string;
-    baseUrl?: string;
-}
-interface TrackParams {
-    email: string;
-    event: string;
-    properties?: Record<string, unknown>;
-}
-interface IdentifyParams {
-    email: string;
-    properties: Record<string, unknown>;
-}
-interface TriggerParams {
-    email: string;
-    sequence: string;
-}
-interface ExitParams {
-    email: string;
-    sequence: string;
-}
-interface TrackResponse {
-    success: boolean;
-    contact_id: string;
-    event_id: string;
-}
-interface IdentifyResponse {
-    success: boolean;
-    contact_id: string;
-    created: boolean;
-}
-interface TriggerResponse {
-    success: boolean;
-    enrolled: boolean;
-}
-interface ExitResponse {
-    success: boolean;
-    exited: boolean;
-}
-interface WirlError {
-    error: string;
-    details?: unknown;
-}
-declare class WirlAPIError extends Error {
-    readonly statusCode: number;
-    readonly details?: unknown;
-    constructor(message: string, statusCode: number, details?: unknown);
-}
-declare class Wirl {
-    private readonly apiKey;
-    private readonly baseUrl;
-    constructor(options: WirlOptions);
-    private request;
-    /**
-     * Track an event for a contact.
-     * Creates the contact if they don't exist.
-     */
-    track(params: TrackParams): Promise<TrackResponse>;
-    /**
-     * Create or update a contact with properties.
-     */
-    identify(params: IdentifyParams): Promise<IdentifyResponse>;
-    /**
-     * Manually enroll a contact in a sequence.
-     */
-    trigger(params: TriggerParams): Promise<TriggerResponse>;
-    /**
-     * Remove a contact from an active sequence.
-     */
-    exit(params: ExitParams): Promise<ExitResponse>;
-}
-
-export { type ExitParams, type ExitResponse, type IdentifyParams, type IdentifyResponse, type TrackParams, type TrackResponse, type TriggerParams, type TriggerResponse, Wirl, WirlAPIError, type WirlError, type WirlOptions, Wirl as default };