@xano/sdk 1.0.0

package/dist/chunk-45UIT5T2.js

@@ -0,0 +1,862 @@
+import {
+  identityName,
+  isWorkspaceKeyAtDefault
+} from "./chunk-HRVBLCVJ.js";
+import {
+  DEFAULT_PREFERENCES,
+  DEFAULT_SETTINGS
+} from "./chunk-2CMJZDCL.js";
+import {
+  HOSTED_ICON_KINDS,
+  isPrivateLibraryRow
+} from "./chunk-XNCP4KYO.js";
+import {
+  deepEqual,
+  normalize
+} from "./chunk-L5JYN3NM.js";
+
+// src/deploy/live-diff.ts
+function storedColumnsAfter(outgoing, live, prior, mode) {
+  const liveTables = new Map(rows(live, "dbo").map((t) => [identify(t), t]));
+  const out = /* @__PURE__ */ new Map();
+  for (const table of rows(outgoing, "dbo")) {
+    if (typeof table.guid !== "string" || table.guid === "") continue;
+    const current = mode === "rebuild" ? void 0 : liveTables.get(identify(table));
+    const liveColumns = current === void 0 ? /* @__PURE__ */ new Map() : typedColumnsOf(current);
+    const blind = mode === "merge" && live === void 0;
+    const known = prior.get(table.guid) ?? {};
+    const stored = {};
+    for (const [column, type] of typedColumnsOf(table)) {
+      if (type === "") continue;
+      if (!blind && !liveColumns.has(column)) stored[column] = type;
+      else if (known[column] !== void 0) stored[column] = known[column];
+    }
+    if (Object.keys(stored).length > 0) out.set(table.guid, stored);
+  }
+  return out;
+}
+function usesXdo(table) {
+  if (typeof table.use_xdo === "boolean") return table.use_xdo;
+  return Array.isArray(table.index) && table.index.some((entry) => {
+    const { type, fields } = entry ?? {};
+    return type === "gin" && Array.isArray(fields) && fields.some((f) => f?.name === "xdo");
+  });
+}
+function indexesOf(table) {
+  const out = /* @__PURE__ */ new Map();
+  if (!Array.isArray(table.index)) return out;
+  for (const entry of table.index) {
+    if (entry === null || typeof entry !== "object") continue;
+    const { type, fields } = entry;
+    if (typeof type !== "string" || type === "primary" || !Array.isArray(fields)) continue;
+    const parts = type.split("|");
+    const unique = parts.includes("unique");
+    const kind = unique ? "unique" : parts[0] ?? type;
+    const cols = fields.map((f) => {
+      const { name, op } = f ?? {};
+      return typeof name !== "string" ? "" : typeof op === "string" && op !== "" ? `${name} ${op}` : name;
+    }).filter((c) => c !== "");
+    out.set(`${kind}(${cols.join(", ")})`, unique);
+  }
+  return out;
+}
+function uniqueIndexLabels(table) {
+  return [...indexesOf(table)].filter(([, unique]) => unique).map(([label]) => label);
+}
+function indexKeysOf(table) {
+  const asc = { ...table, index: Array.isArray(table.index) ? table.index.map(withoutAsc) : table.index };
+  return [...indexesOf(asc).keys()].sort();
+}
+function withoutAsc(entry) {
+  if (entry === null || typeof entry !== "object" || !Array.isArray(entry.fields)) return entry;
+  const fields = entry.fields.map(
+    (f) => f !== null && typeof f === "object" && f.op === "asc" ? { ...f, op: "" } : f
+  );
+  return { ...entry, fields };
+}
+function rows(bundle, key) {
+  const payload = bundle?.payload;
+  if (payload === null || typeof payload !== "object") return [];
+  const value = payload[key];
+  return Array.isArray(value) ? value.filter((r) => r !== null && typeof r === "object") : [];
+}
+function typedColumnsOf(table) {
+  const out = columnsOf(table, "type", (v) => typeof v === "string" ? v : "");
+  for (const [column, size] of columnsOf(table, "vector", (v) => v?.size)) {
+    if (out.get(column) === "vector") out.set(column, sizedVector(size));
+  }
+  return out;
+}
+function sizedVector(size) {
+  return `vector(${typeof size === "number" && Number.isInteger(size) ? size : 3})`;
+}
+function vectorSize(type) {
+  const m = /^vector\((\d+)\)$/.exec(type);
+  return m === null ? void 0 : Number(m[1]);
+}
+function enumColumnsOf(table) {
+  return columnsOf(table, "values", (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : void 0);
+}
+function refColumnsOf(table) {
+  return columnsOf(table, "methods", (v) => {
+    if (!Array.isArray(v)) return void 0;
+    for (const m of v) {
+      if (m?.name !== "@" || !Array.isArray(m.arg)) continue;
+      const ref = m.arg.find((a) => typeof a === "string" && a.startsWith("dbo="));
+      if (ref !== void 0) return ref.slice("dbo=".length);
+    }
+    return void 0;
+  });
+}
+function nullableColumnsOf(table) {
+  return columnsOf(table, "nullable", (v) => typeof v === "boolean" ? v : void 0);
+}
+function columnsOf(table, key, read) {
+  const out = /* @__PURE__ */ new Map();
+  const schema = table.schema;
+  if (!Array.isArray(schema)) return out;
+  for (const entry of schema) {
+    if (entry === null || typeof entry !== "object") continue;
+    const { name } = entry;
+    if (typeof name !== "string" || name === "") continue;
+    out.set(name, read(entry[key]));
+  }
+  return out;
+}
+function identify(table) {
+  const guid = table.guid;
+  if (typeof guid === "string" && guid !== "") return `guid:${guid}`;
+  const name = table.name;
+  return typeof name === "string" ? `name:${name}` : "";
+}
+function envValuesOf(bundle) {
+  const payload = bundle?.payload;
+  const out = /* @__PURE__ */ new Map();
+  if (payload === null || typeof payload !== "object") return out;
+  const workspace = payload.workspace;
+  const candidates = [
+    payload.env,
+    workspace !== null && typeof workspace === "object" && !Array.isArray(workspace) ? workspace.env : void 0,
+    Array.isArray(workspace) && workspace[0] !== null && typeof workspace[0] === "object" ? workspace[0].env : void 0
+  ];
+  for (const candidate of candidates) {
+    if (!Array.isArray(candidate)) continue;
+    for (const entry of candidate) {
+      if (typeof entry === "string") {
+        const at = entry.indexOf("=");
+        if (at > 0) out.set(entry.slice(0, at), entry.slice(at + 1));
+        continue;
+      }
+      if (entry === null || typeof entry !== "object") continue;
+      const { name, value } = entry;
+      if (typeof name === "string" && name !== "") out.set(name, typeof value === "string" ? value : "");
+    }
+  }
+  return out;
+}
+function diffAgainstLive(outgoing, live, opts) {
+  const outgoingTables = new Map(rows(outgoing, "dbo").map((t) => [identify(t), t]));
+  const guidlessNames = new Set(
+    rows(outgoing, "dbo").filter((t) => typeof t.guid !== "string" || t.guid === "").map(nameOf)
+  );
+  const outgoingNames = new Set(rows(outgoing, "dbo").map(nameOf));
+  const uncarriedTables = [];
+  const replacedTables = [];
+  const droppedColumns = [];
+  const retypedColumns = [];
+  const unrelaxedColumns = [];
+  const tightenedColumns = [];
+  const indexChanges = [];
+  const narrowedEnums = [];
+  const retargetedRefs = [];
+  const storageChanges = [];
+  const tableNames = /* @__PURE__ */ new Map();
+  for (const t of [...rows(live, "dbo"), ...rows(outgoing, "dbo")]) {
+    if (typeof t.guid === "string" && typeof t.name === "string") tableNames.set(t.guid, t.name);
+  }
+  for (const liveTable of rows(live, "dbo")) {
+    const outgoingTable = outgoingTables.get(identify(liveTable));
+    if (outgoingTable === void 0) {
+      const liveName = nameOf(liveTable);
+      const ownIdentity = typeof liveTable.guid === "string" && liveTable.guid !== "";
+      if (!outgoingNames.has(liveName) || ownIdentity && !guidlessNames.has(liveName)) {
+        uncarriedTables.push(liveName);
+        if (outgoingNames.has(liveName)) replacedTables.push(liveName);
+      }
+      continue;
+    }
+    const kept = typedColumnsOf(outgoingTable);
+    const defaults = columnsOf(outgoingTable, "default", (v) => typeof v === "string" ? v : "");
+    const nullable = columnsOf(outgoingTable, "nullable", (v) => v === true);
+    const name = typeof outgoingTable.name === "string" ? outgoingTable.name : typeof liveTable.name === "string" ? liveTable.name : "(unnamed)";
+    const storedHere = typeof liveTable.guid === "string" ? opts.stored?.get(liveTable.guid) : void 0;
+    for (const [column, type] of typedColumnsOf(liveTable)) {
+      const next = kept.get(column);
+      if (next === void 0) droppedColumns.push({ table: name, column });
+      else if (next !== type) {
+        const declared = defaults.get(column) ?? "";
+        const recorded = storedHere?.[column];
+        const stored = recorded === "vector" ? void 0 : recorded;
+        retypedColumns.push({
+          table: name,
+          column,
+          from: type,
+          to: next,
+          ...declared === "" ? {} : { default: declared },
+          ...nullable.get(column) === true ? { nullable: true } : {},
+          ...stored === void 0 ? {} : { stored },
+          ...usesXdo(liveTable) && usesXdo(outgoingTable) ? { useXdo: true } : {}
+        });
+      }
+    }
+    if (opts.mode !== "merge") continue;
+    const [from2, to2] = [usesXdo(liveTable), usesXdo(outgoingTable)];
+    if (from2 !== to2) {
+      storageChanges.push({
+        table: name,
+        liveName: nameOf(liveTable),
+        ...typeof liveTable.guid === "string" && liveTable.guid !== "" ? { guid: liveTable.guid } : {},
+        from: from2,
+        to: to2
+      });
+    }
+    const liveIndexes = indexesOf(liveTable);
+    const nextIndexes = indexesOf(outgoingTable);
+    for (const [index, unique] of nextIndexes) {
+      if (!liveIndexes.has(index)) indexChanges.push({ table: name, index, action: "add", unique });
+    }
+    for (const [index, unique] of liveIndexes) {
+      if (!nextIndexes.has(index)) indexChanges.push({ table: name, index, action: "drop", unique });
+    }
+    const types = typedColumnsOf(liveTable);
+    const nextEnums = enumColumnsOf(outgoingTable);
+    for (const [column, values] of enumColumnsOf(liveTable)) {
+      if (types.get(column) !== "enum" || kept.get(column) !== "enum" || values === void 0) continue;
+      const next = nextEnums.get(column) ?? [];
+      const removed = values.filter((v) => !next.includes(v));
+      if (removed.length > 0) narrowedEnums.push({ table: name, column, removed });
+    }
+    const nextRefs = refColumnsOf(outgoingTable);
+    for (const [column, ref] of refColumnsOf(liveTable)) {
+      const next = nextRefs.get(column);
+      if (ref === void 0 || next === void 0 || next === ref || types.get(column) !== kept.get(column)) continue;
+      retargetedRefs.push({ table: name, column, from: tableNames.get(ref) ?? ref, to: tableNames.get(next) ?? next });
+    }
+    const nextNullable = nullableColumnsOf(outgoingTable);
+    for (const [column, nullable2] of nullableColumnsOf(liveTable)) {
+      if (nullable2 === false && nextNullable.get(column) === true) unrelaxedColumns.push({ table: name, column });
+      if (nullable2 === true && nextNullable.get(column) === false) {
+        tightenedColumns.push({ table: name, column, type: kept.get(column) ?? "" });
+      }
+    }
+  }
+  const unchangedEnv = [];
+  const droppedEnv = [];
+  const liveEnv = envValuesOf(live);
+  if (opts.mode === "merge") {
+    for (const [name, value] of envValuesOf(outgoing)) {
+      const current = liveEnv.get(name);
+      if (current !== void 0 && current !== value) unchangedEnv.push({ name, empty: value === "" });
+    }
+  } else {
+    const declared = envValuesOf(outgoing);
+    for (const name of liveEnv.keys()) {
+      if (!declared.has(name)) droppedEnv.push({ name });
+    }
+  }
+  const unappliedDocumentation = [];
+  if (opts.mode === "merge") {
+    const ours = documentationOf(outgoing);
+    const theirs = documentationOf(live);
+    if (ours !== void 0) {
+      if (Object.hasOwn(ours, "require_token") && !deepEqual(ours.require_token, theirs?.require_token)) {
+        unappliedDocumentation.push("require_token");
+      }
+      const gated = ours.require_token === true || theirs?.require_token === true;
+      if (gated && typeof ours.token === "string" && ours.token !== "" && ours.token !== theirs?.token) {
+        unappliedDocumentation.push("token");
+      }
+    }
+  }
+  const from = workspaceNameOf(live);
+  const to = workspaceNameOf(outgoing);
+  const workspaceRename = from !== "" && to !== "" && from !== to ? { from, to } : void 0;
+  return {
+    uncarriedTables,
+    replacedTables,
+    droppedColumns,
+    retypedColumns,
+    unrelaxedColumns,
+    tightenedColumns,
+    indexChanges,
+    narrowedEnums,
+    retargetedRefs,
+    storageChanges,
+    unchangedEnv,
+    droppedEnv,
+    unappliedDocumentation,
+    ...workspaceRename !== void 0 ? { workspaceRename } : {}
+  };
+}
+function secretsCarriedBy(bundle) {
+  const out = [];
+  if ([...envValuesOf(bundle).values()].some((v) => v !== "")) out.push("env values");
+  const set = (block) => {
+    const token = block?.token;
+    return typeof token === "string" && token !== "";
+  };
+  const groups = payloadOf(bundle).app;
+  const groupTokens = Array.isArray(groups) ? groups.some((g) => set(g?.documentation)) : false;
+  if (set(documentationOf(bundle)) || groupTokens) out.push("documentation token");
+  const payload = payloadOf(bundle);
+  const workspace = asRecord(payload.workspace);
+  if (workspace !== void 0) {
+    const crypto = asRecord(workspace.crypto);
+    if (filled(workspace.secret) || filled(crypto?.secret)) out.push("workspace secrets");
+    const repo = asRecord(workspace["git"]);
+    if (filled(repo?.private_key)) out.push("a repository private key");
+    const providers = asRecord(asRecord(asRecord(workspace.settings)?.ai_settings)?.providers);
+    if (providers !== void 0 && Object.values(providers).some((p) => filled(asRecord(p)?.api_key))) {
+      out.push("AI provider API keys");
+    }
+  }
+  if (Array.isArray(payload.vault) && payload.vault.some(isPrivateLibraryRow)) {
+    out.push("vault entries");
+  }
+  return out;
+}
+function filled(value) {
+  return typeof value === "string" && value !== "";
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function secretsInMultidoc(text) {
+  const out = [];
+  const nonEmptyString = /"(?:[^"\\]|\\.)+"/;
+  if (assignedBlocks(text, "env").some((b) => nonEmptyString.test(b))) out.push("env values");
+  if (assignedBlocks(text, "swagger").some((b) => /\btoken\s*:\s*"(?:[^"\\]|\\.)+"/.test(b))) {
+    out.push("documentation token");
+  }
+  if (passwordHashesInMultidoc(text).length > 0) out.push("password hashes");
+  return out;
+}
+function passwordHashesInMultidoc(text) {
+  const out = [];
+  for (const doc of text.split(/^(?=table[ \t]+)/m)) {
+    const name = /^table[ \t]+("?)([^\s"{]+)\1/.exec(doc)?.[2];
+    if (name === void 0) continue;
+    const columns = [...doc.matchAll(/^[ \t]*password\??[ \t]+("?)([A-Za-z_]\w*)\1/gm)].map((m) => m[2]);
+    if (columns.length === 0) continue;
+    const items = assignedBlocks(doc, "items", "[").join("\n");
+    for (const column of columns) {
+      if (new RegExp(`(?:^|[{,\\s])"?${column}"?\\s*:\\s*"(?:[^"\\\\]|\\\\.)+"`).test(items)) out.push(`${name}.${column}`);
+    }
+  }
+  return out;
+}
+function assignedBlocks(text, key, open = "{") {
+  const out = [];
+  const close = open === "{" ? "}" : "]";
+  const start = new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*\\${open}`, "gm");
+  for (let m = start.exec(text); m !== null; m = start.exec(text)) {
+    let depth = 1;
+    let i = m.index + m[0].length;
+    const from = i;
+    for (; i < text.length && depth > 0; i++) {
+      const ch = text[i];
+      if (ch === '"') {
+        for (i++; i < text.length && text[i] !== '"'; i++) if (text[i] === "\\") i++;
+      } else if (ch === open) depth++;
+      else if (ch === close) depth--;
+    }
+    out.push(text.slice(from, i - 1));
+  }
+  return out;
+}
+function documentationOf(bundle) {
+  const ws = payloadOf(bundle)[WORKSPACE_KEY];
+  if (ws === null || typeof ws !== "object" || Array.isArray(ws)) return void 0;
+  const block = ws.documentation;
+  return block !== null && typeof block === "object" && !Array.isArray(block) ? block : void 0;
+}
+function workspaceNameOf(bundle) {
+  const ws = payloadOf(bundle)[WORKSPACE_KEY];
+  if (ws === null || typeof ws !== "object" || Array.isArray(ws)) return "";
+  const name = ws.name;
+  return typeof name === "string" ? name : "";
+}
+function sharedSchemaChanges(outgoing, live, opts = {}) {
+  if (live === void 0) return void 0;
+  const changes = [];
+  for (const kind of ["dbo", "microservice"]) {
+    const liveRows = new Map(rows(live, kind).map((r) => [identify(r), r]));
+    const outgoingRows = new Map(rows(outgoing, kind).map((r) => [identify(r), r]));
+    for (const [key, out] of outgoingRows) {
+      const current = liveRows.get(key);
+      const name = nameOf(out);
+      if (current === void 0) {
+        changes.push({ kind, name, action: "create" });
+        continue;
+      }
+      const details = kind === "dbo" ? tableDelta(current, out) : objectDelta(current, out);
+      if (details.length > 0) changes.push({ kind, name, action: "alter", details });
+    }
+    if (opts.prune === true) {
+      for (const [key, current] of liveRows) {
+        if (!outgoingRows.has(key)) changes.push({ kind, name: nameOf(current), action: "remove" });
+      }
+    }
+  }
+  return changes;
+}
+function tableDelta(live, outgoing) {
+  const details = [];
+  const before = typedColumnsOf(live);
+  const after = typedColumnsOf(outgoing);
+  const liveName = nameOf(live);
+  const outgoingName = nameOf(outgoing);
+  if (liveName !== outgoingName) details.push(`renamed from "${liveName}" to "${outgoingName}"`);
+  for (const [column, type] of after) {
+    const current = before.get(column);
+    if (current === void 0) {
+      details.push(`add column "${column}"`);
+    } else if (current !== type) {
+      details.push(`retype column "${column}" (${current} \u2192 ${type})`);
+    }
+  }
+  for (const column of before.keys()) {
+    if (!after.has(column)) details.push(`drop column "${column}"`);
+  }
+  const liveIndexes = indexKeysOf(live);
+  const nextIndexes = indexKeysOf(outgoing);
+  for (const index of nextIndexes) if (!liveIndexes.includes(index)) details.push(`add index ${index}`);
+  for (const index of liveIndexes) if (!nextIndexes.includes(index)) details.push(`drop index ${index}`);
+  return details;
+}
+function tableAdditions(outgoing, live) {
+  const liveTables = new Map(rows(live, "dbo").map((t) => [identify(t), t]));
+  const createdTables = [];
+  const addedColumns = [];
+  const renamedTables = [];
+  const addedDefaults = {};
+  for (const table of rows(outgoing, "dbo")) {
+    const current = liveTables.get(identify(table));
+    const name = nameOf(table);
+    if (current === void 0) {
+      createdTables.push(name);
+      continue;
+    }
+    if (nameOf(current) !== name) renamedTables.push({ from: nameOf(current), to: name });
+    const before = typedColumnsOf(current);
+    const defaults = columnsOf(table, "default", (v) => typeof v === "string" ? v : "");
+    for (const column of typedColumnsOf(table).keys()) {
+      if (before.has(column)) continue;
+      addedColumns.push(`${name}.${column}`);
+      const value = defaults.get(column) ?? "";
+      if (value !== "") addedDefaults[`${name}.${column}`] = value;
+    }
+  }
+  return { createdTables, addedColumns, addedDefaults, renamedTables };
+}
+function objectDelta(live, outgoing) {
+  const liveName = nameOf(live);
+  const outgoingName = nameOf(outgoing);
+  if (liveName !== outgoingName) return [`renamed from "${liveName}" to "${outgoingName}"`];
+  return deepEqual(normalize(live), normalize(outgoing)) ? [] : ["configuration differs"];
+}
+var WORKSPACE_KEY = "workspace";
+var ENV_KEY = "env";
+var VAULT_KEY = "vault";
+var ARCHIVE_KEYS = /* @__PURE__ */ new Set(["metadata", "partial"]);
+var SETTINGS_KEYS_COMPARED_ELSEWHERE = /* @__PURE__ */ new Set([
+  WORKSPACE_KEY,
+  ENV_KEY,
+  "canonical",
+  "guid",
+  "documentation",
+  "checksum",
+  "iv",
+  "salt",
+  "secret",
+  "crypto"
+]);
+var WORKSPACE_VALUE_DEFAULTS = {
+  settings: DEFAULT_SETTINGS,
+  preferences: DEFAULT_PREFERENCES,
+  swagger: false,
+  description: ""
+};
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function fillAbsentDefaults(live, fallback) {
+  if (live === void 0) return fallback;
+  if (!isPlainObject(live) || !isPlainObject(fallback)) return live;
+  const out = { ...live };
+  for (const [key, member] of Object.entries(fallback)) out[key] = fillAbsentDefaults(live[key], member);
+  return out;
+}
+function settingsSides(row, theirs, rawOurs, rawTheirs) {
+  if (!isPlainObject(theirs)) return { ours: omitComparedElsewhere(row), live: theirs };
+  const rawLive = isPlainObject(rawTheirs) ? rawTheirs : theirs;
+  const live = { ...theirs };
+  const ours = {};
+  for (const [key, fallback] of Object.entries(WORKSPACE_VALUE_DEFAULTS)) {
+    live[key] = fillAbsentDefaults(rawLive[key], fallback);
+    if (Object.hasOwn(rawOurs, key)) ours[key] = rawOurs[key];
+  }
+  for (const [key, value] of Object.entries(omitComparedElsewhere(row))) {
+    if (Object.hasOwn(WORKSPACE_VALUE_DEFAULTS, key)) continue;
+    if (isWorkspaceKeyAtDefault(key, value) && (theirs[key] === void 0 || isWorkspaceKeyAtDefault(key, theirs[key]))) {
+      continue;
+    }
+    ours[key] = value;
+  }
+  return { ours, live };
+}
+function omitComparedElsewhere(row) {
+  return Object.fromEntries(Object.entries(row).filter(([key]) => !SETTINGS_KEYS_COMPARED_ELSEWHERE.has(key)));
+}
+function subsetDifferences(ours, theirs, path = "") {
+  const here = [path === "" ? "(row)" : path];
+  if (ours === null || typeof ours !== "object") return deepEqual(ours, theirs) ? [] : here;
+  if (Array.isArray(ours) || Array.isArray(theirs)) return deepEqual(ours, theirs) ? [] : here;
+  if (theirs === null || typeof theirs !== "object") return here;
+  const live = theirs;
+  return Object.entries(ours).flatMap(
+    ([key, value]) => subsetDifferences(value, live[key], path === "" ? key : `${path}.${key}`)
+  );
+}
+function workspaceSettingsDifferences(ours, theirs, outgoing, live, documentation) {
+  if (ours === null || typeof ours !== "object" || Array.isArray(ours)) {
+    return deepEqual(normalize(ours), normalize(theirs)) ? [] : ["(row)"];
+  }
+  const sides = settingsSides(
+    normalize(ours),
+    normalize(theirs),
+    ours,
+    theirs
+  );
+  const fields = subsetDifferences(sides.ours, sides.live);
+  if (documentation !== "skip") fields.push(...documentationDifferences(ours, theirs, documentation));
+  const liveEnv = envValuesOf(live);
+  for (const name of envValuesOf(outgoing).keys()) {
+    if (!liveEnv.has(name)) fields.push(`env.${name}`);
+  }
+  return fields;
+}
+function documentationDifferences(ours, theirs, mode) {
+  const authored = ours.documentation;
+  if (authored === null || typeof authored !== "object" || Array.isArray(authored)) return [];
+  const block = authored;
+  const live = theirs !== null && typeof theirs === "object" && !Array.isArray(theirs) ? theirs.documentation : void 0;
+  const fields = [];
+  if (typeof block.token === "string" && block.token !== "") {
+    if (mode === "request" || block.token !== live?.token) fields.push("documentation.token");
+  }
+  if (Object.hasOwn(block, "require_token") && !deepEqual(block.require_token, live?.require_token)) {
+    fields.push("documentation.require_token");
+  }
+  return fields;
+}
+var SAMPLE = 5;
+function payloadOf(bundle) {
+  const payload = bundle?.payload;
+  return payload !== null && typeof payload === "object" ? payload : {};
+}
+function guidOf(row) {
+  const guid = row.guid;
+  return typeof guid === "string" && guid !== "" ? guid : void 0;
+}
+function indexSection(rows2) {
+  const byGuid = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  const repeated = /* @__PURE__ */ new Set();
+  const all = [];
+  for (const row of rows2) {
+    if (row === null || typeof row !== "object") continue;
+    const record = row;
+    all.push(record);
+    const guid = guidOf(record);
+    if (guid !== void 0) byGuid.set(guid, record);
+    const name = record.name;
+    if (typeof name !== "string" || name === "") continue;
+    if (byName.has(name) || repeated.has(name)) {
+      byName.delete(name);
+      repeated.add(name);
+      continue;
+    }
+    byName.set(name, record);
+  }
+  return { byGuid, byName, all };
+}
+function byNameWithoutGuid(index, name, ourGuid) {
+  const candidate = index.byName.get(name);
+  if (candidate === void 0) return void 0;
+  return guidOf(candidate) === void 0 || ourGuid === void 0 ? candidate : void 0;
+}
+function nameOf(row) {
+  if (typeof row.name === "string" && row.name !== "") return row.name;
+  return typeof row.path === "string" && row.path !== "" ? row.path.replace(/^knowledge-refs\/[^/]+\//, "") : "(unnamed)";
+}
+var SDK_KIND_BY_SECTION = {
+  dbo: "table",
+  app: "apiGroup",
+  workflow_test: "workflowTest",
+  realtime_server: "realtimeServer",
+  channel: "realtimeChannel",
+  message: "realtimeMessage"
+};
+function sectionKind(key, row) {
+  if (key === "toolset") return row?.type === "agent" ? "agent" : "mcpServer";
+  return (Object.hasOwn(SDK_KIND_BY_SECTION, key) ? SDK_KIND_BY_SECTION[key] : void 0) ?? key;
+}
+function planTypeSection(type) {
+  return (Object.hasOwn(PLAN_TYPE_SECTIONS, type) ? PLAN_TYPE_SECTIONS[type] : void 0) ?? type;
+}
+var PLAN_TYPE_SECTIONS = { table: "dbo", api_group: "app" };
+var SETTINGS_LABEL = `${sectionKind(WORKSPACE_KEY)}:(settings)`;
+function rowLabeler(payload) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const group of Array.isArray(payload.app) ? payload.app : []) {
+    if (group === null || typeof group !== "object") continue;
+    const g = group;
+    if (typeof g.name !== "string") continue;
+    if (typeof g.guid === "string" && g.guid !== "") groups.set(g.guid, g.name);
+    if (typeof g.id === "number" && g.id !== 0) groups.set(g.id, g.name);
+  }
+  return (key, row) => {
+    const kind = sectionKind(key, row);
+    if (key === "knowledge_file") return `${kind}:${identityName(payload, key, row)}`;
+    if ((key === "channel" || key === "message") && typeof row.name === "string" && row.name !== "") {
+      return `${kind}:${identityName(payload, key, row)}`;
+    }
+    if (key !== "query") return `${kind}:${nameOf(row)}`;
+    const verb = typeof row.verb === "string" && row.verb !== "" ? `${row.verb} ` : "";
+    const ref = row.app?.id;
+    const group = ref === void 0 || ref === 0 || ref === "" ? void 0 : groups.get(ref) ?? (typeof ref === "number" ? `#${ref}` : String(ref));
+    return `${kind}:${verb}${nameOf(row)}${group === void 0 ? "" : ` (apiGroup ${group})`}`;
+  };
+}
+function declaredLabels(bundle) {
+  const payload = payloadOf(bundle);
+  const label = rowLabeler(payload);
+  return Object.entries(payload).flatMap(
+    ([key, section]) => Array.isArray(section) ? section.flatMap(
+      (row) => row !== null && typeof row === "object" && typeof row.name === "string" ? [label(key, row)] : []
+    ) : []
+  );
+}
+var isEmptyList = (v) => Array.isArray(v) && v.length === 0;
+var isEmptyText = (v) => v === "";
+var isFalse = (v) => v === false;
+var isNull = (v) => v === null;
+var isNoTests = (v) => v === null || isEmptyList(v);
+var allNull = (v) => isPlainObject(v) && Object.values(v).every((m) => m === null);
+var telemetryOff = (v) => deepEqual(v, {
+  enabled: false,
+  langfuse: { base_url: "", public_key: "", secret_key: "" },
+  langsmith: { api_key: "" },
+  braintrust: { api_key: "", project_name: "" },
+  destination: ""
+});
+var ENGINE_FILLED_DEFAULTS = {
+  tool: {
+    auth: isFalse,
+    icons: isEmptyList,
+    title: isEmptyText,
+    annotations: allNull,
+    output_schema: isEmptyList,
+    test: isNoTests
+  },
+  // Agents and MCP servers share the section; an MCP server stores no settings.
+  toolset: {
+    prompt: isEmptyList,
+    resource: isEmptyList,
+    agent_settings: isNull
+  }
+};
+var AGENT_SETTINGS_DEFAULTS = {
+  model: isEmptyText,
+  telemetry: telemetryOff
+};
+function withoutEngineDefaults(defaults, ours, theirs) {
+  if (defaults === void 0) return [ours, theirs];
+  const a = { ...ours };
+  const b = { ...theirs };
+  for (const [key, isDefault] of Object.entries(defaults)) {
+    const atDefault = (row) => !Object.hasOwn(row, key) || isDefault(row[key]);
+    if (atDefault(a) && atDefault(b)) {
+      delete a[key];
+      delete b[key];
+    }
+  }
+  if (defaults === ENGINE_FILLED_DEFAULTS.toolset && isPlainObject(a.agent_settings) && isPlainObject(b.agent_settings)) {
+    [a.agent_settings, b.agent_settings] = withoutEngineDefaults(AGENT_SETTINGS_DEFAULTS, a.agent_settings, b.agent_settings);
+  }
+  return [a, b];
+}
+function withoutNullColumnDefaults(table) {
+  const strip = (columns) => Array.isArray(columns) ? columns.map((col) => {
+    if (!isPlainObject(col)) return col;
+    const { default: d, ...rest } = col;
+    const out = d === null ? rest : col;
+    return Array.isArray(out.children) ? { ...out, children: strip(out.children) } : out;
+  }) : columns;
+  return Array.isArray(table.schema) ? { ...table, schema: strip(table.schema) } : table;
+}
+function hostedIconIdentity(src) {
+  if (typeof src !== "string") return void 0;
+  const decode = (name) => {
+    try {
+      return decodeURIComponent(name);
+    } catch {
+      return name;
+    }
+  };
+  const placeholder = /^xanosdk-file:\/\/([^/\s]+)\/([^/\s]+)$/.exec(src);
+  if (placeholder) return `${placeholder[1]}/${decode(placeholder[2])}`;
+  const library = /^\/vault\/[^/\s]+\/([^/\s]+)\/[^/\s]+\/([^/\s]+)$/.exec(src);
+  if (library) return `${library[1]}/${decode(library[2])}`;
+  return void 0;
+}
+function withHostedIconIdentity(row) {
+  if (!Array.isArray(row.icons)) return row;
+  return {
+    ...row,
+    icons: row.icons.map((icon) => {
+      if (!isPlainObject(icon)) return icon;
+      const id = hostedIconIdentity(icon.src);
+      return id === void 0 ? icon : { ...icon, src: `hosted:${id}` };
+    })
+  };
+}
+var INDEX_SET_KEY = "(indexes)";
+function comparable(section, oursIn, theirsIn, pinned) {
+  let [ours, theirs] = withoutEngineDefaults(Object.hasOwn(ENGINE_FILLED_DEFAULTS, section) ? ENGINE_FILLED_DEFAULTS[section] : void 0, oursIn, theirsIn);
+  if (section === "dbo") {
+    [ours, theirs] = [withoutNullColumnDefaults(ours), withoutNullColumnDefaults(theirs)];
+    [ours, theirs] = [{ ...ours, [INDEX_SET_KEY]: indexKeysOf(oursIn) }, { ...theirs, [INDEX_SET_KEY]: indexKeysOf(theirsIn) }];
+  }
+  if (HOSTED_ICON_KINDS.includes(section)) [ours, theirs] = [withHostedIconIdentity(ours), withHostedIconIdentity(theirs)];
+  if (pinned || !("canonical" in ours || "canonical" in theirs)) {
+    return [normalize(ours), normalize(theirs)];
+  }
+  const { canonical: _a, ...oursRest } = ours;
+  const { canonical: _b, ...theirsRest } = theirs;
+  return [normalize(oursRest), normalize(theirsRest)];
+}
+function pinsCanonical(key, record, pinnedKeys) {
+  const name = typeof record.name === "string" ? record.name : void 0;
+  if (pinnedKeys !== void 0) {
+    return name !== void 0 && pinnedKeys.has(`${key}:${name}`);
+  }
+  return typeof record.canonical === "string" && record.canonical !== "";
+}
+function compareToLive(outgoing, live, pinnedKeys, opts = {}) {
+  const ours = payloadOf(outgoing);
+  const theirs = payloadOf(live);
+  const ourLabel = rowLabeler(ours);
+  const theirLabel = rowLabeler(theirs);
+  const cap = opts.sample === "all" ? Number.POSITIVE_INFINITY : opts.sample ?? SAMPLE;
+  const differing = [];
+  const missing = [];
+  const liveOnly = [];
+  let settingsFields = [];
+  let differingCount = 0;
+  let missingCount = 0;
+  let compared = 0;
+  const note = (label) => {
+    differingCount++;
+    if (differing.length < cap) differing.push(label);
+  };
+  const absent = (label) => {
+    missingCount++;
+    if (missing.length < cap) missing.push(label);
+  };
+  for (const [key, value] of Object.entries(ours)) {
+    if (key === ENV_KEY || ARCHIVE_KEYS.has(key)) continue;
+    if (key === WORKSPACE_KEY) {
+      compared++;
+      settingsFields = workspaceSettingsDifferences(value, theirs[key], outgoing, live, opts.documentation ?? "request");
+      if (settingsFields.length > 0) note(SETTINGS_LABEL);
+      continue;
+    }
+    if (!Array.isArray(value)) {
+      compared++;
+      if (!deepEqual(normalize(value), normalize(theirs[key]))) note(`${sectionKind(key)}:(settings)`);
+      continue;
+    }
+    const liveSection = theirs[key];
+    const index = indexSection(Array.isArray(liveSection) ? liveSection : []);
+    const matched = /* @__PURE__ */ new Set();
+    for (const row of value) {
+      compared++;
+      if (row === null || typeof row !== "object") {
+        note(`${sectionKind(key)}:(unreadable)`);
+        continue;
+      }
+      const record = row;
+      const guid = guidOf(record);
+      const name = typeof record.name === "string" ? record.name : void 0;
+      const counterpart = (guid !== void 0 ? index.byGuid.get(guid) : void 0) ?? // Name only answers what guid cannot. A live row that HAS a guid and
+      // does not have ours is a different object — the import would create
+      // ours alongside it — so the fallback is refused there and taken only
+      // when one side carries no guid at all.
+      (name !== void 0 ? byNameWithoutGuid(index, name, guid) : void 0);
+      if (counterpart === void 0) {
+        absent(ourLabel(key, record));
+        continue;
+      }
+      matched.add(counterpart);
+      if (!deepEqual(...comparable(key, record, counterpart, pinsCanonical(key, record, pinnedKeys)))) {
+        note(ourLabel(key, record));
+      }
+    }
+    if (key === VAULT_KEY) continue;
+    for (const row of index.all) {
+      if (!matched.has(row)) liveOnly.push(theirLabel(key, row));
+    }
+  }
+  for (const [key, value] of Object.entries(theirs)) {
+    if (key in ours || key === ENV_KEY || key === WORKSPACE_KEY || key === VAULT_KEY || ARCHIVE_KEYS.has(key)) continue;
+    if (!Array.isArray(value)) continue;
+    for (const row of value) {
+      if (row !== null && typeof row === "object") liveOnly.push(theirLabel(key, row));
+    }
+  }
+  return {
+    converged: compared > 0 && differingCount === 0 && missingCount === 0,
+    compared,
+    differing,
+    differingCount,
+    missing,
+    missingCount,
+    liveOnly,
+    settingsFields
+  };
+}
+
+export {
+  storedColumnsAfter,
+  uniqueIndexLabels,
+  indexKeysOf,
+  vectorSize,
+  envValuesOf,
+  diffAgainstLive,
+  secretsCarriedBy,
+  secretsInMultidoc,
+  passwordHashesInMultidoc,
+  sharedSchemaChanges,
+  tableAdditions,
+  payloadOf,
+  sectionKind,
+  planTypeSection,
+  SETTINGS_LABEL,
+  rowLabeler,
+  declaredLabels,
+  hostedIconIdentity,
+  compareToLive
+};
+//# sourceMappingURL=chunk-45UIT5T2.js.map