@xano/sdk 1.0.5 → 1.0.7

package/dist/{chunk-Z2BRSQ6M.js → chunk-I6XRUU6U.js}

@@ -9,40 +9,47 @@ import {
   staticRetryHint,
   unknownStaticOutcome,
   warnStaticTeardown
-} from "./chunk-4NEBBKOP.js";
+} from "./chunk-RRMH7WMY.js";
+import {
+  objectDigests,
+  syncDigests
+} from "./chunk-JI3BLXWQ.js";
+import {
+  archiveSeedContent
+} from "./chunk-NV37YGOV.js";
 import {
   shownLabel
-} from "./chunk-YSLMMR2U.js";
+} from "./chunk-N3YFCFCO.js";
 import {
   confirm,
   needsConfirmation
-} from "./chunk-AESE434J.js";
-import {
-  landedRecordFor,
-  landingLockPath,
-  recordForeignLanding,
-  recordLanding
-} from "./chunk-ES5A66IH.js";
+} from "./chunk-7M6JP3FS.js";
 import {
   assertStorageModesKept,
   discloseCanonicalMoves,
   movesClause,
   storageChangesPayload
-} from "./chunk-BBPAXOU6.js";
+} from "./chunk-BSVQEKHO.js";
 import {
   listTables,
   tableRowCounter,
   tableRowIds
-} from "./chunk-GMVW6ZZK.js";
+} from "./chunk-H2K4GFUS.js";
+import {
+  landedRecordFor,
+  landingLockPath,
+  recordForeignLanding,
+  recordLanding
+} from "./chunk-2YER2J47.js";
+import {
+  recordSync
+} from "./chunk-VAGSKUWC.js";
 import {
   XANOSDK_IMPORT_CONFLICT_CODE,
   XANOSDK_IMPORT_UNIQUENESS_CODE,
   XanoSdkImportRefusal,
   xanosdkImport
-} from "./chunk-QOLOQ35F.js";
-import {
-  archiveSeedContent
-} from "./chunk-PIPIA7K7.js";
+} from "./chunk-567KK6XF.js";
 import {
   encodeWorkspaceArchive
 } from "./chunk-3DRXWLJ5.js";
@@ -55,7 +62,7 @@ import {
   listBranchListing,
   liveBranchLabel,
   setLiveBranch
-} from "./chunk-5RLAF6RL.js";
+} from "./chunk-M2C54ZBC.js";
 import {
   compareToLive,
   envValuesOf,
@@ -66,50 +73,54 @@ import {
   sharedSchemaChanges,
   storedColumnsAfter,
   uniqueIndexLabels
-} from "./chunk-SF2B7MZK.js";
+} from "./chunk-IYXL5NYU.js";
 import {
   assertBundleFile,
   assertBundleInput,
   loadBundleText,
   resolveLockPath
-} from "./chunk-S5KQIFKJ.js";
+} from "./chunk-DG3APBUJ.js";
 import {
   LookupFailedError,
   isUnansweredLookup,
   unansweredCause
-} from "./chunk-JXKO6JT7.js";
+} from "./chunk-TWVUYS63.js";
 import {
   isSignatureRefusal
-} from "./chunk-5XVBT6CQ.js";
+} from "./chunk-MBL7CXJ7.js";
 import {
   getAccessToken
-} from "./chunk-CJ76PSJT.js";
+} from "./chunk-YH2JVJAO.js";
+import {
+  readLockFile
+} from "./chunk-CJDPSCMX.js";
 import {
   ephemeralLandedOn
-} from "./chunk-4QBGE3EO.js";
+} from "./chunk-ORGNLQN6.js";
 import {
   pipedYes,
   retryCommand,
   withheldNote
-} from "./chunk-Z4VN347O.js";
+} from "./chunk-UYFUIHH3.js";
 import {
   contextFlags
-} from "./chunk-G57RYMKB.js";
+} from "./chunk-3FRGNBOC.js";
 import {
   backendDirIn
-} from "./chunk-AGD7F7YI.js";
+} from "./chunk-5SCPRXFB.js";
 import {
   shellWord
 } from "./chunk-FWD7AL6N.js";
