@xano/sdk 1.0.5 → 1.0.7

package/dist/{chunk-TM5LRSBB.js → chunk-LBJA7IEM.js}

@@ -1,7 +1,285 @@
+import {
+  byCodeUnit
+} from "./chunk-WAVNUTMT.js";
 import {
   parsePathParams,
   pathSegment
-} from "./chunk-3IYVHVM6.js";
+} from "./chunk-VJFMUJWZ.js";
+import {
+  linkedTableOf,
+  tableRefOf
+} from "./chunk-EHP3WPEG.js";
+import {
+  COLUMN_NULLABLE_TYPES,
+  INPUT_NULLABLE_TYPES,
+  isListColumn
+} from "./chunk-JIKGT7DO.js";
+
+// src/emit/route-inputs.ts
+var SCALAR_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "int",
+  "decimal",
+  "bool",
+  "email",
+  "password",
+  "uuid",
+  "date",
+  "epochms",
+  "json",
+  "file",
+  "blob",
+  "blob_img",
+  "blob_video",
+  "blob_audio",
+  "geo_point",
+  "geo_multipoint",
+  "geo_linestring",
+  "geo_multilinestring",
+  "geo_polygon",
+  "geo_multipolygon"
+]);
+var INPUT_NULLABLE = new Set(INPUT_NULLABLE_TYPES);
+var COLUMN_NULLABLE = new Set(COLUMN_NULLABLE_TYPES);
+function isRow(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function rows(v) {
+  return Array.isArray(v) ? v.filter(isRow) : [];
+}
+function tableColumns(payload) {
+  const out = /* @__PURE__ */ new Map();
+  for (const table of rows(payload.dbo)) {
+    if (typeof table.guid === "string" && table.guid !== "" && Array.isArray(table.schema)) {
+      out.set(table.guid, table.schema);
+    }
+  }
+  return out;
+}
+function describeInputs(input, tables) {
+  return rows(input).map((row) => describeField(row, INPUT_NULLABLE, tables));
+}
+function bound(v) {
+  const n = typeof v === "number" ? Math.trunc(v) : typeof v === "string" ? Number.parseInt(v, 10) : Number.NaN;
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function listOf(row) {
+  if (!isListColumn({ style: isRow(row.style) ? row.style : void 0 })) return false;
+  const stored = isRow(row.list) ? row.list : {};
+  const min = bound(stored.min);
+  const max = bound(stored.max);
+  return { ...min !== void 0 ? { min } : {}, ...max !== void 0 ? { max } : {} };
+}
+function methodArg(v) {
+  return typeof v === "string" ? v : typeof v === "number" || typeof v === "boolean" ? String(v) : JSON.stringify(v);
+}
+function methodsOf(stored, honorDisabled = true) {
+  return rows(stored).flatMap((m) => {
+    if (typeof m.name !== "string" || m.name === "@") return [];
+    if (honorDisabled && m.disabled === true) return [];
+    return [{ name: m.name, args: Array.isArray(m.arg) ? m.arg.map(methodArg) : [] }];
+  });
+}
+function baseOf(row, type, nullableByDefault) {
+  return {
+    name: typeof row.name === "string" ? row.name : "",
+    required: row.required === true,
+    // The engine binds every `json` input nullable, whatever was stored.
+    nullable: type === "json" ? true : typeof row.nullable === "boolean" ? row.nullable : nullableByDefault.has(type),
+    list: listOf(row),
+    // The engine renders an enum, a vector and an object without their
+    // methods, so none of them applies one.
+    methods: type === "enum" || type === "vector" || type === "obj" ? [] : methodsOf(row.methods)
+  };
+}
+function describeField(row, nullableByDefault, tables) {
+  const type = typeof row.type === "string" ? row.type : "";
+  const field = row;
+  const linked = linkedTableOf(field);
+  if (linked !== null) return expandDbLink(row, linked, tables);
+  const base = baseOf(row, type, nullableByDefault);
+  const table = tableRefOf(field);
+  if (table !== null) return { ...base, type: "tableRef", keyType: type === "uuid" ? "uuid" : "int", table };
+  if (type === "enum") {
+    const values = Array.isArray(row.values) ? row.values : [];
+    return { ...base, type, values: values.map((v) => typeof v === "number" ? v : methodArg(v)) };
+  }
+  if (type === "vector") {
+    const size = isRow(row.vector) ? Number(row.vector.size) : Number.NaN;
+    return { ...base, type, size: Number.isFinite(size) ? size : 0 };
+  }
+  if (type === "obj") {
+    return { ...base, type, children: rows(row.children).map((child) => describeField(child, nullableByDefault, tables)) };
+  }
+  if (SCALAR_TYPES.has(type)) return { ...base, type };
+  return { ...base, type: "unknown", storedType: type };
+}
+function customizeMap(v) {
+  return isRow(v) ? v : {};
+}
+function expandDbLink(row, table, tables) {
+  const name = typeof row.name === "string" ? row.name : "";
+  const schema = tables.get(table);
+  if (schema === void 0) return { name, type: "dbLink", table, columns: void 0 };
+  const hidden = new Set(Array.isArray(row.hidden) ? row.hidden.filter((h) => typeof h === "string") : []);
+  const columns = rows(schema).filter((column) => column.name !== "id" && !hidden.has(String(column.name)));
+  return { name, type: "dbLink", table, columns: customizeColumns(columns, customizeMap(row.customize), tables) };
+}
+function customizeColumns(columns, customize, tables) {
+  return columns.flatMap((column) => {
+    const name = String(column.name);
+    const node = Object.hasOwn(customize, name) ? customize[name] : void 0;
+    if (node === void 0) {
+      if (column.access === "private" || column.access === "internal") return [];
+      return [describeField(column, COLUMN_NULLABLE, tables)];
+    }
+    const settings = isRow(node) ? node : {};
+    if (settings.hidden === true) return [];
+    const described = describeField(column, COLUMN_NULLABLE, tables);
+    const nested = customizeMap(settings.customize);
+    if (Object.keys(nested).length > 0) {
+      if (described.type !== "obj") return [described];
+      return [{ ...described, children: customizeColumns(rows(column.children), nested, tables) }];
+    }
+    if (described.type === "dbLink") return [described];
+    const methods = described.type === "obj" ? [] : methodsOf(settings.methods, false);
+    return [{ ...described, required: settings.required === true, methods }];
+  });
+}
+
+// src/emit/route-input-types.ts
+var NO_ROUTE_INPUTS = { routes: [], channels: [], messages: [] };
+var OBJECT_MEMBERS = /* @__PURE__ */ new Set([
+  "constructor",
+  "toString",
+  "toLocaleString",
+  "valueOf",
+  "hasOwnProperty",
+  "isPrototypeOf",
+  "propertyIsEnumerable"
+]);
+var FILE_REF = "{ path?: string; name?: string; type?: string; size?: number; access?: string; meta?: unknown; url?: string }";
+var FILE_UPLOAD = "{ readonly __fileUpload?: never }";
+var POSITION = "{ lng: number; lat: number }";
+var GEO = {
+  geo_point: `{ type: "point"; data: ${POSITION} }`,
+  geo_multipoint: `{ type: "points"; data: ${POSITION}[] }`,
+  geo_linestring: `{ type: "path"; data: ${POSITION}[] }`,
+  geo_multilinestring: `{ type: "paths"; data: ${POSITION}[][] }`,
+  geo_polygon: `{ type: "poly"; data: ${POSITION}[] }`,
+  geo_multipolygon: `{ type: "polys"; data: ${POSITION}[][] }`
+};
+var SCALAR = {
+  text: "string",
+  email: "string",
+  password: "string",
+  uuid: "string",
+  date: "string",
+  int: "number",
+  decimal: "number",
+  epochms: "number",
+  bool: "boolean",
+  json: "unknown",
+  file: FILE_UPLOAD,
+  blob: FILE_REF,
+  blob_img: FILE_REF,
+  blob_video: FILE_REF,
+  blob_audio: FILE_REF,
+  ...GEO
+};
+function propertyName(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function baseType(d, indent) {
+  switch (d.type) {
+    case "enum":
+      return d.values.length === 0 ? "never" : d.values.map((v) => typeof v === "number" ? String(v) : JSON.stringify(v)).join(" | ");
+    case "vector":
+      return "number[]";
+    case "tableRef":
+      return d.keyType === "uuid" ? "string" : "number";
+    case "obj":
+      return objectType(d.children, indent);
+    case "unknown":
+      return "unknown";
+    default:
+      return SCALAR[d.type] ?? "unknown";
+  }
+}
+function valueType(d, indent) {
+  let type = baseType(d, indent);
+  if (d.list !== false) type = d.type === "enum" ? `(${type})[]` : `${type}[]`;
+  if (d.nullable && type !== "unknown") type = `${type} | null`;
+  return type;
+}
+function objectType(inputs, indent) {
+  const keys = /* @__PURE__ */ new Map();
+  let open = false;
+  const inner = `${indent}  `;
+  const visit = (list) => {
+    for (const d of list) {
+      if (d.type === "dbLink") {
+        if (d.columns === void 0) open = true;
+        else visit(d.columns);
+        continue;
+      }
+      const type = valueType(d, inner);
+      const seen = keys.get(d.name);
+      if (seen === void 0) {
+        keys.set(d.name, { types: [type], required: d.required });
+      } else {
+        if (!seen.types.includes(type)) seen.types.push(type);
+        seen.required &&= d.required;
+      }
+    }
+  };
+  visit(inputs);
+  const rows2 = [...keys].map(([name, { types, required }]) => {
+    const widened = !required && OBJECT_MEMBERS.has(name) ? [...types, `Object[${JSON.stringify(name)}]`] : types;
+    return `${inner}${propertyName(name)}${required ? "" : "?"}: ${widened.join(" | ")};`;
+  });
+  if (open) rows2.push(`${inner}[column: string]: unknown;`);
+  return rows2.length === 0 ? "{}" : `{
+${rows2.join("\n")}
+${indent}}`;
+}
+function inputMap(name, doc, sets) {
+  const rows2 = sets.map((set) => `  ${JSON.stringify(set.key)}: ${objectType(set.inputs, "  ")};`);
+  return `${doc}
+export type ${name} = ${rows2.length === 0 ? "{}" : `{
+${rows2.join("\n")}
+}`};
+`;
+}
+function renderRouteInputTypes(inputs) {
+  return `
+${inputMap(
+    "RouteInputs",
+    `/**
+ * The request body/query inputs of every endpoint, keyed exactly like ROUTES.
+ * Path params are inputs too, so they appear here as well as in routePath().
+ * Matches InferInput<typeof def>, except that a database-link input appears as
+ * the linked table's columns, which is what the server accepts.
+ */`,
+    inputs.routes
+  )}
+${inputMap(
+    "ChannelInputs",
+    "/** The path params of every realtime channel, keyed exactly like CHANNELS. */",
+    inputs.channels
+  )}
+${inputMap(
+    "MessageInputs",
+    `/**
+ * The payload of every realtime message, keyed "<channel key> <message name>"
+ * (e.g. "rooms/{room_id} send").
+ */`,
+    inputs.messages
+  )}
+/** Every realtime message in this workspace, keyed "<channel key> <message name>". */
+export type MessageName = keyof MessageInputs;
+`;
+}
 
 // src/emit/routes-manifest.ts
 var RouteManifestError = class extends Error {
@@ -12,16 +290,36 @@ function routeKey(route) {
 function qualifiedRouteKey(route) {
   return `${route.group}:${routeKey(route)}`;
 }
+function keyRoutes(routes) {
+  const sorted = [...routes].sort(
+    (a, b) => a.canonical.localeCompare(b.canonical) || a.name.localeCompare(b.name) || a.verb.localeCompare(b.verb)
+  );
+  const holders = /* @__PURE__ */ new Map();
+  for (const route of sorted) holders.set(routeKey(route), (holders.get(routeKey(route)) ?? 0) + 1);
+  return sorted.map((route) => {
+    const short = routeKey(route);
+    const group = route.group ?? route.canonical;
+    return { route, key: holders.get(short) > 1 ? qualifiedRouteKey({ ...route, group }) : short, short, group };
+  });
+}
+function keyChannels(channels) {
+  const holders = /* @__PURE__ */ new Map();
+  for (const channel of channels) holders.set(channel.name, (holders.get(channel.name) ?? 0) + 1);
+  return [...channels].sort((a, b) => a.name.localeCompare(b.name) || a.server.localeCompare(b.server)).map((channel) => ({
+    channel,
+    key: holders.get(channel.name) > 1 ? `${channel.server}:${channel.name}` : channel.name
+  }));
+}
 function literal(value) {
   return JSON.stringify(value);
 }
-function objectLiteral(rows) {
-  return rows.length === 0 ? "{}" : `{
-${rows.join("\n")}
+function objectLiteral(rows2) {
+  return rows2.length === 0 ? "{}" : `{
+${rows2.join("\n")}
 }`;
 }
-function overloadsFor(fn, rows) {
-  return rows.map(
+function overloadsFor(fn, rows2) {
+  return rows2.map(
     (r) => r.params.length === 0 ? `export function ${fn}(name: ${literal(r.name)}): string;` : `export function ${fn}(name: ${literal(r.name)}, params: { ${r.params.map((p) => `${literal(p)}: string | number`).join("; ")} }): string;`
   ).join("\n");
 }
@@ -37,17 +335,14 @@ function renderRealtime(realtime) {
     }
     seenServer.add(server.name);
   }
-  const holders = /* @__PURE__ */ new Map();
-  for (const channel of realtime.channels) holders.set(channel.name, (holders.get(channel.name) ?? 0) + 1);
   const ambiguous = /* @__PURE__ */ new Map();
   const seenChannel = /* @__PURE__ */ new Set();
-  const channels = [...realtime.channels].sort((a, b) => a.name.localeCompare(b.name) || a.server.localeCompare(b.server)).map((channel) => {
+  const channels = keyChannels(realtime.channels).map(({ channel, key }) => {
     if (!known.has(channel.server)) {
       throw new RouteManifestError(
         `The channel "${channel.name}" names the realtime server "${channel.server}", which is not in this workspace. A channel's socket URL comes from its server's canonical, so the server must be registered too.`
       );
     }
-    const key = holders.get(channel.name) > 1 ? `${channel.server}:${channel.name}` : channel.name;
     if (seenChannel.has(key)) {
       throw new RouteManifestError(
         `The realtime server "${channel.server}" has two channels both named "${channel.name}". Rename one.`
@@ -91,18 +386,10 @@ export type ChannelName = keyof typeof CHANNELS;
 ${ambiguousOverloads}${overloadsFor("channelPath", channels.map((c) => ({ name: c.key, params: c.params })))}
 ${realtimeImplementation(ambiguousKeys.length > 0)}`;
 }
-function renderRouteManifest(routes, realtime) {
-  const sorted = [...routes].sort(
-    (a, b) => a.canonical.localeCompare(b.canonical) || a.name.localeCompare(b.name) || a.verb.localeCompare(b.verb)
-  );
-  const holders = /* @__PURE__ */ new Map();
-  for (const route of sorted) holders.set(routeKey(route), (holders.get(routeKey(route)) ?? 0) + 1);
+function renderRouteManifest(routes, realtime, inputs = NO_ROUTE_INPUTS) {
   const ambiguous = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Map();
-  const rows = sorted.map((route) => {
-    const short = routeKey(route);
-    const group = route.group ?? route.canonical;
-    const key = holders.get(short) > 1 ? qualifiedRouteKey({ ...route, group }) : short;
+  const rows2 = keyRoutes(routes).map(({ route, key, short, group }) => {
     const clash = seen.get(key);
     if (clash !== void 0) {
       throw new RouteManifestError(
@@ -115,7 +402,7 @@ function renderRouteManifest(routes, realtime) {
     const path = `/api:${route.canonical}/${route.name.replace(/^\/+/, "")}`;
     return { ...route, key, params, path };
   });
-  const entries = rows.map(
+  const entries = rows2.map(
     (r) => `  ${literal(r.key)}: { verb: ${literal(r.verb)}, path: ${literal(r.path)} },`
   );
   const ambiguousKeys = [...ambiguous.keys()].sort();
@@ -133,7 +420,7 @@ const AMBIGUOUS: Record<string, readonly string[]> = ${objectLiteral(
   )};
 `;
   const realtimeSection = realtime && (realtime.servers.length > 0 || realtime.channels.length > 0) ? renderRealtime(realtime) : "";
-  return `${HEADER}${FILL_PARAMS}${ambiguousSection}
+  return `${MANIFEST_HEADER}${FILL_PARAMS}${ambiguousSection}
 export const ROUTES = ${objectLiteral(entries)} as const;
 
 /**
@@ -141,10 +428,10 @@ export const ROUTES = ${objectLiteral(entries)} as const;
  * or \`"<group>:<VERB> <name>"\` when that pair is in more than one api group.
  */
 export type RouteName = keyof typeof ROUTES;
-${rows.length > 1 ? MANY_ROUTES : ""}
-${rows.length > 1 ? UNION_OVERLOAD : ""}${ambiguousOverloads ? `${ambiguousOverloads}
-` : ""}${overloadsFor("routePath", rows.map((r) => ({ name: r.key, params: r.params })))}
-${implementation(ambiguousKeys.length > 0)}${realtimeSection}`;
+${rows2.length > 1 ? MANY_ROUTES : ""}
+${rows2.length > 1 ? UNION_OVERLOAD : ""}${ambiguousOverloads ? `${ambiguousOverloads}
+` : ""}${overloadsFor("routePath", rows2.map((r) => ({ name: r.key, params: r.params })))}
+${implementation(ambiguousKeys.length > 0)}${realtimeSection}${renderRouteInputTypes(inputs)}`;
 }
 var UNION_OVERLOAD = `/** A union of route names (e.g. a \`key: RouteName\` parameter): params checked at runtime. */
 export function routePath<N extends RouteName>(name: ManyRoutes<N>, params?: Record<string, string | number>): string;
@@ -153,13 +440,16 @@ var MANY_ROUTES = `
 /** \`N\` when it is a union of two or more route names, else \`never\`. */
 type ManyRoutes<N> = [(N extends unknown ? (x: N) => void : never) extends (x: infer I) => void ? I : never] extends [never] ? N : never;
 `;
-var HEADER = `/**
+var MANIFEST_HEADER = `/**
  * GENERATED by \`xanosdk routes --emit\`. Do not edit.
  *
- * Plain data plus one interpolator \u2014 this file imports nothing, so a frontend
- * gets the typed path/verb (and socket) contract without pulling the SDK runtime
- * into its bundle. Regenerate after changing an endpoint's name, verb, or api
- * group, or a realtime server's or channel's name.
+ * Plain data plus one interpolator, and the request input types of every
+ * endpoint, channel and message. The core sections import nothing; the only
+ * imports are the packages an installed module's block declares, never the
+ * SDK itself. So a frontend gets the typed path/verb (and socket) contract
+ * without pulling the SDK runtime into its bundle. Regenerate after changing an
+ * endpoint's name, verb, api group or inputs, or a realtime server's, channel's
+ * or message's name or inputs.
  */
 `;
 var FILL_PARAMS = `
@@ -376,12 +666,13 @@ function planRouteManifest(payload, locked = () => void 0) {
     if (guid === void 0) continue;
     const name = text(a.name);
     if (name !== void 0) groupByGuid.set(guid, name);
-    const resolved = text(a.canonical) ?? (name !== void 0 ? locked("app", name) : void 0);
-    if (resolved) canonicalByGuid.set(guid, resolved);
+    const resolved2 = text(a.canonical) ?? (name !== void 0 ? locked("app", name) : void 0);
+    if (resolved2) canonicalByGuid.set(guid, resolved2);
   }
-  const rows = list("query").map((q) => {
+  const storedInputs = /* @__PURE__ */ new Map();
+  const rows2 = list("query").map((q) => {
     const group = ref(q.app);
-    return {
+    const row = {
       verb: q.verb,
       // already an uppercase HttpVerb in the bundle
       // Match getPath(): the path segment drops any leading slash on the name.
@@ -389,8 +680,10 @@ function planRouteManifest(payload, locked = () => void 0) {
       canonical: group !== void 0 ? canonicalByGuid.get(group) : void 0,
       ...group !== void 0 && groupByGuid.has(group) ? { group: groupByGuid.get(group) } : {}
     };
+    storedInputs.set(row, q.input);
+    return row;
   });
-  rows.sort((a, b) => (a.canonical ?? "").localeCompare(b.canonical ?? "") || a.name.localeCompare(b.name));
+  rows2.sort((a, b) => (a.canonical ?? "").localeCompare(b.canonical ?? "") || a.name.localeCompare(b.name));
   const serverNameByGuid = /* @__PURE__ */ new Map();
   const serverRows = list("realtime_server").flatMap((s) => {
     const name = text(s.name);
@@ -401,23 +694,51 @@ function planRouteManifest(payload, locked = () => void 0) {
   });
   const servers = serverRows.flatMap((s) => s.canonical ? [{ name: s.name, canonical: s.canonical }] : []);
   const describable = new Set(servers.map((s) => s.name));
+  const channelGuids = /* @__PURE__ */ new Map();
   const channels = list("channel").flatMap((c) => {
     const name = text(c.name);
     if (name === void 0) return [];
     const serverGuid = ref(c.server);
     const server = serverGuid !== void 0 ? serverNameByGuid.get(serverGuid) : void 0;
     if (server === void 0 || !describable.has(server)) return [];
-    return [{ name, server }];
+    const channel = { name, server };
+    channelGuids.set(channel, text(c.guid));
+    storedInputs.set(channel, c.input);
+    return [channel];
+  });
+  const resolved = rows2.flatMap((r) => {
+    if (!r.canonical) return [];
+    const entry = { name: r.name, verb: r.verb, canonical: r.canonical, ...r.group !== void 0 ? { group: r.group } : {} };
+    storedInputs.set(entry, storedInputs.get(r));
+    return [entry];
+  });
+  const tables = tableColumns(payload);
+  const routeInputs = keyRoutes(resolved).map(({ route, key }) => ({
+    key,
+    inputs: describeInputs(storedInputs.get(route), tables)
+  }));
+  const channelKeyByGuid = /* @__PURE__ */ new Map();
+  const channelInputs = keyChannels(channels).map(({ channel, key }) => {
+    const guid = channelGuids.get(channel);
+    if (guid !== void 0) channelKeyByGuid.set(guid, key);
+    return { key, inputs: describeInputs(storedInputs.get(channel), tables) };
+  });
+  const messageInputs = list("message").flatMap((m) => {
+    const name = text(m.name);
+    const guid = ref(m.channel);
+    const channel = guid !== void 0 ? channelKeyByGuid.get(guid) : void 0;
+    if (name === void 0 || channel === void 0) return [];
+    return [{ key: `${channel} ${name}`, channel, name, inputs: describeInputs(m.input, tables) }];
   });
+  messageInputs.sort((a, b) => byCodeUnit(a.key, b.key));
   return {
-    rows,
-    resolved: rows.flatMap(
-      (r) => r.canonical ? [{ name: r.name, verb: r.verb, canonical: r.canonical, ...r.group !== void 0 ? { group: r.group } : {} }] : []
-    ),
-    unresolved: rows.filter((r) => !r.canonical),
+    rows: rows2,
+    resolved,
+    unresolved: rows2.filter((r) => !r.canonical),
     servers,
     unresolvedServers: serverRows.filter((s) => !s.canonical).map((s) => s.name),
-    channels
+    channels,
+    inputs: { routes: routeInputs, channels: channelInputs, messages: messageInputs }
   };
 }
 function unresolvedCanonicalMessage(unresolved, entry) {
@@ -430,7 +751,8 @@ function renderPlannedManifest(plan, entry = "<entry>") {
   if (plan.resolved.length === 0 && plan.servers.length === 0) return void 0;
   return renderRouteManifest(
     plan.resolved,
-    plan.servers.length > 0 ? { servers: plan.servers, channels: plan.channels } : void 0
+    plan.servers.length > 0 ? { servers: plan.servers, channels: plan.channels } : void 0,
+    plan.inputs
   );
 }
 
@@ -438,10 +760,13 @@ export {
   RouteManifestError,
   routeKey,
   qualifiedRouteKey,
+  keyRoutes,
+  keyChannels,
   renderRouteManifest,
+  MANIFEST_HEADER,
   ROUTES_MANIFEST_BASENAME,
   planRouteManifest,
   unresolvedCanonicalMessage,
   renderPlannedManifest
 };
-//# sourceMappingURL=chunk-TM5LRSBB.js.map
+//# sourceMappingURL=chunk-LBJA7IEM.js.map

package/dist/chunk-LCOCRJ4K.js

@@ -0,0 +1,116 @@
+// src/deploy/local-engine-handshake.ts
+var LOOPBACK_HOSTS = ["127.0.0.1", "::1", "localhost"];
+var ALLOWED_PROTOCOLS = ["http:", "https:"];
+function isLoopbackUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (!ALLOWED_PROTOCOLS.includes(parsed.protocol)) return false;
+  const host = parsed.hostname.replace(/^\[|\]$/g, "");
+  if (!LOOPBACK_HOSTS.includes(host)) return false;
+  return /^[0-9]+$/.test(parsed.port);
+}
+function assertLoopbackUrl(url, what) {
+  if (isLoopbackUrl(url)) return;
+  throw new Error(
+    `${what} reports a url this SDK will not send a token to: ${url}
+A Xano Engine has to serve loopback over http on a port of its own \u2014 ${LOOPBACK_HOSTS.join(", ")} \u2014 and anything else is reachable from off this machine. Stop that engine and start a fresh one without binding it to all interfaces.`
+  );
+}
+function requireString(raw, key, source) {
+  const value = raw[key];
+  if (typeof value !== "string" || value === "") {
+    throw new Error(
+      `${source} is missing \`${key}\`, or gave it as something other than text.
+That is not an engine this SDK knows how to drive \u2014 the engine on this machine is older or newer than the one it was built against. Move to a current one with \`xanosdk local update\`.`
+    );
+  }
+  return value;
+}
+function optionalString(raw, key, source) {
+  return raw[key] === void 0 ? void 0 : requireString(raw, key, source);
+}
+function requireNumber(raw, key, source) {
+  const value = raw[key];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(
+      `${source} is missing \`${key}\`, or gave it as something other than a number.
+That is not an engine this SDK knows how to drive \u2014 the engine on this machine is older or newer than the one it was built against. Move to a current one with \`xanosdk local update\`.`
+    );
+  }
+  return value;
+}
+function readEngine(value, source) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(
+      `${source} did not print an engine description.
+Re-run, and if it happens again fetch a fresh copy with \`xanosdk local cache clear\`, then \`xanosdk deploy --local\`.`
+    );
+  }
+  const raw = value;
+  const mcpUrl = optionalString(raw, "mcp_url", source);
+  return {
+    name: requireString(raw, "name", source),
+    url: requireString(raw, "url", source),
+    workspaceId: requireNumber(raw, "workspace_id", source),
+    token: requireString(raw, "access_token", source),
+    pid: requireNumber(raw, "pid", source),
+    signInUrl: requireString(raw, "sign_in_url", source),
+    loginLinkEndpoint: requireString(raw, "login_link_endpoint", source),
+    logPath: requireString(raw, "log", source),
+    ...mcpUrl === void 0 ? {} : { mcpUrl }
+  };
+}
+var HANDSHAKE_SOURCE = "The engine's start handshake";
+var LISTING_SOURCE = "The engine's list of running engines";
+function parseEngineHandshake(stdout) {
+  let value;
+  try {
+    value = JSON.parse(stdout.trim());
+  } catch {
+    throw new Error(
+      `${HANDSHAKE_SOURCE} did not print an engine description.
+Re-run, and if it happens again fetch a fresh copy with \`xanosdk local cache clear\`, then \`xanosdk deploy --local\`.`
+    );
+  }
+  const engine = readEngine(value, HANDSHAKE_SOURCE);
+  assertLoopbackUrl(engine.url, "The engine that just started");
+  return engine;
+}
+function parseEngineListing(stdout) {
+  const text = stdout.trim();
+  if (text === "") return [];
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new Error(
+      `${LISTING_SOURCE} was not readable.
+Re-run, and if it happens again fetch a fresh copy with \`xanosdk local cache clear\`, then \`xanosdk deploy --local\`.`
+    );
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(
+      `${LISTING_SOURCE} was not a list.
+Re-run, and if it happens again fetch a fresh copy with \`xanosdk local cache clear\`, then \`xanosdk deploy --local\`.`
+    );
+  }
+  return value.filter((entry) => !isForeignEngine(entry)).map((entry) => readEngine(entry, LISTING_SOURCE));
+}
+function isForeignEngine(entry) {
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return false;
+  const raw = entry;
+  return raw.workspace_id === void 0 && raw.access_token === void 0;
+}
+
+export {
+  LOOPBACK_HOSTS,
+  isLoopbackUrl,
+  assertLoopbackUrl,
+  parseEngineHandshake,
+  parseEngineListing
+};
+//# sourceMappingURL=chunk-LCOCRJ4K.js.map