@palbase/web 1.9.0 → 2.0.0

package/dist/gen/cli.js

@@ -0,0 +1,1206 @@
+#!/usr/bin/env node
+import "../chunk-PZ5AY32C.js";
+
+// src/gen/cli.ts
+import process2 from "process";
+
+// src/gen/generate.ts
+import { createHash } from "crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import process from "process";
+import { parseArgs } from "util";
+
+// src/gen/emitter.ts
+function opSegments(opId) {
+  return opId.split(".").filter((p) => p !== "");
+}
+function typeNameOf(s) {
+  return sanitize(s, true);
+}
+function typePrefix(opId) {
+  return opSegments(opId).map(typeNameOf).join("");
+}
+function sanitize(s, firstUpper) {
+  const parts = [];
+  let cur = "";
+  for (const ch of s) {
+    if (/^[A-Za-z0-9]$/.test(ch)) {
+      cur += ch;
+    } else if (cur.length > 0) {
+      parts.push(cur);
+      cur = "";
+    }
+  }
+  if (cur.length > 0) parts.push(cur);
+  if (parts.length === 0) return firstUpper ? "Op" : "op";
+  let out = "";
+  parts.forEach((p, i) => {
+    out += i === 0 && !firstUpper ? p.charAt(0).toLowerCase() + p.slice(1) : p.charAt(0).toUpperCase() + p.slice(1);
+  });
+  if (out.charAt(0) >= "0" && out.charAt(0) <= "9") out = `_${out}`;
+  return out;
+}
+function emitTypeScript(ops, cfg) {
+  const usable = [];
+  const skippedNS = [];
+  const seenSkip = /* @__PURE__ */ new Set();
+  for (const op of ops) {
+    const [ns] = opSegments(op.operationId);
+    if (ns === void 0) continue;
+    if (tsReservedTopLevel(ns)) {
+      const key = ns.toLowerCase();
+      if (!seenSkip.has(key)) {
+        seenSkip.add(key);
+        skippedNS.push(ns);
+      }
+      continue;
+    }
+    usable.push(op);
+  }
+  skippedNS.sort();
+  const [candidates, opSkips] = filterTSOps(usable);
+  const [typesOut, collisionSkips, typeCollisionOps] = emitTSTypes(candidates);
+  const registerable = candidates.filter((op) => !typeCollisionOps.has(op.operationId));
+  const [errorsOut, classCount] = emitTSTypedErrors(registerable);
+  let b = "";
+  b += "// AUTO-GENERATED by `palbe-gen` \u2014 DO NOT EDIT.\n";
+  b += "// Regenerate: palbe-gen   (or automatically via the predev/prebuild script)\n";
+  const typeImports = [];
+  if (classCount > 0) typeImports.push("BackendError");
+  if (registerable.length > 0) typeImports.push("CallOptions");
+  if (typeImports.length > 0) {
+    b += `import type { ${typeImports.join(", ")} } from '@palbase/web';
+`;
+  }
+  b += "import { __configure, __registerNamespaces } from '@palbase/web/internal';\n\n";
+  b += emitTSConfigure(cfg);
+  b += "\n";
+  b += typesOut;
+  b += errorsOut;
+  b += "// \u2500\u2500 Namespaces \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n";
+  for (const ns of skippedNS) {
+    b += `// codegen: skipped reserved namespace "${ns}"
+`;
+  }
+  for (const l of opSkips) {
+    b += `${l}
+`;
+  }
+  for (const c of collisionSkips) {
+    b += `${c}
+`;
+  }
+  b += emitTSRegistration(registerable);
+  if (registerable.length > 0) {
+    b += "\n";
+    b += emitTSAugmentation(registerable);
+  }
+  return b;
+}
+function emitTSConfigure(cfg) {
+  const branch = cfg.branch === "" ? "main" : cfg.branch;
+  let b = "__configure({\n";
+  b += `  url: ${tsStringLit(cfg.url)},
+`;
+  b += `  apiKey: ${tsStringLit(cfg.apiKey)},
+`;
+  b += `  appId: ${tsStringLit(cfg.appId)},
+`;
+  b += `  branch: ${tsStringLit(branch)},
+`;
+  const oauth = renderTSOAuth(cfg.oauth);
+  if (oauth !== "") {
+    b += "  oauth: {\n";
+    b += oauth;
+    b += "  },\n";
+  }
+  b += "});\n";
+  return b;
+}
+function renderTSOAuth(o) {
+  if (!o) return "";
+  let b = "";
+  if (o.apple?.enabled) {
+    b += "    apple: { enabled: true },\n";
+  }
+  if (o.google?.enabled && o.google.clientId !== "") {
+    b += `    google: { enabled: true, clientId: ${tsStringLit(o.google.clientId)} },
+`;
+  }
+  return b;
+}
+function filterTSOps(ops) {
+  const out = [];
+  const skips = [];
+  const root = new TSNode();
+  for (const op of ops) {
+    const segs = opSegments(op.operationId);
+    const lastSeg = segs[segs.length - 1];
+    if (lastSeg === void 0) continue;
+    let skip = false;
+    for (const seg of segs.slice(1)) {
+      if (tsReservedNested(seg)) {
+        skips.push(`// codegen: skipped operation "${op.operationId}" (reserved segment "${seg}")`);
+        skip = true;
+        break;
+      }
+    }
+    if (skip) continue;
+    if (op.input && op.query) {
+      skips.push(
+        `// codegen: skipped operation "${op.operationId}" (both body and query declared \u2014 unsupported)`
+      );
+      continue;
+    }
+    if (op.query) {
+      const bad = firstNonPrimitiveQueryProp(op.query);
+      if (bad !== void 0) {
+        skips.push(
+          `// codegen: skipped operation "${op.operationId}" (non-primitive query parameter "${bad}")`
+        );
+        continue;
+      }
+    }
+    let node = root;
+    for (const seg of segs.slice(0, -1)) {
+      node = node.childNode(seg);
+      if (!node) break;
+    }
+    if (!node?.addMethod(lastSeg, op)) {
+      skips.push(
+        `// codegen: skipped operation "${op.operationId}" (key collides with existing namespace/method)`
+      );
+      continue;
+    }
+    out.push(op);
+  }
+  return [out, skips];
+}
+function firstNonPrimitiveQueryProp(q) {
+  for (const p of q.props) {
+    switch (p.schema.kind) {
+      case "string":
+      case "number":
+      case "integer":
+      case "boolean":
+      case "enum":
+        break;
+      // primitive — serializeQuery handles it
+      default:
+        return p.name;
+    }
+  }
+  return void 0;
+}
+function emitTSTypes(ops) {
+  const collisionOps = /* @__PURE__ */ new Set();
+  const seenPrefix = /* @__PURE__ */ new Map();
+  const collisionSkips = [];
+  const lines = [];
+  for (const op of ops) {
+    const pfx = typePrefix(op.operationId);
+    const first = seenPrefix.get(pfx);
+    if (first !== void 0) {
+      collisionSkips.push(`// codegen: skipped type "${pfx}" (collides with operation "${first}")`);
+      collisionOps.add(op.operationId);
+      continue;
+    }
+    seenPrefix.set(pfx, op.operationId);
+    if (op.input) {
+      lines.push(...tsNamedTypeLines(`${pfx}Request`, op.input));
+    }
+    if (op.query) {
+      lines.push(...tsNamedTypeLines(`${pfx}Query`, op.query));
+    }
+    if (op.output) {
+      lines.push(...tsResponseTypeLines(pfx, op.output));
+    }
+    const [liftable] = tsLiftableErrors(op);
+    for (const e of liftable) {
+      if (!e.data) continue;
+      const dataName = `${pfx}${typeNameOf(e.name)}Data`;
+      lines.push(`/** ${e.code} (${e.status}): ${e.description} */`);
+      lines.push(...tsNamedTypeLines(dataName, e.data));
+    }
+  }
+  if (lines.length === 0) {
+    return ["", collisionSkips, collisionOps];
+  }
+  let b = "// \u2500\u2500 Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n";
+  for (const l of lines) {
+    b += `${l}
+`;
+  }
+  return [b, collisionSkips, collisionOps];
+}
+function tsNamedTypeLines(name, s) {
+  if (s.kind === "object") {
+    return tsInterfaceLines(name, s);
+  }
+  return [`export type ${name} = ${tsTypeOf(s)};`, ""];
+}
+function tsResponseTypeLines(pfx, s) {
+  if (s.kind === "array" && s.elem && s.elem.kind === "object") {
+    return [
+      ...tsInterfaceLines(`${pfx}ResponseItem`, s.elem),
+      `export type ${pfx}Response = ${pfx}ResponseItem[];`,
+      ""
+    ];
+  }
+  return tsNamedTypeLines(`${pfx}Response`, s);
+}
+function tsInterfaceLines(name, s) {
+  const lines = [`export interface ${name} {`];
+  for (const p of s.props) {
+    if (p.name === "__proto__") {
+      lines.push('  // codegen: skipped property "__proto__"');
+      continue;
+    }
+    const opt = p.required ? "" : "?";
+    lines.push(`  ${tsPropKey(p.name)}${opt}: ${tsTypeOf(p.schema)};`);
+  }
+  lines.push("}", "");
+  return lines;
+}
+function tsTypeOf(s) {
+  switch (s.kind) {
+    case "string":
+      return s.nullable ? "string | null" : "string";
+    case "number":
+    case "integer":
+      return s.nullable ? "number | null" : "number";
+    case "boolean":
+      return s.nullable ? "boolean | null" : "boolean";
+    case "enum": {
+      const union = s.enumVals.map(tsStringLit).join(" | ");
+      return s.nullable ? `(${union}) | null` : union;
+    }
+    case "array": {
+      if (!s.elem) {
+        return s.nullable ? "unknown[] | null" : "unknown[]";
+      }
+      let elem = tsTypeOf(s.elem);
+      if (elem.includes(" | ") || elem.startsWith("(")) {
+        elem = `(${elem})`;
+      }
+      const arr = `${elem}[]`;
+      return s.nullable ? `${arr} | null` : arr;
+    }
+    case "object": {
+      const inline = tsInlineObject(s);
+      return s.nullable ? `${inline} | null` : inline;
+    }
+    default:
+      return s.nullable ? "unknown | null" : "unknown";
+  }
+}
+function tsInlineObject(s) {
+  const parts = [];
+  for (const p of s.props) {
+    if (p.name === "__proto__") continue;
+    const opt = p.required ? "" : "?";
+    parts.push(`${tsPropKey(p.name)}${opt}: ${tsTypeOf(p.schema)}`);
+  }
+  if (parts.length === 0) return "Record<string, unknown>";
+  return `{ ${parts.join("; ")} }`;
+}
+var tsInfraReservedCodes = /* @__PURE__ */ new Set([
+  "not_configured",
+  "network_error",
+  "decode_error",
+  "validation_error",
+  "unauthorized",
+  "rate_limited",
+  "invalid_endpoint_name",
+  "unsupported_get_input",
+  "missing_path_param",
+  "unexpected_argument",
+  "invalid_query_value",
+  "reserved_namespace",
+  "invalid_namespace_tree",
+  "aborted",
+  "http_error"
+]);
+function tsLiftableErrors(op) {
+  if (op.errors.length === 0) return [[], []];
+  const sorted = [...op.errors].sort((a, b) => a.code < b.code ? -1 : a.code > b.code ? 1 : 0);
+  const seenCode = /* @__PURE__ */ new Set();
+  const seenClass = /* @__PURE__ */ new Map();
+  const liftable = [];
+  const comments = [];
+  for (const e of sorted) {
+    if (e.code === "__proto__") {
+      comments.push('// codegen: skipped error code "__proto__"');
+      continue;
+    }
+    if (tsInfraReservedCodes.has(e.code)) {
+      comments.push(`// codegen: skipped error code "${e.code}" (reserved infra code)`);
+      continue;
+    }
+    if (seenCode.has(e.code)) {
+      comments.push(`// codegen: skipped duplicate error code "${e.code}"`);
+      continue;
+    }
+    const stem = typeNameOf(e.name);
+    const first = seenClass.get(stem);
+    if (first !== void 0) {
+      comments.push(`// codegen: skipped error "${e.name}" (class name collides with "${first}")`);
+      continue;
+    }
+    seenCode.add(e.code);
+    seenClass.set(stem, e.name);
+    liftable.push(e);
+  }
+  return [liftable, comments];
+}
+function emitTSTypedErrors(ops) {
+  let count = 0;
+  const lines = [];
+  for (const op of ops) {
+    const pfx = typePrefix(op.operationId);
+    const [liftable] = tsLiftableErrors(op);
+    for (const e of liftable) {
+      const className = `${pfx}${typeNameOf(e.name)}Error`;
+      const hasData = e.data !== void 0;
+      lines.push(`export class ${className} extends Error {`);
+      lines.push(`  readonly name = '${className}';`);
+      lines.push(`  readonly code = '${e.code}';`);
+      lines.push(`  readonly status = ${e.status};`);
+      if (hasData) {
+        lines.push(`  readonly data: ${pfx}${typeNameOf(e.name)}Data;`);
+      }
+      lines.push("  readonly cause: BackendError;");
+      lines.push("  constructor(cause: BackendError) {");
+      lines.push("    super(cause.message);");
+      lines.push("    this.cause = cause;");
+      if (hasData) {
+        lines.push(`    this.data = cause.data as ${pfx}${typeNameOf(e.name)}Data;`);
+      }
+      lines.push("  }");
+      lines.push("}");
+      lines.push("");
+      count++;
+    }
+  }
+  if (count === 0) return ["", 0];
+  let b = "// \u2500\u2500 Typed errors \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n";
+  for (const l of lines) {
+    b += `${l}
+`;
+  }
+  return [b, count];
+}
+var TSNode = class _TSNode {
+  entries = [];
+  index = /* @__PURE__ */ new Map();
+  // childNode returns (creating if needed) the nested namespace node for key.
+  // Returns undefined if a METHOD entry already occupies the key (kind
+  // mismatch).
+  childNode(key) {
+    const e = this.index.get(key);
+    if (e) return e.child;
+    const child = new _TSNode();
+    const entry = { key, child };
+    this.entries.push(entry);
+    this.index.set(key, entry);
+    return child;
+  }
+  // addMethod registers a method at key. Returns false if the key is already
+  // occupied (either by another method or by a namespace node).
+  addMethod(key, op) {
+    if (this.index.has(key)) return false;
+    const entry = { key, op };
+    this.entries.push(entry);
+    this.index.set(key, entry);
+    return true;
+  }
+};
+function buildTSTrie(ops) {
+  const root = new TSNode();
+  for (const op of ops) {
+    const segs = opSegments(op.operationId);
+    const lastSeg = segs[segs.length - 1];
+    if (lastSeg === void 0) continue;
+    let node = root;
+    for (const seg of segs.slice(0, -1)) {
+      node = node.childNode(seg);
+      if (!node) break;
+    }
+    if (node) {
+      node.addMethod(lastSeg, op);
+    }
+  }
+  return root;
+}
+function emitTSRegistration(ops) {
+  if (ops.length === 0) {
+    return "__registerNamespaces({});\n";
+  }
+  let b = "__registerNamespaces({\n";
+  b += renderTSNode(buildTSTrie(ops), 2);
+  b += "});\n";
+  return b;
+}
+function renderTSNode(node, indentSpaces) {
+  const ind = " ".repeat(indentSpaces);
+  let b = "";
+  for (const e of node.entries) {
+    if (e.child) {
+      b += `${ind}${tsPropKey(e.key)}: {
+`;
+      b += renderTSNode(e.child, indentSpaces + 2);
+      b += `${ind}},
+`;
+      continue;
+    }
+    if (e.op) {
+      b += renderTSDescriptor(e.op, e.key, indentSpaces);
+    }
+  }
+  return b;
+}
+function renderTSDescriptor(op, methodSeg, indentSpaces) {
+  const ind = " ".repeat(indentSpaces);
+  const key = tsPropKey(methodSeg);
+  const [liftable, errComments] = tsLiftableErrors(op);
+  const hasErrors = liftable.length > 0;
+  const hasPathParams = op.pathParams.length > 0;
+  const hasInput = op.input !== void 0;
+  const hasQuery = op.query !== void 0;
+  let inputVal = "";
+  if (!hasInput && !hasQuery) {
+    inputVal = "none";
+  } else if (hasQuery) {
+    inputVal = "query";
+  }
+  let b = "";
+  if (!hasErrors) {
+    for (const c of errComments) {
+      b += `${ind}${c}
+`;
+    }
+    const parts = [`method: ${tsStringLit(op.method)}`, `path: ${tsStringLit(op.path)}`];
+    if (hasPathParams) {
+      parts.push(`pathParams: [${renderTSStringArray(op.pathParams)}]`);
+    }
+    if (inputVal !== "") {
+      parts.push(`input: ${tsStringLit(inputVal)}`);
+    }
+    b += `${ind}${key}: { ${parts.join(", ")} },
+`;
+    return b;
+  }
+  const innerInd = " ".repeat(indentSpaces + 2);
+  b += `${ind}${key}: {
+`;
+  b += `${innerInd}method: ${tsStringLit(op.method)},
+`;
+  b += `${innerInd}path: ${tsStringLit(op.path)},
+`;
+  if (hasPathParams) {
+    b += `${innerInd}pathParams: [${renderTSStringArray(op.pathParams)}],
+`;
+  }
+  if (inputVal !== "") {
+    b += `${innerInd}input: ${tsStringLit(inputVal)},
+`;
+  }
+  for (const c of errComments) {
+    b += `${innerInd}${c}
+`;
+  }
+  b += `${innerInd}errors: { `;
+  liftable.forEach((e, i) => {
+    if (i > 0) b += ", ";
+    const className = `${typePrefix(op.operationId)}${typeNameOf(e.name)}Error`;
+    b += `${tsPropKey(e.code)}: (e) => new ${className}(e)`;
+  });
+  b += " },\n";
+  b += `${ind}},
+`;
+  return b;
+}
+function renderTSStringArray(ss) {
+  return ss.map(tsStringLit).join(", ");
+}
+function emitTSAugmentation(ops) {
+  let b = "declare module '@palbase/web' {\n";
+  b += "  interface PB {\n";
+  b += renderTSAugNode(buildTSTrie(ops), 4);
+  b += "  }\n";
+  b += "}\n";
+  return b;
+}
+function renderTSAugNode(node, indentSpaces) {
+  const ind = " ".repeat(indentSpaces);
+  let b = "";
+  for (const e of node.entries) {
+    if (e.child) {
+      b += `${ind}${tsPropKey(e.key)}: {
+`;
+      b += renderTSAugNode(e.child, indentSpaces + 2);
+      b += `${ind}};
+`;
+      continue;
+    }
+    if (e.op) {
+      b += `${ind}${tsPropKey(e.key)}${renderTSMethodSignature(e.op)};
+`;
+    }
+  }
+  return b;
+}
+function renderTSMethodSignature(op) {
+  const pfx = typePrefix(op.operationId);
+  const args = [];
+  const used = /* @__PURE__ */ new Set();
+  for (const p of op.pathParams) {
+    args.push(`${tsParamIdent(p, used)}: string`);
+  }
+  if (op.input) {
+    args.push(`input: ${pfx}Request`);
+  } else if (op.query) {
+    args.push(`query: ${pfx}Query`);
+  }
+  args.push(buildOptionsArg(op.headers));
+  const ret = op.output ? `Promise<${pfx}Response>` : "Promise<void>";
+  return `(${args.join(", ")}): ${ret}`;
+}
+function buildOptionsArg(headers) {
+  if (!headers || headers.props.length === 0) {
+    return "options?: CallOptions";
+  }
+  const anyRequired = headers.props.some((p) => p.required);
+  const hParts = headers.props.map((p) => {
+    const opt = p.required ? "" : "?";
+    return `${tsPropKey(p.name)}${opt}: ${tsTypeOf(p.schema)}`;
+  });
+  const headersType = `{ ${hParts.join("; ")} }`;
+  if (anyRequired) {
+    return `options: CallOptions & { headers: ${headersType} }`;
+  }
+  return `options?: CallOptions & { headers?: ${headersType} }`;
+}
+function tsParamIdent(name, used) {
+  let id = sanitize(name, false);
+  if (tsReservedWords.has(id) || id === "input" || id === "query" || id === "options") {
+    id += "_";
+  }
+  let candidate = id;
+  for (let n = 2; used.has(candidate); n++) {
+    candidate = id + n;
+  }
+  used.add(candidate);
+  return candidate;
+}
+var tsReservedWords = /* @__PURE__ */ new Set([
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  // strict-mode reserved / restricted binding names
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  "arguments",
+  "eval"
+]);
+var tsBareKeyRe = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function tsPropKey(name) {
+  return tsBareKeyRe.test(name) ? name : tsStringLit(name);
+}
+function tsStringLit(s) {
+  return `'${s.replaceAll("\\", "\\\\").replaceAll("'", "\\'").replaceAll("\n", "\\n").replaceAll("\r", "\\r")}'`;
+}
+function tsReservedTopLevel(seg) {
+  switch (seg.toLowerCase()) {
+    case "auth":
+    case "analytics":
+    case "flags":
+    case "realtime":
+      return true;
+    default:
+      return tsReservedWebOnly(seg);
+  }
+}
+function tsReservedNested(seg) {
+  if (seg === "then") return true;
+  return tsObjectPrototypeMember(seg);
+}
+function tsReservedWebOnly(seg) {
+  switch (seg) {
+    case "call":
+    case "upload":
+    case "then":
+      return true;
+    default:
+      return tsObjectPrototypeMember(seg);
+  }
+}
+function tsObjectPrototypeMember(seg) {
+  switch (seg) {
+    case "constructor":
+    case "hasOwnProperty":
+    case "isPrototypeOf":
+    case "propertyIsEnumerable":
+    case "toLocaleString":
+    case "toString":
+    case "valueOf":
+    case "__proto__":
+    case "__defineGetter__":
+    case "__defineSetter__":
+    case "__lookupGetter__":
+    case "__lookupSetter__":
+      return true;
+    default:
+      return false;
+  }
+}
+
+// src/gen/parser.ts
+function asObject(v) {
+  if (typeof v === "object" && v !== null && !Array.isArray(v)) return v;
+  return void 0;
+}
+function asString(v) {
+  return typeof v === "string" ? v : "";
+}
+function parseOpenAPI(specText) {
+  let root;
+  try {
+    root = asObject(JSON.parse(specText));
+  } catch (e) {
+    throw new Error(`openapi.json is not valid JSON: ${e instanceof Error ? e.message : e}`);
+  }
+  const paths = asObject(root?.paths);
+  if (!paths) {
+    throw new Error("openapi.json has no `paths`");
+  }
+  const ops = [];
+  for (const [path, item] of Object.entries(paths)) {
+    const methods = asObject(item);
+    if (!methods) continue;
+    for (const [method, raw] of Object.entries(methods)) {
+      const op = asObject(raw);
+      if (!op) continue;
+      const opId = asString(op.operationId);
+      if (opId === "") continue;
+      ops.push({
+        operationId: opId,
+        method: method.toUpperCase(),
+        path,
+        pathParams: pathParamNames(path),
+        input: requestSchema(op),
+        output: responseSchema(op),
+        headers: parametersSchemaIn(op, "header"),
+        query: parametersSchemaIn(op, "query"),
+        errors: declaredErrors(op)
+      });
+    }
+  }
+  ops.sort((a, b) => a.operationId < b.operationId ? -1 : a.operationId > b.operationId ? 1 : 0);
+  return ops;
+}
+function declaredErrors(op) {
+  const extRaw = asObject(op["x-palbase-errors"]);
+  if (!extRaw) return [];
+  const responses = asObject(op.responses);
+  const out = [];
+  for (const [name, raw] of Object.entries(extRaw)) {
+    const entry = asObject(raw);
+    if (!entry) continue;
+    const status = typeof entry.status === "number" ? Math.trunc(entry.status) : 0;
+    const code = asString(entry.code);
+    const description = asString(entry.description);
+    const hasData = entry.hasData === true;
+    if (code === "" || status === 0) continue;
+    const def = { name, code, status, description };
+    if (hasData) {
+      def.data = errorDataSchema(responses, status, code);
+    }
+    out.push(def);
+  }
+  out.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  return out;
+}
+function errorDataSchema(responses, status, code) {
+  const resp = asObject(responses?.[String(status)]);
+  const jsonCt = asObject(asObject(resp?.content)?.["application/json"]);
+  const schema = asObject(jsonCt?.schema);
+  if (!schema) return void 0;
+  const variants = schema.oneOf;
+  if (Array.isArray(variants)) {
+    for (const v of variants) {
+      const vm = asObject(v);
+      if (!vm) continue;
+      const errProp = asObject(asObject(vm.properties)?.error);
+      if (errProp && asString(errProp.const) === code) {
+        return extractDataProperty(vm);
+      }
+    }
+    return void 0;
+  }
+  return extractDataProperty(schema);
+}
+function extractDataProperty(schema) {
+  const dm = asObject(asObject(schema.properties)?.data);
+  if (!dm) return void 0;
+  return parseSchema(dm);
+}
+function requestSchema(op) {
+  const body = asObject(op.requestBody);
+  if (!body) return void 0;
+  return schemaFromContent(body.content);
+}
+function parametersSchemaIn(op, where) {
+  const paramsRaw = op.parameters;
+  if (!Array.isArray(paramsRaw) || paramsRaw.length === 0) return void 0;
+  const props = [];
+  for (const p of paramsRaw) {
+    const pm = asObject(p);
+    if (!pm) continue;
+    if (asString(pm.in) !== where) continue;
+    const name = asString(pm.name);
+    if (name === "") continue;
+    const required = pm.required === true;
+    const sm = asObject(pm.schema);
+    const ps = sm ? parseSchema(sm) : emptySchema("string");
+    props.push({ name, schema: ps, required });
+  }
+  if (props.length === 0) return void 0;
+  props.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  return { ...emptySchema("object"), props };
+}
+function pathParamNames(path) {
+  const out = [];
+  let rest = path;
+  for (; ; ) {
+    const open = rest.indexOf("{");
+    if (open < 0) break;
+    const close = rest.indexOf("}", open);
+    if (close < 0) break;
+    const name = rest.slice(open + 1, close);
+    if (name !== "") out.push(name);
+    rest = rest.slice(close + 1);
+  }
+  return out;
+}
+function responseSchema(op) {
+  const responses = asObject(op.responses);
+  if (!responses) return void 0;
+  const others = [];
+  for (const code of Object.keys(responses)) {
+    if (code.startsWith("2") && code !== "200" && code !== "201") others.push(code);
+  }
+  others.sort();
+  for (const code of ["200", "201", ...others]) {
+    const resp = asObject(responses[code]);
+    if (!resp) continue;
+    const s = schemaFromContent(resp.content);
+    if (s) return s;
+  }
+  return void 0;
+}
+function schemaFromContent(content) {
+  const jsonCt = asObject(asObject(content)?.["application/json"]);
+  const schema = asObject(jsonCt?.schema);
+  if (!schema) return void 0;
+  if ("$ref" in schema) return void 0;
+  return parseSchema(schema);
+}
+function emptySchema(kind) {
+  return { kind, nullable: false, props: [], enumVals: [] };
+}
+function parseSchema(s) {
+  let nullable = s.nullable === true;
+  const enumRaw = s.enum;
+  if (Array.isArray(enumRaw)) {
+    const cases = [];
+    let allStrings = true;
+    for (const v of enumRaw) {
+      if (typeof v === "string") {
+        cases.push(v);
+      } else {
+        allStrings = false;
+        break;
+      }
+    }
+    if (allStrings && cases.length > 0) {
+      return { ...emptySchema("enum"), nullable, enumVals: cases };
+    }
+  }
+  let typ = asString(s.type);
+  if (typ === "" && Array.isArray(s.type)) {
+    for (const v of s.type) {
+      if (typeof v !== "string") continue;
+      if (v === "null") {
+        nullable = true;
+      } else if (typ === "") {
+        typ = v;
+      }
+    }
+  }
+  switch (typ) {
+    case "string":
+    case "number":
+    case "integer":
+    case "boolean":
+      return { ...emptySchema(typ), nullable };
+    case "array": {
+      const items = asObject(s.items);
+      const elem = items ? parseSchema(items) : emptySchema("any");
+      return { ...emptySchema("array"), nullable, elem };
+    }
+    case "object":
+      return parseObject(s, nullable);
+    default:
+      if ("properties" in s) return parseObject(s, nullable);
+      return { ...emptySchema("any"), nullable };
+  }
+}
+function parseObject(s, nullable) {
+  const propsRaw = asObject(s.properties) ?? {};
+  const requiredSet = /* @__PURE__ */ new Set();
+  if (Array.isArray(s.required)) {
+    for (const r of s.required) {
+      if (typeof r === "string") requiredSet.add(r);
+    }
+  }
+  const names = Object.keys(propsRaw).sort();
+  const props = [];
+  for (const name of names) {
+    const pm = asObject(propsRaw[name]);
+    const ps = pm ? parseSchema(pm) : emptySchema("any");
+    props.push({ name, schema: ps, required: requiredSet.has(name) });
+  }
+  return { ...emptySchema("object"), nullable, props };
+}
+
+// src/gen/generate.ts
+var USAGE = `Usage: palbe-gen [--dir Palbase] [--out palbe.gen.ts] [--url <specOrigin>] [--soft] [--watch]
+
+Generate the typed palbe.gen.ts web client for the @palbase/web SDK.
+
+  --dir <dir>    Directory holding the committed openapi.json and required
+                 palbase-config.json written by \`palbase web link\`
+                 (default: Palbase)
+  --out <file>   Output file (default: palbe.gen.ts)
+  --url <origin> Fetch the spec from <origin>/openapi.json instead of --dir
+                 (local \`palbase serve\` dev flow, e.g. http://localhost:4003)
+  --soft         Never fail: print a warning and exit 0 on any error
+                 (for predev/prebuild hooks)
+  --watch        Poll the --url origin (default http://localhost:4003) every
+                 second and regenerate whenever the spec changes
+  -h, --help     Show this help`;
+function errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+var HttpStatusError = class extends Error {
+  status;
+  constructor(status, url) {
+    super(`GET ${url}: HTTP ${status}`);
+    this.status = status;
+  }
+};
+async function fetchSpec(url) {
+  let res;
+  try {
+    res = await fetch(url, { signal: AbortSignal.timeout(3e3) });
+  } catch (e) {
+    throw new Error(`GET ${url}: ${errMsg(e)}`);
+  }
+  if (!res.ok) throw new HttpStatusError(res.status, url);
+  return res.text();
+}
+function readWebConfig(dir) {
+  const path = join(dir, "palbase-config.json");
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    throw new Error(`${path} is required in dir mode \u2014 run \`palbase web link\``);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (e) {
+    throw new Error(`${path} is not valid JSON: ${errMsg(e)}`);
+  }
+  const obj = raw ?? {};
+  const str = (v) => typeof v === "string" ? v : "";
+  const required = (field) => {
+    const value = str(obj[field]);
+    if (value.trim() === "") {
+      throw new Error(`${path} is missing nonempty required field ${field}`);
+    }
+    return value;
+  };
+  const cfg = {
+    url: required("base_url"),
+    apiKey: required("api_key"),
+    appId: required("app_id"),
+    branch: str(obj.branch)
+  };
+  const oauthRaw = obj.oauth;
+  if (oauthRaw && typeof oauthRaw === "object") {
+    const oauth = {};
+    const apple = oauthRaw.apple;
+    if (apple && typeof apple === "object") {
+      oauth.apple = { enabled: apple.enabled === true };
+    }
+    const google = oauthRaw.google;
+    if (google && typeof google === "object") {
+      oauth.google = {
+        enabled: google.enabled === true,
+        clientId: str(google.client_id),
+        redirectUri: str(google.redirect_uri)
+      };
+    }
+    cfg.oauth = oauth;
+  }
+  return cfg;
+}
+function emitAndWrite(ops, cfg, outFile) {
+  const dir = dirname(outFile);
+  if (dir !== "." && dir !== "") {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(outFile, emitTypeScript(ops, cfg));
+}
+function existingNonEmpty(outFile) {
+  try {
+    return readFileSync(outFile).length > 0;
+  } catch {
+    return false;
+  }
+}
+function writeGenerated(ops, cfg, outFile, out) {
+  if (ops.length === 0) {
+    if (existingNonEmpty(outFile)) {
+      out(
+        `warning: live spec has 0 operations \u2014 keeping existing ${outFile} (fix your controllers and rerun)`
+      );
+      return;
+    }
+    out(
+      `warning: live spec has 0 operations \u2014 ${outFile} registers no calls (fix your controllers and rerun)`
+    );
+  }
+  emitAndWrite(ops, cfg, outFile);
+  out(`\u2713 wrote ${outFile} (${ops.length} operations)`);
+}
+async function generateOnce(dir, outFile, url, out) {
+  let specText;
+  let cfg;
+  if (url !== void 0) {
+    const origin = url.replace(/\/+$/, "");
+    specText = await fetchSpec(`${origin}/openapi.json`);
+    cfg = { url: origin, apiKey: "", appId: "", branch: "" };
+  } else {
+    cfg = readWebConfig(dir);
+    const specPath = join(dir, "openapi.json");
+    try {
+      specText = readFileSync(specPath, "utf8");
+    } catch {
+      throw new Error(
+        `no OpenAPI spec at ${specPath} \u2014 run \`palbase spec\` first, or pass --url for a local \`palbase serve\``
+      );
+    }
+  }
+  writeGenerated(parseOpenAPI(specText), cfg, outFile, out);
+}
+async function watchLoop(specURL, cfg, outFile, fetchFn, ticks, out) {
+  let lastEmittedHash = "";
+  let lastBadHash = "";
+  let lastDownMsg = "";
+  for await (const _ of ticks) {
+    let specText;
+    try {
+      specText = await fetchFn(specURL);
+    } catch (err) {
+      let m = "waiting for palbase serve on :4003\u2026";
+      if (err instanceof HttpStatusError) {
+        m = `local serve responded with an error (HTTP ${err.status}) \u2014 fix \`palbase serve\``;
+      }
+      if (m !== lastDownMsg) {
+        out(m);
+        lastDownMsg = m;
+      }
+      continue;
+    }
+    lastDownMsg = "";
+    const h = createHash("sha256").update(specText).digest("hex");
+    if (lastEmittedHash !== "" && h === lastEmittedHash) continue;
+    if (lastBadHash !== "" && h === lastBadHash) continue;
+    let ops;
+    try {
+      ops = parseOpenAPI(specText);
+    } catch (err) {
+      out(`warning: failed to parse spec: ${errMsg(err)}`);
+      lastBadHash = h;
+      continue;
+    }
+    if (ops.length === 0 && existingNonEmpty(outFile)) {
+      out(
+        `warning: live spec has 0 operations \u2014 keeping existing ${outFile} (fix your controllers and rerun)`
+      );
+      lastBadHash = h;
+      continue;
+    }
+    try {
+      emitAndWrite(ops, cfg, outFile);
+    } catch (err) {
+      out(`warning: codegen error: ${errMsg(err)}`);
+      continue;
+    }
+    lastEmittedHash = h;
+    lastBadHash = "";
+    out(`regenerated ${outFile} (${ops.length} operations)`);
+  }
+  out("watch stopped");
+}
+function delay(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(t);
+      resolve();
+    };
+    const t = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function* intervalTicks(ms, signal) {
+  while (!signal.aborted) {
+    await delay(ms, signal);
+    if (signal.aborted) return;
+    yield;
+  }
+}
+async function runWatch(outFile, url, out) {
+  const origin = (url ?? "http://localhost:4003").replace(/\/+$/, "");
+  const specURL = `${origin}/openapi.json`;
+  const cfg = { url: origin, apiKey: "", appId: "", branch: "" };
+  try {
+    writeGenerated(parseOpenAPI(await fetchSpec(specURL)), cfg, outFile, out);
+  } catch (err) {
+    out(`warning: codegen skipped (${errMsg(err)})`);
+  }
+  const ctrl = new AbortController();
+  const stop = () => ctrl.abort();
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  try {
+    await watchLoop(specURL, cfg, outFile, fetchSpec, intervalTicks(1e3, ctrl.signal), out);
+  } finally {
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGTERM", stop);
+  }
+}
+var stdoutWriter = (line) => {
+  process.stdout.write(`${line}
+`);
+};
+var stderrWriter = (line) => {
+  process.stderr.write(`${line}
+`);
+};
+function parseCliArgs(argv) {
+  return parseArgs({
+    args: argv,
+    options: {
+      dir: { type: "string", default: "Palbase" },
+      out: { type: "string", default: "palbe.gen.ts" },
+      url: { type: "string" },
+      soft: { type: "boolean", default: false },
+      watch: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  }).values;
+}
+async function main(argv, out = stdoutWriter, errOut = stderrWriter) {
+  let values;
+  try {
+    values = parseCliArgs(argv);
+  } catch (e) {
+    errOut(`error: ${errMsg(e)}`);
+    errOut(USAGE);
+    return 1;
+  }
+  if (values.help) {
+    out(USAGE);
+    return 0;
+  }
+  try {
+    if (values.watch) {
+      await runWatch(values.out, values.url, out);
+    } else {
+      await generateOnce(values.dir, values.out, values.url, out);
+    }
+    return 0;
+  } catch (err) {
+    if (values.soft) {
+      out(`warning: codegen skipped (${errMsg(err)})`);
+      return 0;
+    }
+    errOut(`error: ${errMsg(err)}`);
+    return 1;
+  }
+}
+
+// src/gen/cli.ts
+main(process2.argv.slice(2)).then(
+  (code) => process2.exit(code),
+  (err) => {
+    process2.stderr.write(`error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process2.exit(1);
+  }
+);
+//# sourceMappingURL=cli.js.map