+import {
+  TransportError,
+  isTimeoutError
+} from "./chunk-L6HZ67P6.js";
 import {
   describeWrite
 } from "./chunk-4KHEMC32.js";
 import {
   seedRowsByTableGuid
-} from "./chunk-Y76ERHLK.js";
-import {
-  readLockFile
-} from "./chunk-SQPIECXD.js";
+} from "./chunk-FDTET7FZ.js";
 import {
   destinationKey,
   groupNames,
@@ -118,11 +129,7 @@ import {
   landedKeyForRow,
   storedColumnsOf,
   withStoredColumns
-} from "./chunk-5YBNXNKU.js";
-import {
-  TransportError,
-  isTimeoutError
-} from "./chunk-HLQH3AXB.js";
+} from "./chunk-MFWF2NZJ.js";
 import {
   CliError,
   EXIT_OUTCOME_UNKNOWN,
@@ -142,11 +149,11 @@ import {
   warn,
   writeJson,
   writeTargetPayload
-} from "./chunk-XNZURZ7T.js";
+} from "./chunk-CH23ONYG.js";
 import {
   calcSignatureJson,
   signatureHolds
-} from "./chunk-XJU6UAFV.js";
+} from "./chunk-7FIMUFBP.js";
 import {
   safeNames
 } from "./chunk-GSGDWJB5.js";
@@ -157,7 +164,7 @@ import {
   lockKey,
   lockNameForObject,
   sdkKindName2 as sdkKindName
-} from "./chunk-OKNE3TWU.js";
+} from "./chunk-5KJBWIDZ.js";
 import {
   shellQuote
 } from "./chunk-5ZSO4T2G.js";
