@xano/sdk 1.0.5 → 1.0.6

package/dist/{chunk-SF2B7MZK.js → chunk-IYXL5NYU.js}

@@ -1,11 +1,14 @@
 import {
-  identityName,
-  isWorkspaceKeyAtDefault
-} from "./chunk-MEIJDRHU.js";
-import {
+  DEFAULT_DOCUMENTATION,
   DEFAULT_PREFERENCES,
-  DEFAULT_SETTINGS
+  DEFAULT_SETTINGS,
+  LEGACY_REALTIME
 } from "./chunk-6JAEMMZ7.js";
+import {
+  identityNamesByGuid,
+  lockNameForObject,
+  sdkKindName
+} from "./chunk-5KJBWIDZ.js";
 import {
   HOSTED_ICON_KINDS,
   isPrivateLibraryRow
@@ -13,7 +16,228 @@ import {
 import {
   deepEqual,
   normalize
-} from "./chunk-3HOGFGKG.js";
+} from "./chunk-D3KEPRRN.js";
+
+// src/codegen/omissions.ts
+function omissionSeverity(reason) {
+  return reason === "unmodeled" ? "warning" : "notice";
+}
+var UNSUPPORTED_SECTIONS = {
+  vault: {
+    label: "stored files",
+    reason: "stored-file",
+    detail: 'a file\'s bytes are not carried into the generated tree; to ship one from the project, put it in the repo and point the field at `hostedFile("./<file>", import.meta.url)`'
+  },
+  // These three were tagged `unmodeled`, which their own detail lines contradict:
+  // none of them is an object type the SDK failed to model. They are records of
+  // what was done to the workspace, owned by the instance that did it.
+  market_item: { label: "marketplace records", reason: "instance-owned", detail: "marketplace provenance is owned by the instance" },
+  run_install: { label: "install runs", reason: "instance-owned", detail: "install runs are instance history, not workspace source" },
+  action_package_install: {
+    label: "action-package installs",
+    reason: "instance-owned",
+    detail: "action-package installs are owned by the instance"
+  },
+  service: { label: "services", reason: "unmodeled", detail: "services are not modeled by this SDK" },
+  branch: { label: "branches", reason: "server-managed", detail: "branches are instance state, not workspace source" }
+};
+var WORKSPACE_OMITTED_KEYS = {
+  // --- private key material ---
+  iv: { label: "encryption material", reason: "secret", detail: "instance crypto material" },
+  salt: { label: "encryption salt", reason: "secret", detail: "instance crypto material" },
+  secret: { label: "encryption secret", reason: "secret", detail: "instance crypto material" },
+  crypto: { label: "encryption keys", reason: "secret", detail: "instance crypto material" },
+  mesh0: { label: "integration API keys", reason: "secret", detail: "integration API keys" },
+  git: { label: "git integration keys", reason: "secret", detail: "integration deploy keys" },
+  // --- assigned and owned by the instance ---
+  id: { label: "workspace id", reason: "server-managed", detail: "instance-assigned workspace id" },
+  guid: {
+    label: "workspace guid",
+    reason: "server-managed",
+    derived: true,
+    detail: "instance-assigned workspace guid; the generated tree re-derives its own from the workspace name rather than carrying it"
+  },
+  checksum: { label: "checksum", reason: "server-managed", detail: "derived by the engine on save" },
+  created_at: { label: "created time", reason: "server-managed", detail: "engine timestamp" },
+  updated_at: { label: "updated time", reason: "server-managed", detail: "engine timestamp" },
+  deleted_at: { label: "deleted time", reason: "server-managed", detail: "engine timestamp" },
+  domain_prefix: {
+    label: "routing prefix",
+    reason: "server-managed",
+    detail: "instance-assigned routing prefix; redeploying it to another tenant would claim its hostnames"
+  },
+  branch: { label: "current branch", reason: "server-managed", detail: "current-branch pointer, instance state" },
+  release: { label: "current release", reason: "server-managed", detail: "release pointer, instance state" },
+  user: { label: "owning user", reason: "server-managed", detail: "owning-user record" },
+  usage: { label: "usage counters", reason: "server-managed", detail: "usage counters, instance state" },
+  features: { label: "feature flags", reason: "server-managed", detail: "instance feature flags" },
+  installed_services: { label: "installed services", reason: "server-managed", detail: "per-branch installed service ids" },
+  provision: { label: "provisioning state", reason: "server-managed", detail: "provisioning progress, instance state" },
+  well_known: { label: "well-known records", reason: "server-managed", detail: "well-known hosting records, instance state" },
+  tailor_experience: { label: "onboarding answers", reason: "server-managed", detail: "onboarding survey answers" },
+  require_setup: { label: "setup state", reason: "server-managed", detail: "onboarding state" },
+  disabled: { label: "disable flag", reason: "server-managed", detail: "instance-level workspace disable flag" },
+  jumpstart: { label: "starter state", reason: "server-managed", detail: "onboarding state" },
+  sql_schema_name: { label: "database schema name", reason: "server-managed", detail: "physical schema name, instance-assigned" },
+  connect: { label: "connection state", reason: "server-managed", detail: "third-party connection state" },
+  // --- carried elsewhere in the bundle ---
+  env: {
+    label: "env vars",
+    reason: "relocated",
+    emptied: true,
+    detail: "workspace env vars are carried in the bundle's own env set, where the import reads them; they are verified there"
+  }
+};
+var WORKSPACE_DEFAULTED_KEYS = {
+  use_custom_names: (v) => v === false,
+  // The two blocks the wipe was expressible through. Omitting either emits
+  // no key, so both need recognising here for the same reason the four below do:
+  // the engine materializes them on save, so a stored default is ten lines
+  // nobody wrote — and verification reads this table, so a tree that leaves the
+  // default behind compares equal rather than reporting a loss.
+  documentation: isDefaultDocumentation,
+  realtime: isDefaultLegacyRealtime,
+  defaults: (v) => isRecord(v) && Object.keys(v).length === 1 && v.db_primary_key === "int",
+  datasources: (v) => Array.isArray(v) && v.length === 0,
+  datasource_live: (v) => isRecord(v) && Object.keys(v).length === 2 && v.color === "#008000" && v.show_banner === false,
+  middleware: (v) => isRecord(v) && Object.values(v).every((list) => Array.isArray(list) && list.length === 0),
+  history: isDefaultWorkspaceHistory
+};
+function isDefaultDocumentation(value) {
+  return matchesDefault(value, DEFAULT_DOCUMENTATION, { whitelist: isEmptyWhitelist });
+}
+function isEmptyWhitelist(value) {
+  if (Array.isArray(value)) return value.length === 0;
+  return isRecord(value) && Object.keys(value).length === 0;
+}
+function isDefaultLegacyRealtime(value) {
+  return matchesDefault(value, LEGACY_REALTIME, {
+    channels: (v) => Array.isArray(v) && v.length === 0
+  });
+}
+function matchesDefault(value, defaults, loose = {}) {
+  if (!isRecord(value)) return false;
+  return Object.entries(value).every(([key, member]) => {
+    if (!Object.hasOwn(defaults, key)) return false;
+    const predicate = Object.hasOwn(loose, key) ? loose[key] : void 0;
+    return predicate ? predicate(member) : deepEqualDefault(member, defaults[key]);
+  });
+}
+function deepEqualDefault(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, i) => deepEqualDefault(item, b[i]));
+  }
+  if (!isRecord(a) || !isRecord(b)) return false;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  return [...keys].every((k) => deepEqualDefault(a[k], b[k]));
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function subtractDefaults(value, fallback) {
+  if (deepEqualDefault(value, fallback)) return void 0;
+  if (!isRecord(value) || !isRecord(fallback)) return value;
+  const out = {};
+  for (const [key, member] of Object.entries(value)) {
+    const kept = Object.hasOwn(fallback, key) ? subtractDefaults(member, fallback[key]) : member;
+    if (kept !== void 0) out[key] = kept;
+  }
+  return Object.keys(out).length === 0 ? void 0 : out;
+}
+var HISTORY_DEFAULT_OFF = /* @__PURE__ */ new Set(["function", "middleware", "trigger", "message"]);
+function isDefaultWorkspaceHistory(value) {
+  if (!isRecord(value)) return false;
+  return Object.entries(value).every(([key, member]) => {
+    const enabled = key.endsWith("_enabled");
+    if (!enabled && !key.endsWith("_limit")) return false;
+    const type = key.slice(0, key.lastIndexOf("_"));
+    return enabled ? member === !HISTORY_DEFAULT_OFF.has(type) : member === 100;
+  });
+}
+function isWorkspaceKeyAtDefault(key, value) {
+  const predicate = Object.hasOwn(WORKSPACE_DEFAULTED_KEYS, key) ? WORKSPACE_DEFAULTED_KEYS[key] : void 0;
+  return predicate !== void 0 && predicate(value);
+}
+function sectionOmission(key) {
+  return Object.hasOwn(UNSUPPORTED_SECTIONS, key) ? UNSUPPORTED_SECTIONS[key] : void 0;
+}
+function workspaceKeyOmission(key) {
+  return Object.hasOwn(WORKSPACE_OMITTED_KEYS, key) ? WORKSPACE_OMITTED_KEYS[key] : void 0;
+}
+
+// src/codegen/labels.ts
+var NOUNS = {
+  query: ["query", "queries"],
+  env: ["env var", "env vars"],
+  knowledge: ["knowledge item", "knowledge items"],
+  knowledge_file: ["knowledge file", "knowledge files"],
+  addon: ["addon", "addons"]
+};
+function countOf(n, singular, plural = `${singular}s`) {
+  return `${n} ${n === 1 ? singular : plural}`;
+}
+function decodedCounts(payload) {
+  const out = [];
+  for (const [key, section] of Object.entries(payload)) {
+    if (!Array.isArray(section) || section.length === 0) continue;
+    if (key === "toolset") {
+      const agents = section.filter((r) => r?.type === "agent").length;
+      if (agents > 0) out.push(["agent", countOf(agents, "agent")]);
+      if (section.length - agents > 0) out.push(["mcpServer", countOf(section.length - agents, "mcpServer")]);
+      continue;
+    }
+    const policy = sectionOmission(key);
+    if (policy !== void 0) {
+      out.push([policy.label, `${section.length} ${policy.label}`]);
+      continue;
+    }
+    const noun = Object.hasOwn(NOUNS, key) ? NOUNS[key] : void 0;
+    const kind = sdkKindName(key);
+    out.push([kind, noun !== void 0 ? countOf(section.length, noun[0], noun[1]) : countOf(section.length, kind)]);
+  }
+  return out.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0).map(([, phrase]) => phrase);
+}
+var repeatedNames = /* @__PURE__ */ new WeakMap();
+function identityName(payload, payloadKey, stored) {
+  if (payloadKey === "knowledge_file") return knowledgeFileName(payload, stored);
+  const name = String(stored?.name ?? "");
+  let repeats = repeatedNames.get(payload);
+  if (repeats === void 0) {
+    repeats = /* @__PURE__ */ new Map();
+    for (const [key, section] of Object.entries(payload)) {
+      if (!Array.isArray(section)) continue;
+      const seen = /* @__PURE__ */ new Set();
+      const twice = /* @__PURE__ */ new Set();
+      for (const row of section) {
+        const n = String(row?.name ?? "");
+        if (seen.has(n)) twice.add(n);
+        seen.add(n);
+      }
+      repeats.set(key, twice);
+    }
+    repeatedNames.set(payload, repeats);
+  }
+  if (!repeats.get(payloadKey)?.has(name)) return name;
+  return lockNameForObject(payloadKey, stored, identityNamesByGuid(payload));
+}
+function knowledgeFileName(payload, stored) {
+  const { path, knowledge } = stored ?? {};
+  const items = Array.isArray(payload.knowledge) ? payload.knowledge : [];
+  const item = items.find((k) => k?.guid === knowledge?.id);
+  const rel = String(path ?? "").replace(/^knowledge-refs\/[^/]+\//, "");
+  return item?.name === void 0 ? rel : `${String(item.name)}/${rel}`;
+}
+var WORKSPACE_SETTINGS = "workspace settings";
+function reportObjectLabel(payloadKey, name) {
+  if (payloadKey === "workspace") {
+    const policy = workspaceKeyOmission(name);
+    return `${WORKSPACE_SETTINGS} (${policy?.label ?? name})`;
+  }
+  const section = sectionOmission(payloadKey);
+  if (section !== void 0) return `${section.label}: ${name}`;
+  return `${sdkKindName(payloadKey)}:${name}`;
+}
 
 // src/deploy/live-diff.ts
 function storedColumnsAfter(outgoing, live, prior, mode) {
@@ -681,27 +905,22 @@ 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 };
+function withoutEngineDefaults(defaults, row) {
+  if (defaults === void 0) return row;
+  const out = { ...row };
   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 (!Object.hasOwn(out, key) || isDefault(out[key])) delete out[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);
+  if (defaults === ENGINE_FILLED_DEFAULTS.toolset && isPlainObject(out.agent_settings)) {
+    out.agent_settings = withoutEngineDefaults(AGENT_SETTINGS_DEFAULTS, out.agent_settings);
   }
-  return [a, b];
+  return out;
 }
-function withoutNullColumnDefaults(table) {
+function withoutEmptyColumnDefaults(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;
+    const out = d === null || d === "" || col.required === true ? 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;
@@ -734,18 +953,17 @@ function withHostedIconIdentity(row) {
 }
 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);
+  return [canonicalRow(section, oursIn, pinned), canonicalRow(section, theirsIn, pinned)];
+}
+function canonicalRow(section, rowIn, pinned) {
+  let row = withoutEngineDefaults(Object.hasOwn(ENGINE_FILLED_DEFAULTS, section) ? ENGINE_FILLED_DEFAULTS[section] : void 0, rowIn);
   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)];
