@xano/sdk 1.0.0

package/dist/chunk-HHN734BU.js

@@ -0,0 +1,371 @@
+import {
+  readDeployed
+} from "./chunk-LPECSJ2J.js";
+import {
+  isProjectDir
+} from "./chunk-6NNTNXN7.js";
+import {
+  LookupFailedError,
+  SourceError,
+  resolveSource
+} from "./chunk-QCNYHBL7.js";
+import {
+  NotSignedInError
+} from "./chunk-ET4Y4XCB.js";
+import {
+  otherCredentialRefusal
+} from "./chunk-SWBF2LTK.js";
+import {
+  getEngineRecord
+} from "./chunk-3M4LFYNQ.js";
+import {
+  commandPath,
+  parseSlot,
+  refusedKind,
+  slotValueMissing
+} from "./chunk-STSFNCY4.js";
+import {
+  getEnvironment,
+  readEphemeralState,
+  unreadableEphemeralState
+} from "./chunk-5QU2P5CA.js";
+import {
+  ENV_CREDENTIAL_VARS,
+  ORIGIN_READ_ONLY_BY_REFRESH,
+  contextFlags,
+  credentialFileFlagFor,
+  recordedByEnvCredential,
+  typedCredentialFlags
+} from "./chunk-NAQDMEHV.js";
+import {
+  backendDirIn
+} from "./chunk-5A2PLKZB.js";
+import {
+  globalAuthFilePath,
+  localAuthFilePath,
+  loginCommand,
+  profileAddCommand,
+  readCredentialFile,
+  recordedCredentialPath
+} from "./chunk-XW6KISBB.js";
+import {
+  UsageError,
+  displayPath,
+  pastePath,
+  sourceSpellings
+} from "./chunk-PTHVMXZI.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+
+// src/emit/tracked-backend.ts
+import { existsSync, readdirSync } from "fs";
+import { join, relative } from "path";
+function memoCredential(provider) {
+  let pending;
+  return () => pending ??= provider();
+}
+async function selectBackend(slot, raw, ctx) {
+  if (raw !== void 0) return parseSlot(slot, raw);
+  if (slot.selector.default === "none") throw slotValueMissing(slot);
+  if (slot.selector.default !== "tracked") {
+    throw new Error(
+      `Internal: \`${commandPath(slot.command, slot.subcommand)}\`'s ${slot.spelling} defaults to "${slot.selector.default}", which the caller resolves itself \u2014 not the tracked backend.`
+    );
+  }
+  const cwd = ctx.deps?.cwd ?? process.cwd();
+  const env = ctx.deps?.env ?? process.env;
+  const pointer = readDeployed(cwd)?.kind;
+  if (pointer !== void 0) refuseUnservable(slot, pointer);
+  const state = readEphemeralState(cwd);
+  let scope;
+  if (pointer === "ephemeral") {
+    scope = await ctx.credential();
+  } else if (pointer === void 0 && Object.keys(state.environments).length > 0) {
+    scope = await silently(ctx.credential);
+  }
+  const decided = decide({ cwd, pointer, state, scope, engineRecorded: getEngineRecord(cwd, env) !== void 0 }, slot);
+  if ("refusal" in decided) {
+    const { reachableFirst } = await import("./env-target-O4HRKTGZ.js");
+    throw await reachableFirst(decided.refusal, scope);
+  }
+  refuseUnservable(slot, decided.kind);
+  return { kind: decided.kind };
+}
+async function resolveBackend(slot, raw, ctx) {
+  const credential = memoCredential(ctx.credential);
+  const source = await selectBackend(slot, raw, { ...ctx, credential });
+  if (source.kind === "file") {
+    throw new Error(`Internal: \`${commandPath(slot.command, slot.subcommand)}\` resolved a bundle file; read it before resolving a backend.`);
+  }
+  if (source.kind === "local-engine") refuseProfileForLocal(ctx.profile, [source.kind], slot);
+  return resolveSource(source, credential, { ...ctx.deps, cwd: ctx.deps?.cwd ?? process.cwd() }).catch((err) => {
+    throw lookupRetry(err, slot);
+  });
+}
+function lookupRetry(err, slot) {
+  if (!(err instanceof LookupFailedError)) return err;
+  return err.withRerun(`xanosdk ${commandPath(slot.command, slot.subcommand)} \u2026`, " as you ran it");
+}
+function refuseProfileForLocal(profile, kinds, slot, flags = typedCredentialFlags()) {
+  if (kinds.some((k) => k !== "local-engine")) return;
+  const why = "and a local engine takes none \u2014 it is reached with the engine's own bearer.";
+  const or = slot === void 0 ? "or drop `--local-engine` to deploy to a hosted backend." : `or ${nameOne(slot, "a hosted backend", true)}.`;
+  if (profile !== void 0) {
+    throw new UsageError(`\`--profile ${profile}\` selects a Xano credential, ${why} Drop \`--profile\`, ${or}`, hintOpts(slot));
+  }
+  if (flags.authFile !== void 0) {
+    throw new UsageError(`\`--config ${flags.authFile}\` names a Xano credential file, ${why} Drop \`--config\`, ${or}`, hintOpts(slot));
+  }
+  if (flags.local === true) {
+    throw new UsageError(`\`--local\` selects the project-local Xano credential file, ${why} Drop \`--local\`, ${or}`, hintOpts(slot));
+  }
+  if (flags.authHost !== void 0) {
+    throw new UsageError(`\`--origin\` names a Xano sign-in server, ${why} ${ORIGIN_READ_ONLY_BY_REFRESH}`, hintOpts(slot));
+  }
+}
+function readTrackedBackend(opts) {
+  const decided = decide(
+    {
+      cwd: opts.cwd,
+      pointer: readDeployed(opts.cwd)?.kind,
+      state: readEphemeralState(opts.cwd),
+      scope: opts.scope,
+      engineRecorded: getEngineRecord(opts.cwd, opts.env ?? process.env) !== void 0
+    },
+    void 0
+  );
+  if ("refusal" in decided) return { kind: null, via: null, reason: decided.refusal.message };
+  return { kind: decided.kind, via: decided.via, reason: null };
+}
+function decide(facts, slot) {
+  const { cwd, pointer, state, scope, engineRecorded } = facts;
+  const ephemeralHere = scope !== void 0 && getEnvironment(state, scope) !== void 0;
+  if (pointer === "local-engine") {
+    return engineRecorded ? { kind: "local-engine", via: "pointer" } : { refusal: noEngineRecorded(slot) };
+  }
+  if (pointer === "ephemeral") {
+    if (scope === void 0) return { refusal: signedOut(slot, state) };
+    return ephemeralHere ? { kind: "ephemeral", via: "pointer" } : { refusal: untracked(cwd, state, scope, slot, true) };
+  }
+  if (ephemeralHere) return { kind: "ephemeral", via: "fallback" };
+  if (engineRecorded) return { kind: "local-engine", via: "fallback" };
+  if (scope !== void 0) return { refusal: untracked(cwd, state, scope, slot, false) };
+  return { refusal: nothingTracked(cwd, slot, Object.keys(state.environments).length > 0, state) };
+}
+async function silently(credential) {
+  try {
+    return await credential();
+  } catch (err) {
+    if (err instanceof NotSignedInError) return void 0;
+    throw err;
+  }
+}
+function refuseUnservable(slot, kind) {
+  const refusal = refusedKind(slot, kind, "tracked");
+  if (refusal !== void 0) throw refusal;
+  if (!slot.selector.accepted.includes(kind)) {
+    throw new UsageError(
+      `This project last deployed to ${KIND_PHRASE[kind]}, which \`xanosdk ${commandPath(slot.command, slot.subcommand)}\` does not take. Name one with \`${slot.spelling}\`: ${sourceSpellings(slot.selector.accepted)}.`,
+      hintOpts(slot)
+    );
+  }
+}
+var KIND_PHRASE = {
+  ephemeral: "an ephemeral",
+  "local-engine": "a local engine"
+};
+function hintOpts(slot) {
+  if (slot === void 0) return {};
+  return {
+    hintFor: slot.subcommand === void 0 ? { command: slot.command } : { command: slot.command, subcommand: slot.subcommand }
+  };
+}
+function nameOne(slot, what = "a backend", hostedOnly = false) {
+  if (slot === void 0) return `name ${what} on the command explicitly`;
+  const spellings = sourceSpellings(
+    hostedOnly ? slot.selector.accepted.filter((k) => k !== "local-engine" && k !== "file") : slot.selector.accepted
+  );
+  if (!slot.spelling.startsWith("--")) {
+    const verb = slot.subcommand === void 0 ? slot.command : `${slot.command} ${slot.subcommand}`;
+    return `name ${what} as its argument (\`xanosdk ${verb} ${slot.spelling}\`): ${spellings}`;
+  }
+  return `name ${what} with \`${slot.spelling}\`: ${spellings}`;
+}
+function bothDeploys(cwd) {
+  const flags = contextFlags();
+  const entry = cwd === void 0 ? "" : soleNestedEntry(cwd);
+  const hosted = /(^| )--local( |$)/.test(flags) ? "an ephemeral, with the project-local credential" : "an ephemeral";
+  return `\`xanosdk deploy${entry}${flags}\` (${hosted}) or \`xanosdk deploy${entry} --local-engine\` (a local engine on this machine)`;
+}
+function untracked(cwd, state, scope, slot, pointer) {
+  const other = otherCredentialRefusal(state, scope, `or ${nameOne(slot)}`, hintOpts(slot));
+  if (other !== void 0) return other;
+  if (pointer) {
+    const unreadable = unreadableEphemeralState(cwd);
+    if (unreadable !== void 0) {
+      return new SourceError(
+        `This project last deployed to an ephemeral, but its record ${displayPath(unreadable)} is unreadable. \`xanosdk ephemeral list${contextFlags()}\` finds the ephemeral it recorded \u2014 then ${nameOne(slot, "it")}.`,
+        "gone",
+        "ephemeral"
+      );
+    }
+    return new SourceError(
+      `This project last deployed to an ephemeral, but the last one is gone (deleted or expired). Run \`xanosdk deploy${contextFlags()}\` to create one \u2014 or \`xanosdk deploy --local-engine\` for a local engine \u2014 or ${nameOne(slot)}.`,
+      "gone",
+      "ephemeral"
+    );
+  }
+  return nothingTracked(cwd, slot, false);
+}
+var NothingTrackedError = class extends UsageError {
+};
+function nothingTracked(cwd, slot, ephemeralRecordedElsewhere, state) {
+  const nested = ephemeralRecordedElsewhere ? [] : nestedTrackedBackends(cwd);
+  if (nested.length > 0) {
+    const takesEntry = slot?.command === "release" && slot.subcommand === "create" && !isProjectDir(cwd);
+    const shown = nested.map((n) => `\`${n.dir}\`${n.entry === void 0 ? "" : ` (deployed from ${n.entry})`}`);
+    const one = nested.length === 1 ? nested[0] : void 0;
+    return new NothingTrackedError(
+      `This directory has no backend to default to: nothing deployed from here. ` + (one !== void 0 ? `The backend below it at ${shown[0]} did, and its record is kept beside it. Run the command from there (\`cd ${shellQuote(one.dir)}\`)` + (takesEntry && one.entry !== void 0 ? `, or name its entry with \`--entry=${shellQuote(one.entry)}\`` : "") + `, or ${nameOne(slot)}.` : `Backends below it did, each with its record kept beside it: ${shown.join(", ")}. Run the command from the one you mean (\`cd <dir>\`)` + (takesEntry ? `, or name its entry with \`--entry=<entry>\`` : "") + `, or ${nameOne(slot)}.`),
+      hintOpts(slot)
+    );
+  }
+  const flags = state === void 0 ? void 0 : recordedCredentialFlags(state);
+  const signIn = !ephemeralRecordedElsewhere ? "" : flags !== void 0 ? flags.env ? ` An ephemeral is recorded under ${flags.who} \u2014 set ${ENV_CREDENTIAL_VARS} for that workspace again to reach it.` : flags.signIn ? ` An ephemeral is recorded under ${flags.who}, which no credential file holds \u2014 add it again with ${flags.flags} to reach it.` : ` An ephemeral is recorded under ${flags.who}, and no credential is signed in \u2014 re-run with \`${flags.flags}\` to reach it.` : ` An ephemeral is recorded, but no credential is signed in to look it up \u2014 \`${runLogin()}\` reaches it.`;
+  return new NothingTrackedError(
+    `This project has no backend to default to: it has not deployed to an ephemeral under this credential or to a local engine from this directory.${signIn} Deploy first with ${bothDeploys(cwd)}, or ${nameOne(slot)}.`,
+    hintOpts(slot)
+  );
+}
+function soleNestedEntry(cwd) {
+  if (existsSync(join(backendDirIn(cwd), "index.ts"))) return "";
+  const entries = nestedBackendEntries(cwd, 2);
+  return entries.length === 1 ? ` ${shellQuote(entries[0])}` : "";
+}
+function nestedBackendEntries(cwd, limit = 10) {
+  const entries = [];
+  const walk = (dir, depth) => {
+    if (depth > NESTED_DEPTH || entries.length >= limit) return;
+    let names;
+    try {
+      names = readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    } catch {
+      return;
+    }
+    for (const name of names.sort()) {
+      if (name === "node_modules" || name.startsWith(".")) continue;
+      const child = join(dir, name);
+      const entry = join(backendDirIn(child), "index.ts");
+      if (existsSync(entry)) entries.push(entry);
+      else walk(child, depth + 1);
+    }
+  };
+  walk(cwd, 1);
+  return entries.slice(0, limit).map((entry) => pastePath(relative(cwd, entry)));
+}
+var NESTED_DEPTH = 4;
+function nestedTrackedBackends(cwd) {
+  const found = [];
+  const walk = (dir, depth) => {
+    if (depth > NESTED_DEPTH || found.length >= 10) return;
+    let names;
+    try {
+      names = readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    } catch {
+      return;
+    }
+    for (const name of names.sort()) {
+      if (name === "node_modules" || name.startsWith(".")) continue;
+      const child = join(dir, name);
+      const state = readEphemeralState(child);
+      const records = Object.values(state.environments);
+      if (readDeployed(child) !== void 0 || records.length > 0) {
+        const entry = records.find((r) => typeof r.entry === "string")?.entry;
+        found.push({
+          dir: pastePath(relative(cwd, child)),
+          ...entry === void 0 ? {} : { entry: pastePath(relative(cwd, join(child, entry))) }
+        });
+        continue;
+      }
+      walk(child, depth + 1);
+    }
+  };
+  walk(cwd, 1);
+  return found;
+}
+function noEngineRecorded(slot) {
+  const named = slot === void 0 ? "name one on the command" : slot.spelling.startsWith("--") ? `name one with \`${slot.spelling} local-engine:<name>\`` : `name one: \`xanosdk ${slot.subcommand === void 0 ? slot.command : `${slot.command} ${slot.subcommand}`} local-engine:<name>\``;
+  return new SourceError(
+    `This project last deployed to a local engine, but no engine is recorded for this directory. Run \`xanosdk deploy --local-engine\` to stand one up, or \`xanosdk local-engine list\` to see what is running and ${named}. \`xanosdk deploy${contextFlags()}\` still deploys to an ephemeral.`,
+    "gone",
+    "local-engine"
+  );
+}
+function signedOut(slot, state) {
+  const flags = recordedCredentialFlags(state);
+  return new UsageError(
+    `This project last deployed to an ephemeral, and no credential is signed in to look it up. ` + (flags?.env ? `It is recorded under ${flags.who} \u2014 set ${ENV_CREDENTIAL_VARS} for that workspace again, or ${nameOne(slot)}.` : flags?.signIn ? `It is recorded under ${flags.who}, which no credential file holds \u2014 add it again with ${flags.flags}; or ${nameOne(slot)}.` : flags !== void 0 ? `It is recorded under ${flags.who} \u2014 re-run with \`${flags.flags}\`, or ${nameOne(slot)}.` : `Run \`${runLogin()}\`, or ${nameOne(slot)}.`),
+    hintOpts(slot)
+  );
+}
+function runLogin() {
+  return `xanosdk login${contextFlags()}`;
+}
+function recordedCredentialFlags(state) {
+  const seen = /* @__PURE__ */ new Map();
+  const entries = Object.entries(state.environments);
+  for (const [key, record] of entries) {
+    if (!key.includes("/")) return void 0;
+    const profile2 = key.slice(0, key.indexOf("/"));
+    const env2 = recordedByEnvCredential(record);
+    seen.set(`${env2 ? "
env" : profile2}\0${record.credential_file ?? ""}`, { profile: profile2, file: record.credential_file, env: env2 });
+  }
+  if (seen.size !== 1) return void 0;
+  const [{ profile, file, env }] = [...seen.values()];
+  if (env) return { who: "the environment credential", flags: "", env: true };
+  if (!profileStored(profile, file)) {
+    const [key, record] = entries.length === 1 ? entries[0] : [void 0, void 0];
+    const target = {
+      path: file !== void 0 ? recordedCredentialPath(file) ?? void 0 : void 0,
+      instance: key === void 0 ? void 0 : record?.instance ?? `https://${key.split("/").slice(1, -1).join("/")}`,
+      workspaceId: key?.slice(key.lastIndexOf("/") + 1)
+    };
+    return {
+      who: `profile "${profile}"`,
+      flags: `\`${loginCommand(profile, target)}\` (OAuth), or \`${profileAddCommand(profile, target)}\` (meta API token)`,
+      signIn: true
+    };
+  }
+  return {
+    who: `profile "${profile}"`,
+    flags: `--profile ${profile}${file !== void 0 ? credentialFileFlagFor(file) : ""}`
+  };
+}
+function recordedFilePath(file) {
+  if (file === void 0 || file === "shared") return void 0;
+  return file === "local" ? localAuthFilePath() : file;
+}
+function profileStored(profile, file) {
+  const paths = file === void 0 ? [globalAuthFilePath(), localAuthFilePath()] : [recordedFilePath(file) ?? globalAuthFilePath()];
+  for (const path of paths) {
+    try {
+      const stored = readCredentialFile(path);
+      if (stored !== null && Object.hasOwn(stored.profiles, profile)) return true;
+    } catch {
+      return true;
+    }
+  }
+  return false;
+}
+
+export {
+  memoCredential,
+  selectBackend,
+  resolveBackend,
+  refuseProfileForLocal,
+  readTrackedBackend,
+  NothingTrackedError,
+  nestedBackendEntries
+};
+//# sourceMappingURL=chunk-HHN734BU.js.map

package/dist/chunk-HRVBLCVJ.js

@@ -0,0 +1,243 @@
+import {
+  DEFAULT_DOCUMENTATION,
+  LEGACY_REALTIME
+} from "./chunk-2CMJZDCL.js";
+import {
+  identityNamesByGuid,
+  lockNameForObject,
+  sdkKindName
+} from "./chunk-6MR5TI5V.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}`;
+}
+
+export {
+  omissionSeverity,
+  UNSUPPORTED_SECTIONS,
+  subtractDefaults,
+  isWorkspaceKeyAtDefault,
+  sectionOmission,
+  workspaceKeyOmission,
+  decodedCounts,
+  identityName,
+  reportObjectLabel
+};
+//# sourceMappingURL=chunk-HRVBLCVJ.js.map