@@ -630,7 +637,7 @@ function isTransientReadFailure(err) {
   return isUnansweredLookup(err);
 }
 async function readLive(auth, dest, branch) {
-  const { exportWorkspaceBundle } = await import("./workspace-export-3XTVGQVM.js");
+  const { exportWorkspaceBundle } = await import("./workspace-export-BIKAYHWJ.js");
   let failure;
   for (let attempt = 0; attempt <= LIVE_READ_RETRY_PAUSES_MS.length; attempt++) {
     try {
@@ -737,7 +744,7 @@ function targetIsEmpty(live) {
 async function convergedWithLive(live, req, outgoingBundle, pinned) {
   if (live === void 0 || req.mode !== "merge") return false;
   if (req.records === true || req.truncate === true) return false;
-  const { compareToLive: compareToLive2 } = await import("./live-diff-IM4W3ELT.js");
+  const { compareToLive: compareToLive2 } = await import("./live-diff-5E2BQWQ7.js");
   let result;
   try {
     result = compareToLive2(
@@ -758,7 +765,7 @@ async function convergedWithLive(live, req, outgoingBundle, pinned) {
 async function unchangedWithLive(live, req, outgoingBundle, pinned) {
   if (live === void 0 || req.mode !== "merge") return void 0;
   if (req.records === true || req.truncate === true) return void 0;
-  const { compareToLive: compareToLive2, declaredLabels, payloadOf: payloadOf2, SETTINGS_LABEL } = await import("./live-diff-IM4W3ELT.js");
+  const { compareToLive: compareToLive2, declaredLabels, payloadOf: payloadOf2, SETTINGS_LABEL } = await import("./live-diff-5E2BQWQ7.js");
   try {
     const outgoing = JSON.parse(outgoingBundle);
     const result = compareToLive2(outgoing, live, new Set(pinned.map((p) => `${p.payloadKey}:${p.name}`)), {
@@ -786,7 +793,7 @@ function markUnchanged(presented, unchanged, noun) {
 }
 var REPLACE_DROPS = "which deletes every table's rows there (only seed rows come back)";
 async function replaceCommandHint(args) {
-  const { retryCommand: retryCommand2, withheldNote: withheldNote2 } = await import("./deploy-command-HJZNYCUY.js");
+  const { retryCommand: retryCommand2, withheldNote: withheldNote2 } = await import("./deploy-command-OEVEE6UG.js");
   const valued = /* @__PURE__ */ new Set(["--branch", "--backup-branch", "--expect-live"]);
   const dropped = /* @__PURE__ */ new Set(["--prune", "--reset-data", "--seed", "--set-live", "--dry-run", "--replace", "--yes", "-y"]);
   const argv = [];
@@ -817,7 +824,7 @@ function landingTableFields(losses) {
   };
 }
 async function warnAboutLiveLosses(live, req, outgoingBundle, setWhere = "workspace", fromBundle = false, replaceHint = "`xanosdk deploy <source> --to <destination> --replace`.", noun = "workspace", failure, stored) {
-  const { NO_TABLE_EFFECTS, tableEffectsOf, discloseTableEffects, tableEffectFields, alteringChanges, droppedAndAdded } = await import("./plan-disclosure-QGL5UYQR.js");
+  const { NO_TABLE_EFFECTS, tableEffectsOf, discloseTableEffects, tableEffectFields, alteringChanges, droppedAndAdded } = await import("./plan-disclosure-JR52DWXN.js");
   const none = {
     ...tableEffectFields(NO_TABLE_EFFECTS),
     renamedTables: [],
@@ -836,7 +843,7 @@ async function warnAboutLiveLosses(live, req, outgoingBundle, setWhere = "worksp
     blank();
     return none;
   }
-  const { diffAgainstLive, tableAdditions } = await import("./live-diff-IM4W3ELT.js");
+  const { diffAgainstLive, tableAdditions } = await import("./live-diff-5E2BQWQ7.js");
   let diff;
   let additions;
   try {
@@ -1551,7 +1558,7 @@ async function unrecordedTableRenames(args, bundle, live, plan, classified) {
   const held = guidsOf(live);
   const codePinned = codePinnedTables(outgoingDoc, lock, classified);
   const { orphanFixUps } = await import("./cli.js");
-  const { setGuidRemedy, clearReplacedCommand } = await import("./keep-data-merge-GUGF7MVZ.js");
+  const { setGuidRemedy, clearReplacedCommand } = await import("./keep-data-merge-TDJOIAVT.js");
   const run = (line) => (line ?? "").replace(/^(renamed|deleted)\? run: /, "");
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -1595,7 +1602,7 @@ async function unrecordedTableRenames(args, bundle, live, plan, classified) {
   return out;
 }
 async function pendingRenameRefusal(frame, pending, prune, branch) {
-  const { pendingRenameLines, pendingRenameFollowUp, pendingRenameDetail, sameNameRepin } = await import("./keep-data-merge-GUGF7MVZ.js");
+  const { pendingRenameLines, pendingRenameFollowUp, pendingRenameDetail, sameNameRepin } = await import("./keep-data-merge-TDJOIAVT.js");
   const one = pending.length === 1;
   const lines = pending.flatMap(
     (p) => pendingRenameLines(
@@ -2051,7 +2058,7 @@ async function runReleaseCommand(args, dest, opts = {}) {
   assertBundleFile(args, { command: "deploy" });
   const auth = opts.auth ?? await getAccessToken(args);
   const withSeed = req.mode === "replace" || req.records === true;
-  const { discoverToolchainPlugins } = await import("./toolchain-modules-FD5ANV2U.js");
+  const { discoverToolchainPlugins } = await import("./toolchain-modules-OTNSKK52.js");
   const toolchain = await discoverToolchainPlugins(process.cwd(), { frozen: args.frozenLock === true });
   const loaded = await loadBundleText(
     args.dryRun ? { ...args, lockReadOnly: true } : args,
@@ -2077,15 +2084,15 @@ async function runReleaseCommand(args, dest, opts = {}) {
     });
   };
   if (!args.dryRun && args.file !== void 0) {
-    const { ignoreBackendSecretFilesRead } = await import("./deploy-command-HJZNYCUY.js");
+    const { ignoreBackendSecretFilesRead } = await import("./deploy-command-OEVEE6UG.js");
     await ignoreBackendSecretFilesRead(args);
   }
   if (args.static !== void 0) {
-    const { assertNoSeedLeaks } = await import("./deploy-command-HJZNYCUY.js");
+    const { assertNoSeedLeaks } = await import("./deploy-command-OEVEE6UG.js");
     await assertNoSeedLeaks(args.static, nonPublicSeedValues);
   }
   {
-    const { runBundleHooks } = await import("./toolchain-hooks-QVUZ6HZ4.js");
+    const { runBundleHooks } = await import("./toolchain-hooks-7PWCFLSU.js");
     const { readVersion } = await import("./cli.js");
     await runBundleHooks(
       toolchain.loaded,
@@ -2191,8 +2198,8 @@ async function runReleaseCommand(args, dest, opts = {}) {
     pinned: pinned.map((p) => p.guid).filter((g) => g !== void 0)
   }).catch(async (err) => {
     if (err instanceof XanoSdkImportRefusal && err.retryable) {
-      const { importInProgressError } = await import("./keep-data-merge-GUGF7MVZ.js");
-      const { retryCommand: retryCommand2, withheldNote: withheldNote2 } = await import("./retry-command-JRGMZZAC.js");
+      const { importInProgressError } = await import("./keep-data-merge-TDJOIAVT.js");
+      const { retryCommand: retryCommand2, withheldNote: withheldNote2 } = await import("./retry-command-GL5HCMVB.js");
       const retry = retryCommand2(args);
       throw importInProgressError(
         describeWriteTarget({ base: destBase, workspaceId, label: destShownLabel }),
@@ -2312,10 +2319,10 @@ async function runReleaseCommand(args, dest, opts = {}) {
   }
   const dryRunUpToDate = req.branch === void 0 && (plan.operations.length === 0 || converged);
   if (req.mode === "merge" && destIsTenant && live !== void 0 && !dryRunUpToDate) {
-    const { liveTableTriggers, tableTriggerMergeError } = await import("./keep-data-merge-GUGF7MVZ.js");
+    const { liveTableTriggers, tableTriggerMergeError } = await import("./keep-data-merge-TDJOIAVT.js");
     const triggers = liveTableTriggers(live);
     if (triggers.length > 0) {
-      const { retryCommand: retryCommand2, withheldNote: withheldNote2 } = await import("./retry-command-JRGMZZAC.js");
+      const { retryCommand: retryCommand2, withheldNote: withheldNote2 } = await import("./retry-command-GL5HCMVB.js");
       const replace = retryCommand2(args, { add: ["--replace"], drop: ["--prune", "--yes", "-y"] });
       throw tableTriggerMergeError(destNoun, triggers, {
         command: replace.command,
@@ -2324,7 +2331,7 @@ async function runReleaseCommand(args, dest, opts = {}) {
     }
   }
   if (req.mode === "merge" && live !== void 0 && !dryRunUpToDate && losses.storageChanges.length > 0) {
-    const { retryCommand: retryCommand2, withheldNote: withheldNote2 } = await import("./retry-command-JRGMZZAC.js");
+    const { retryCommand: retryCommand2, withheldNote: withheldNote2 } = await import("./retry-command-GL5HCMVB.js");
     const replace = retryCommand2(args, { add: ["--replace"], drop: ["--prune", "--yes", "-y"] });
     await assertStorageModesKept(losses.storageChanges, tableRowCounter(auth, { workspaceId, base: destBase }), {
       target: destNoun,
@@ -2356,6 +2363,7 @@ async function runReleaseCommand(args, dest, opts = {}) {
         // Always present; a dry run records nothing — what it would land is
         // not landed, and the record is what a prune deletes by.
         landingRecord: null,
+        syncBaseline: null,
         workspaceId,
         destination: destinationPayload(resolvedDest, dest, auth),
         // The verdict the real run would reach, said up front: a wrapper
@@ -2407,7 +2415,7 @@ async function runReleaseCommand(args, dest, opts = {}) {
     assertLiveWorkspaceWasRead(live, destNoun, scopeBranch, liveRead.failure, liveKind);
     reportPlannedCanonicalMoves(canonicalMoves, "will", movesWhen);
     if (req.branch !== void 0 && args.setLive && !args.yes && process.stdin.isTTY !== true) {
-      const { yesRerun } = await import("./retry-command-JRGMZZAC.js");
+      const { yesRerun } = await import("./retry-command-GL5HCMVB.js");
       const { rerun, note } = yesRerun(args, "deploy");
       throw needsConfirmation(
         `Make "${req.branch}" the live branch?${movesClause(canonicalMoves)} (or drop --set-live to stage it)`,
@@ -2444,9 +2452,10 @@ async function runReleaseCommand(args, dest, opts = {}) {
         workspaceRename: losses.workspaceRename ?? null,
         workspaceSettingsNotApplied: withheldSettings,
         landingRecord: null,
+        syncBaseline: null,
         ...seeded.length > 0 ? { seedRows: seeded } : {}
       });
-      const { yesRerun } = await import("./retry-command-JRGMZZAC.js");
+      const { yesRerun } = await import("./retry-command-GL5HCMVB.js");
       const { rerun, note } = yesRerun(args, "deploy");
       const ok = await confirm(`Apply this plan to ${destNoun}?${seedOverwriteClause(seeded)}${movesClause(canonicalMoves, movesWhen === void 0 ? "It" : "Once live, it")}`, {
         flag: "--yes",
@@ -2493,7 +2502,7 @@ Retry, or drop \`--backup-branch\` to deploy without one.`,
       );
     } catch (err) {
       if (err instanceof XanoSdkImportRefusal) {
-        const { retryCommand: retryCommand2, withheldNote: withheldNote2 } = await import("./retry-command-JRGMZZAC.js");
+        const { retryCommand: retryCommand2, withheldNote: withheldNote2 } = await import("./retry-command-GL5HCMVB.js");
         const retry = retryCommand2(args);
         reportApplyRefusal(
           err,
@@ -2584,8 +2593,10 @@ Retry, or drop \`--backup-branch\` to deploy without one.`,
     priorStored,
     req.mode === "replace" ? "rebuild" : "merge"
   );
-  const landingRecord = landingDest === void 0 ? null : args.file === void 0 && args.lockPath === void 0 ? recordForeignLanding({
-    lockPath: landingLockPath(args),
+  const sentForeign = args.file === void 0 && args.lockPath === void 0;
+  const landingLock = sentForeign ? landingLockPath(args) : landingLockPath(args, { entryFile: args.file, fromProject: false });
+  const landingRecord = landingDest === void 0 ? null : sentForeign ? recordForeignLanding({
+    lockPath: landingLock,
     instance: auth.instance,
     dest: landingDest,
     bundle: parsedOrUndefined(bundle),
@@ -2593,7 +2604,7 @@ Retry, or drop \`--backup-branch\` to deploy without one.`,
     removed: pruned,
     ...storedAfter !== void 0 ? { stored: storedAfter } : {}
   }) : recordLanding({
-    lockPath: landingLockPath(args, { entryFile: args.file, fromProject: false }),
+    lockPath: landingLock,
     instance: auth.instance,
     dest: landingDest,
     update: {
@@ -2602,6 +2613,21 @@ Retry, or drop \`--backup-branch\` to deploy without one.`,
       removed: pruned
     }
   });
+  const syncBaseline = landingDest?.kind !== "workspace" ? null : await recordDeploySync();
+  async function recordDeploySync() {
+    if (landingDest?.kind !== "workspace" || landingLock === void 0 || !existsSync(landingLock)) return null;
+    const sent = parsedOrUndefined(bundle);
+    const branch = req.mode === "replace" ? DEFAULT_BRANCH_LABEL : applyResponse?.branch ?? preview.branch;
+    const stored = upToDate ? live : (await readLive(auth, resolvedDest, req.branch !== void 0 ? branch : void 0)).live;
+    const digests = stored !== void 0 ? syncDigests({ held: [stored], heldLabels: new Set(Object.keys(objectDigests(sent, "carried"))) }) : syncDigests({ held: [sent], others: req.mode === "replace" ? [] : [live] });
+    return recordSync({
+      lockPath: landingLock,
+      target: { instance: auth.instance, workspaceId: landingDest.workspaceId, branch },
+      digests,
+      by: "deploy",
+      complete: stored !== void 0 || req.mode === "replace" || live !== void 0
+    });
+  }
   const servedDifferences = canonicalDifferences((applyResponse ?? preview).canonicals);
   reportCanonicalDifferences(servedDifferences, planContext);
   if (!args.dryRun) opts.afterLanding?.(parsedOrUndefined(bundle));
@@ -2615,6 +2641,7 @@ Retry, or drop \`--backup-branch\` to deploy without one.`,
     dryRun: false,
     declined: false,
     landingRecord,
+    syncBaseline,
     workspaceId,
     plan: planForOutput(plan, presented, destIsTenant, converged),
     conflicts: conflictsForOutput((applyResponse ?? preview).conflicts, planContext),
@@ -2672,7 +2699,7 @@ Retry, or drop \`--backup-branch\` to deploy without one.`,
       if (isMachineOutput(args)) writeJson(summary);
       assertStaticMatchesServedUrls(servedDifferences, planContext);
     }
-    const { buildStaticEnv, deployStaticTo } = await import("./deploy-command-HJZNYCUY.js");
+    const { buildStaticEnv, deployStaticTo } = await import("./deploy-command-OEVEE6UG.js");
     const env = buildStaticEnv(destBase, args.staticEnv);
     const explicit = Object.keys(args.staticEnv).length > 0;
     const to = dest?.kind === "tenant" ? `${dest.type === "ephemeral" ? "ephemeral" : "tenant"}:${dest.name ?? ""}` : "workspace";
@@ -2724,14 +2751,14 @@ function setLiveRollback(previous, args) {
 async function assertReleaseIdentitiesFree(args, auth, opts) {
   const tenant = opts.tenant;
   const target = tenant === void 0 ? { baseUrl: auth.instance, workspaceId: auth.workspaceId } : { baseUrl: tenant.base, workspaceId: tenant.workspaceId };
-  const { detectXanoSdkImportRoute } = await import("./xanosdk-import-E3WSIYUE.js");
+  const { detectXanoSdkImportRoute } = await import("./xanosdk-import-S7A3CVBN.js");
   let capable;
   try {
     capable = await detectXanoSdkImportRoute(auth, target);
   } catch (err) {
     if (err?.status === 501) capable = false;
     else {
-      const { unreachableProbeError } = await import("./keep-data-merge-GUGF7MVZ.js");
+      const { unreachableProbeError } = await import("./keep-data-merge-TDJOIAVT.js");
       const retry = retryCommand(args, {
         add: pipedYes(args) === "" ? [] : ["--yes"],
         command: [opts.verb, ...args.positionals.map(shellWord)].join(" ")
@@ -2820,4 +2847,4 @@ export {
   setLiveRollback,
   assertReleaseIdentitiesFree
 };
-//# sourceMappingURL=chunk-Z2BRSQ6M.js.map
+//# sourceMappingURL=chunk-I6XRUU6U.js.map

package/dist/chunk-IPNN2KRW.js

@@ -0,0 +1,257 @@
+import {
+  MANIFEST_HEADER,
+  ROUTES_MANIFEST_BASENAME,
+  RouteManifestError
+} from "./chunk-LBJA7IEM.js";
+import {
+  byCodeUnit
+} from "./chunk-WAVNUTMT.js";
+import {
+  blockPackages,
+  composeBlock,
+  findBlock
+} from "./chunk-LJM5CIY4.js";
+import {
+  UsageError,
+  detail,
+  info,
+  warn
+} from "./chunk-CH23ONYG.js";
+
+// src/emit/routes-manifest-modules.ts
+var MODULE_DIALECT = {
+  begin: (pkg) => `// xanosdk:begin ${pkg}`,
+  end: (pkg) => `// xanosdk:end ${pkg}`,
+  stamp: (version) => `// xanosdk:version ${version} - generated; edits inside this block are overwritten`,
+  parseStamp: (block) => /^\/\/ xanosdk:version (\S+)/m.exec(block)?.[1] ?? null
+};
+var IMPORTS_LINE = "// xanosdk:imports ";
+var moduleSpec = (pkg) => ({ dialect: MODULE_DIALECT, pkg, file: ROUTES_MANIFEST_BASENAME });
+var BARE_SPECIFIER = /^(?:@[a-z0-9~][\w.~-]*\/)?[a-z0-9~][\w.~-]*(?:\/[\w.~@-]+)*$/i;
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+var STATIC_IMPORT = /^import(?:\s+type)?(?:\s*["'{*]|\s+[A-Za-z_$][\w$]*\s*(?:,|from\b))/;
+var RE_EXPORT = /^[ \t]*export\s+(?:type\s+)?(?:\*(?:\s+as\s+[A-Za-z_$][\w$]*)?|\{[^}]*\})\s*from\s*["']/m;
+var SDK_LOAD = /\b(?:import|require)\s*\(\s*["'`]@xano\/sdk(?:\/|["'`])/;
+function checkModuleSection(pkg, section) {
+  const refuse = (why) => {
+    throw new RouteManifestError(`${pkg}: its routes.gen.ts section ${why}`);
+  };
+  if (section === null || typeof section !== "object") return refuse("is not an object with a `source` string.");
+  if (typeof section.then === "function") {
+    return refuse("is a Promise. `routesManifest` must be synchronous: every writer of the file has to produce the same bytes, and the decode paths write it synchronously.");
+  }
+  const { source, imports } = section;
+  if (typeof source !== "string") return refuse("has no `source` string.");
+  const lines = source.split(/\r?\n/);
+  const trimmed = lines.map((line) => line.trim());
+  const markers = [MODULE_DIALECT.begin("").trim(), MODULE_DIALECT.end("").trim()];
+  const forged = trimmed.find((line) => markers.some((marker) => line.startsWith(marker)));
+  if (forged !== void 0) {
+    return refuse(`has a line that spells a block marker (${forged}); the file's blocks are found by counting them.`);
+  }
+  const first = lines.find((line) => line.trim() !== "");
+  if (first?.startsWith(IMPORTS_LINE)) {
+    return refuse(`starts with a line that spells the block's imports line (${first.trim()}); declare imports in \`imports\`.`);
+  }
+  const written = trimmed.find((line) => STATIC_IMPORT.test(line) || SDK_LOAD.test(line)) ?? RE_EXPORT.exec(source)?.[0].trim().split(/\r?\n/)[0];
+  if (written !== void 0) {
+    return refuse(`writes an import in its source (${written}); declare imports in \`imports\`.`);
+  }
+  if (imports !== void 0 && !Array.isArray(imports)) return refuse("has `imports` that is not an array.");
+  const merged = /* @__PURE__ */ new Map();
+  for (const entry of imports ?? []) {
+    const { from, names } = entry ?? {};
+    if (typeof from !== "string") return refuse("declares an import with no `from` string.");
+    if (from === "@xano/sdk" || from.startsWith("@xano/sdk/")) {
+      return refuse(
+        `imports from ${JSON.stringify(from)}. The manifest exists so a frontend can skip the SDK runtime; a module section may not import it.`
+      );
+    }
+    if (!BARE_SPECIFIER.test(from) || from.split("/").some((part) => part === "." || part === "..")) {
+      return refuse(
+        `imports from ${JSON.stringify(from)}, which is not a bare package specifier. A relative or absolute path resolves against wherever the file is written, and a protocol is not a package the project depends on.`
+      );
+    }
+    if (!Array.isArray(names) || names.length === 0) return refuse(`imports nothing by name from ${JSON.stringify(from)}.`);
+    for (const name of names) {
+      if (typeof name !== "string" || !IDENTIFIER.test(name)) {
+        return refuse(`imports ${JSON.stringify(name)} from ${JSON.stringify(from)}, which is not a plain identifier.`);
+      }
+      merged.set(from, (merged.get(from) ?? /* @__PURE__ */ new Set()).add(name));
+    }
+  }
+  return [...merged].sort(([a], [b]) => byCodeUnit(a, b)).map(([from, names]) => ({ from, names: [...names].sort(byCodeUnit) }));
+}
+function composeRoutesManifest(core, modules) {
+  if (!core.startsWith(MANIFEST_HEADER)) {
+    throw new RouteManifestError("composeRoutesManifest: `core` is not a rendered route manifest.");
+  }
+  const imports = /* @__PURE__ */ new Map();
+  const blocks = [];
+  let previous;
+  for (const { pkg, version, section } of [...modules].sort((a, b) => byCodeUnit(a.pkg, b.pkg))) {
+    if (pkg === previous) {
+      throw new RouteManifestError(`${pkg}: two routes.gen.ts sections for one module; a module contributes one.`);
+    }
+    previous = pkg;
+    const own = checkModuleSection(pkg, section);
+    if (section.source.trim() === "") continue;
+    for (const { from, names } of own) {
+      for (const name of names) imports.set(from, (imports.get(from) ?? /* @__PURE__ */ new Set()).add(name));
+    }
+    const lines = own.length > 0 ? [`${IMPORTS_LINE}${JSON.stringify(own)}`, section.source] : [section.source];
+    try {
+      blocks.push(composeBlock(moduleSpec(pkg), lines, version));
+    } catch (error) {
+      throw new RouteManifestError(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (blocks.length === 0) return core;
+  const importLines = [...imports].sort(([a], [b]) => byCodeUnit(a, b)).map(([from, names]) => `import { ${[...names].sort(byCodeUnit).join(", ")} } from ${JSON.stringify(from)};
+`);
+  return `${MANIFEST_HEADER}${importLines.join("")}${core.slice(MANIFEST_HEADER.length)}${blocks.map((b) => `
+${b}
+`).join("")}`;
+}
+function parseModuleSections(text, only) {
+  return blockPackages(text, MODULE_DIALECT).filter((pkg) => only === void 0 || only.has(pkg)).sort(byCodeUnit).map((pkg) => {
+    const fail = (why) => {
+      throw new RouteManifestError(
+        `${pkg}: its block in ${ROUTES_MANIFEST_BASENAME} ${why} Repair or delete the block by hand, then regenerate the file.`
+      );
+    };
+    let span;
+    try {
+      span = findBlock(text, moduleSpec(pkg));
+    } catch (error) {
+      return fail(`cannot be read: ${error instanceof Error ? error.message : String(error)}.`);
+    }
+    const lines = span.text.split(/\r?\n/);
+    const version = MODULE_DIALECT.parseStamp(lines[1] ?? "");
+    if (version === null || lines[2] !== "") return fail("has no version stamp under its begin marker.");
+    let body = lines.slice(3, -1);
+    let imports;
+    if (body[0]?.startsWith(IMPORTS_LINE)) {
+      try {
+        imports = JSON.parse(body[0].slice(IMPORTS_LINE.length));
+      } catch {
+        return fail("has an imports line that is not valid JSON.");
+      }
+      body = body.slice(1);
+    }
+    const section = { ...imports === void 0 ? {} : { imports }, source: body.join("\n") };
+    checkModuleSection(pkg, section);
+    return { pkg, version, section };
+  });
+}
+
+// src/emit/toolchain-hooks.ts
+function redactEnvValues(payload) {
+  const env = payload["env"];
+  if (!Array.isArray(env)) return payload;
+  return {
+    ...payload,
+    env: env.map(
+      (entry) => typeof entry === "object" && entry !== null && "value" in entry ? { ...entry, value: "" } : entry
+    )
+  };
+}
+function report(pkg, result) {
+  if (result.message !== void 0 && result.message !== "") {
+    if (result.failed === true) warn(`${pkg} \u2014 ${result.message}`, "toolchain.failed");
+    else info(result.message);
+  }
+  for (const line of result.warnings ?? []) detail(line);
+}
+function handleThrow(pkg, error, frozen) {
+  const why = error instanceof Error ? error.message : String(error);
+  if (frozen) {
+    throw new UsageError(
+      `${pkg} failed while checking this bundle, so whatever it verifies was not verified \u2014 and this run was asked to verify, not to write:
+  ${why}`
+    );
+  }
+  warn(`${pkg} failed and was skipped.`, "toolchain.failed", [why]);
+}
+async function fireOnBundle(plugins, ctx) {
+  let failed = false;
+  const bundle = { ...ctx.bundle, payload: redactEnvValues(ctx.bundle.payload) };
+  for (const { pkg, plugin, config } of plugins) {
+    if (plugin.onBundle === void 0) continue;
+    try {
+      const result = await plugin.onBundle({ ...ctx, bundle, config });
+      report(pkg, result);
+      if (result.failed === true) failed = true;
+    } catch (error) {
+      handleThrow(pkg, error, ctx.frozen);
+    }
+  }
+  return { failed };
+}
+async function fireOnPreflight(plugins, ctx) {
+  let failed = false;
+  const payloads = {
+    exportedPayload: redactEnvValues(ctx.exportedPayload),
+    remappedPayload: redactEnvValues(ctx.remappedPayload)
+  };
+  for (const { pkg, plugin, config } of plugins) {
+    if (plugin.onPreflight === void 0) continue;
+    try {
+      const result = await plugin.onPreflight({ ...ctx, ...payloads, config });
+      report(pkg, result);
+      if (result.failed === true) failed = true;
+    } catch (error) {
+      const why = error instanceof Error ? error.message : String(error);
+      warn(`${pkg} could not complete its check.`, "toolchain.failed", [why]);
+      failed = true;
+    }
+  }
+  return { failed };
+}
+async function runBundleHooks(plugins, ctx, consequence) {
+  if (plugins.length === 0) return;
+  const outcome = await fireOnBundle(plugins, ctx);
+  if (outcome.failed) {
+    throw new UsageError(
+      `A toolchain module reported that its check did not pass${consequence}. See the report above.`
+    );
+  }
+}
+function fireRoutesManifest(plugins, ctx) {
+  const results = [];
+  for (const { pkg, version, plugin, config } of [...plugins].sort((a, b) => byCodeUnit(a.pkg, b.pkg))) {
+    if (plugin.routesManifest === void 0) continue;
+    try {
+      const section = plugin.routesManifest({ ...ctx, config });
+      if (typeof section?.then === "function") {
+        Promise.resolve(section).catch(() => {
+        });
+      }
+      const imports = checkModuleSection(pkg, section);
+      results.push({
+        kind: "section",
+        pkg,
+        version,
+        section: { ...imports.length > 0 ? { imports } : {}, source: section.source }
+      });
+    } catch (error) {
+      results.push({ kind: "failed", pkg, version, why: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return results;
+}
+function anyDeclares(plugins, hook) {
+  return plugins.some((p) => p.plugin[hook] !== void 0);
+}
+
+export {
+  composeRoutesManifest,
+  parseModuleSections,
+  redactEnvValues,
+  fireOnBundle,
+  fireOnPreflight,
+  runBundleHooks,
+  fireRoutesManifest,
+  anyDeclares
+};
+//# sourceMappingURL=chunk-IPNN2KRW.js.map