+    row = { ...withoutEmptyColumnDefaults(row), [INDEX_SET_KEY]: indexKeysOf(rowIn) };
   }
-  const { canonical: _a, ...oursRest } = ours;
-  const { canonical: _b, ...theirsRest } = theirs;
-  return [normalize(oursRest), normalize(theirsRest)];
+  if (HOSTED_ICON_KINDS.includes(section)) row = withHostedIconIdentity(row);
+  if (pinned || !("canonical" in row)) return normalize(row);
+  const { canonical: _slug, ...rest } = row;
+  return normalize(rest);
 }
 function pinsCanonical(key, record, pinnedKeys) {
   const name = typeof record.name === "string" ? record.name : void 0;
@@ -839,6 +1057,15 @@ function compareToLive(outgoing, live, pinnedKeys, opts = {}) {
 }
 
 export {
+  omissionSeverity,
+  UNSUPPORTED_SECTIONS,
+  subtractDefaults,
+  isWorkspaceKeyAtDefault,
+  sectionOmission,
+  workspaceKeyOmission,
+  decodedCounts,
+  identityName,
+  reportObjectLabel,
   storedColumnsAfter,
   uniqueIndexLabels,
   indexKeysOf,
@@ -857,6 +1084,7 @@ export {
   rowLabeler,
   declaredLabels,
   hostedIconIdentity,
+  canonicalRow,
   compareToLive
 };
-//# sourceMappingURL=chunk-SF2B7MZK.js.map
+//# sourceMappingURL=chunk-IYXL5NYU.js.map

package/dist/{chunk-57B56I4B.js → chunk-JFBRXRJD.js}

@@ -1,26 +1,22 @@
 import {
   createOperation,
   runOperation
-} from "./chunk-SNGFEESM.js";
+} from "./chunk-LAOMN6QQ.js";
 import {
   fetchWorkspaceBundle
-} from "./chunk-LZDA6SVD.js";
+} from "./chunk-RIN4YY34.js";
 import {
   assertReleaseIdentitiesFree,
   pinnedCanonicalGuids,
   setLiveRollback
-} from "./chunk-Z2BRSQ6M.js";
+} from "./chunk-GLY552SI.js";
 import {
   liveBranchMismatch,
   liveMismatch
-} from "./chunk-YSLMMR2U.js";
+} from "./chunk-GHQ4BVI4.js";
 import {
   confirm
-} from "./chunk-AESE434J.js";
-import {
-  landingLockPath,
-  recordForeignLanding
-} from "./chunk-ES5A66IH.js";
+} from "./chunk-JXVJGF3Y.js";
 import {
   CONSTRAINT_FIX,
   CONSTRAINT_PHRASE,
@@ -39,24 +35,35 @@ import {
   releaseTableEffects,
   renameHint,
   tableEffectsPayload
-} from "./chunk-BBPAXOU6.js";
+} from "./chunk-CHINR7WD.js";
 import {
   tableRowCounter
-} from "./chunk-GMVW6ZZK.js";
+} from "./chunk-MBDFH7XB.js";
+import {
+  landingLockPath,
+  recordForeignLanding
+} from "./chunk-IF4PEGVD.js";
+import {
+  recordSync
+} from "./chunk-NDWVJ2QZ.js";
+import {
+  objectDigests,
+  syncDigests
+} from "./chunk-JI3BLXWQ.js";
 import {
   asWorkspaceArchive,
   resolveProjectEntry
-} from "./chunk-PIPIA7K7.js";
+} from "./chunk-Z4ZGTCCD.js";
 import {
   exportWorkspaceBundle
-} from "./chunk-XIABDKFQ.js";
+} from "./chunk-GOLFAEUV.js";
 import {
   decodeWorkspaceArchive
 } from "./chunk-3DRXWLJ5.js";
 import {
   SettledWriteFailure,
   classifyFailure
-} from "./chunk-5D6DGF3W.js";
+} from "./chunk-JRVQ7M7W.js";
 import {
   BranchTakenError,
   assertBranchAbsent,
@@ -67,16 +74,16 @@ import {
   listBranchListing,
   liveBranchLabel,
   setLiveBranch
-} from "./chunk-5RLAF6RL.js";
+} from "./chunk-NPODGBVJ.js";
 import {
   envValuesOf
-} from "./chunk-SF2B7MZK.js";
+} from "./chunk-IYXL5NYU.js";
 import {
   assertOneName
-} from "./chunk-A4NNCI4O.js";
+} from "./chunk-WBH4KJWM.js";
 import {
   resolveSource
-} from "./chunk-JXKO6JT7.js";
+} from "./chunk-3II44CUJ.js";
 import {
   ReleaseHttpError,
   UNPROMOTABLE_RELEASE_PARTS,
@@ -85,27 +92,27 @@ import {
   promotableReleaseName,
   unpromotableReleasePart,
   untenantDeployableReleasePart
-} from "./chunk-3BJYQGAZ.js";
+} from "./chunk-GWTFI3GA.js";
 import {
   getAccessToken
-} from "./chunk-CJ76PSJT.js";
+} from "./chunk-YGLMRH5U.js";
 import {
   pipedYes,
   retryCommand,
   withheldNote
-} from "./chunk-Z4VN347O.js";
+} from "./chunk-6X3MY2JP.js";
 import {
   contextFlags
-} from "./chunk-G57RYMKB.js";
+} from "./chunk-N5I37JFB.js";
 import {
   shellWord
 } from "./chunk-FWD7AL6N.js";
 import {
   readLockFile
-} from "./chunk-SQPIECXD.js";
+} from "./chunk-CJDPSCMX.js";
 import {
   withoutReadAftermath
-} from "./chunk-HLQH3AXB.js";
+} from "./chunk-YR2I5HGE.js";
 import {
   CliError,
   LocalFileNotFoundError,
@@ -123,19 +130,19 @@ import {
   success,
   warn,
   withoutUrls
-} from "./chunk-XNZURZ7T.js";
+} from "./chunk-D7BUMOKU.js";
 import {
   envNamesRead
-} from "./chunk-JSEVKRVJ.js";
+} from "./chunk-T4LJ5UR2.js";
 import {
   safeNames
 } from "./chunk-GSGDWJB5.js";
 import {
   setDiagnosticSink
-} from "./chunk-GPI3OWRE.js";
+} from "./chunk-YHB34BN6.js";
 import {
   sdkKindName2 as sdkKindName
-} from "./chunk-OKNE3TWU.js";
+} from "./chunk-5KJBWIDZ.js";
 import {
   shellQuote
 } from "./chunk-5ZSO4T2G.js";
@@ -292,7 +299,7 @@ async function verifyLanding(auth, opts) {
   } catch (err) {
     return unverified(shortReason(err));
   }
-  const { compareToLive, declaredLabels } = await import("./live-diff-IM4W3ELT.js");
+  const { compareToLive, declaredLabels } = await import("./live-diff-5E2BQWQ7.js");
   let result;
   try {
     result = compareToLive(declared, landedBundle, void 0, { sample: "all" });
@@ -311,7 +318,8 @@ async function verifyLanding(auth, opts) {
     undeclared,
     suffixed: suffixedSiblings(declaredLabels(declared), undeclared),
     compared: result.compared,
-    canonicals
+    canonicals,
+    landed: landedBundle
   };
 }
 function shortReason(err) {
@@ -464,7 +472,7 @@ async function runPromoteCommand(args) {
   discloseWriteTarget(destination);
   const lockPath = landingLockPath(args, args.entryPath === void 0 ? {} : { entryFile: args.entryPath });
   if (lockPath === void 0 && args.noLock !== true) {
-    const { nestedBackendEntries } = await import("./tracked-backend-B4HTME4S.js");
+    const { nestedBackendEntries } = await import("./tracked-backend-4BHSV7NC.js");
     const nested = nestedBackendEntries(process.cwd());
     if (nested.length > 0) {
       warn(
@@ -488,7 +496,7 @@ async function runPromoteCommand(args) {
     // sending every caller on an instance with an unreadable export to resolve
     // a write that already answered.
     checks: ["verify"],
-    extras: { declined: false, landingRecord: null, tableEffects: null, canonicalMoves: [] }
+    extras: { declined: false, landingRecord: null, syncBaseline: null, tableEffects: null, canonicalMoves: [] }
   });
   const flags = contextFlags(args);
   const yesFlags = `${pipedYes(args)}${flags}`;
@@ -775,6 +783,22 @@ Check what is serving with \`xanosdk workspace branch list${flags}\`, then promo
         );
       }
     }
+    if (verification.outcome === "passed" && verification.landed !== void 0) {
+      const released = await ctx.loadArchive().catch(() => void 0);
+      op.set(
+        "syncBaseline",
+        recordSync({
+          lockPath,
+          target: { instance: auth.instance, workspaceId: auth.workspaceId, branch },
+          digests: syncDigests({
+            held: [verification.landed],
+            ...released === void 0 ? {} : { heldLabels: new Set(Object.keys(objectDigests(released))) }
+          }),
+          by: "promote",
+          complete: true
+        })
+      );
+    }
     let live = false;
     let rollback;
     if (setLiveRequested) {
@@ -911,7 +935,7 @@ Nothing was switched. Serve it deliberately with \`xanosdk workspace branch set-
   }
 }
 async function unansweredBranchRead(err, args, what) {
-  const { LookupFailedError, isServerError, isTransportFailure, unansweredCause } = await import("./source-resolve-OWD3MIEO.js");
+  const { LookupFailedError, isServerError, isTransportFailure, unansweredCause } = await import("./source-resolve-MKLNYFWG.js");
   const transport = isTransportFailure(err);
   if (!transport && !isServerError(err)) return err;
   const first = what !== void 0 ? `could not read ${what}` : ((err instanceof Error ? err.message : String(err)).trim().split("\n")[0] ?? "").replace(/[.:]$/, "");
@@ -937,4 +961,4 @@ export {
   reportNotRun,
   runPromoteCommand
 };
-//# sourceMappingURL=chunk-57B56I4B.js.map
+//# sourceMappingURL=chunk-JFBRXRJD.js.map

package/dist/chunk-JI3BLXWQ.js

@@ -0,0 +1,107 @@
+import {
+  SETTINGS_LABEL,
+  canonicalRow,
+  payloadOf,
+  rowLabeler,
+  sectionKind,
+  sectionOmission
+} from "./chunk-IYXL5NYU.js";
+import {
+  canonicalJson
+} from "./chunk-7VR4IO5B.js";
+import {
+  md5Hex
+} from "./chunk-OHX6MIUZ.js";
+
+// src/deploy/sync-baseline.ts
+var DIGEST_SCHEME = 1;
+var SKIPPED_SECTIONS = /* @__PURE__ */ new Set(["env", "metadata", "partial", "workspace"]);
+function digestOf(canonical) {
+  return md5Hex(canonicalJson(canonical));
+}
+function objectDigests(bundle, which = "all") {
+  const payload = payloadOf(bundle);
+  const label = rowLabeler(payload);
+  const out = {};
+  for (const [key, section] of Object.entries(payload)) {
+    if (SKIPPED_SECTIONS.has(key)) continue;
+    if (which !== "all" && sectionOmission(key) === void 0 !== (which === "carried")) continue;
+    if (!Array.isArray(section)) {
+      if (section !== void 0 && section !== null) out[`${sectionKind(key)}:(settings)`] = digestOf(canonicalRow(key, { value: section }, true));
+      continue;
+    }
+    for (const row of section) {
+      if (row === null || typeof row !== "object") continue;
+      const record = row;
+      out[label(key, record)] = digestOf(canonicalRow(key, record, false));
+    }
+  }
+  return out;
+}
+function syncDigests(opts) {
+  const objects = {};
+  const others = {};
+  for (const bundle of opts.others ?? []) Object.assign(others, objectDigests(bundle));
+  for (const bundle of opts.held) {
+    for (const [label, digest] of Object.entries(objectDigests(bundle, "carried"))) {
+      if (opts.heldLabels === void 0 || opts.heldLabels.has(label)) objects[label] = digest;
+      else others[label] = digest;
+    }
+    Object.assign(others, objectDigests(bundle, "uncarried"));
+  }
+  for (const label of Object.keys(objects)) delete others[label];
+  return { scheme: DIGEST_SCHEME, objects, others };
+}
+function syncDirection(local, live, result, baseline) {
+  if (baseline === void 0 || baseline.scheme !== DIGEST_SCHEME) {
+    return { baseline: null, changedThere: [], changedHere: [], changedBoth: [], unclassified: [] };
+  }
+  const here = objectDigests(local);
+  const there = objectDigests(live);
+  const held = baseline.objects;
+  const others = baseline.others ?? {};
+  const digest = (map, label) => Object.hasOwn(map, label) ? map[label] : void 0;
+  const changedThere = [];
+  const changedHere = [];
+  const changedBoth = [];
+  const unclassified = [];
+  const file = (label, movedHere, movedThere) => {
+    if (movedHere && movedThere) changedBoth.push(label);
+    else if (movedHere) changedHere.push(label);
+    else if (movedThere) changedThere.push(label);
+    else unclassified.push(label);
+  };
+  for (const label of result.differing) {
+    const b = digest(held, label) ?? digest(others, label);
+    const h = digest(here, label);
+    const t = digest(there, label);
+    if (label === SETTINGS_LABEL || b === void 0 || h === void 0 || t === void 0) {
+      unclassified.push(label);
+      continue;
+    }
+    file(label, h !== b, t !== b);
+  }
+  for (const label of result.missing) {
+    const b = digest(held, label);
+    if (b !== void 0) file(label, digest(here, label) !== b, true);
+    else if (digest(others, label) !== void 0) file(label, true, true);
+    else changedHere.push(label);
+  }
+  for (const label of result.liveOnly) {
+    const b = digest(held, label);
+    const other = digest(others, label);
+    if (b !== void 0) file(label, true, digest(there, label) !== b);
+    else if (other !== void 0) {
+      if (digest(there, label) !== other) changedThere.push(label);
+    } else if (baseline.complete) changedThere.push(label);
+  }
+  return { baseline: { at: baseline.at, by: baseline.by }, changedThere, changedHere, changedBoth, unclassified };
+}
+
+export {
+  DIGEST_SCHEME,
+  objectDigests,
+  syncDigests,
+  syncDirection
+};
+//# sourceMappingURL=chunk-JI3BLXWQ.js.map

package/dist/{chunk-4DJTQ6W4.js → chunk-JIKGT7DO.js}

@@ -120,6 +120,7 @@ function authoredFieldType(type) {
 
 export {
   COLUMN_NULLABLE_TYPES,
+  INPUT_NULLABLE_TYPES,
   INPUT_CONTEXT,
   COLUMN_CONTEXT,
   defaultNullable,
@@ -130,4 +131,4 @@ export {
   CATALOG_BY_TYPE,
   authoredFieldType
 };
-//# sourceMappingURL=chunk-4DJTQ6W4.js.map
+//# sourceMappingURL=chunk-JIKGT7DO.js.map