@xano/sdk 1.0.4 → 1.0.6

package/dist/{chunk-2B22WWKL.js → chunk-JFBRXRJD.js}

@@ -1,26 +1,22 @@
 import {
   createOperation,
   runOperation
-} from "./chunk-PML67X22.js";
+} from "./chunk-LAOMN6QQ.js";
 import {
   fetchWorkspaceBundle
-} from "./chunk-ESZ2FF57.js";
+} from "./chunk-RIN4YY34.js";
 import {
   assertReleaseIdentitiesFree,
   pinnedCanonicalGuids,
   setLiveRollback
-} from "./chunk-45YPFB7B.js";
+} from "./chunk-GLY552SI.js";
 import {
   liveBranchMismatch,
   liveMismatch
-} from "./chunk-OGBMUST4.js";
+} from "./chunk-GHQ4BVI4.js";
 import {
   confirm
-} from "./chunk-4APOHK7Y.js";
-import {
-  landingLockPath,
-  recordForeignLanding
-} from "./chunk-C4FHQA7R.js";
+} from "./chunk-JXVJGF3Y.js";
 import {
   CONSTRAINT_FIX,
   CONSTRAINT_PHRASE,
@@ -39,24 +35,35 @@ import {
   releaseTableEffects,
   renameHint,
   tableEffectsPayload
-} from "./chunk-5T2CTWTB.js";
+} from "./chunk-CHINR7WD.js";
 import {
   tableRowCounter
-} from "./chunk-MNVDVR3M.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-VRVKNY4A.js";
+} from "./chunk-Z4ZGTCCD.js";
 import {
   exportWorkspaceBundle
-} from "./chunk-QV3GXQRE.js";
+} from "./chunk-GOLFAEUV.js";
 import {
   decodeWorkspaceArchive
 } from "./chunk-3DRXWLJ5.js";
 import {
   SettledWriteFailure,
   classifyFailure
-} from "./chunk-O5V3YH5P.js";
+} from "./chunk-JRVQ7M7W.js";
 import {
   BranchTakenError,
   assertBranchAbsent,
@@ -67,16 +74,16 @@ import {
   listBranchListing,
   liveBranchLabel,
   setLiveBranch
-} from "./chunk-E65QIWOO.js";
+} from "./chunk-NPODGBVJ.js";
 import {
   envValuesOf
-} from "./chunk-HMLGM2MW.js";
+} from "./chunk-IYXL5NYU.js";
 import {
   assertOneName
-} from "./chunk-DIG3NITC.js";
+} from "./chunk-WBH4KJWM.js";
 import {
   resolveSource
-} from "./chunk-2AUV6NXK.js";
+} from "./chunk-3II44CUJ.js";
 import {
   ReleaseHttpError,
   UNPROMOTABLE_RELEASE_PARTS,
@@ -85,27 +92,27 @@ import {
   promotableReleaseName,
   unpromotableReleasePart,
   untenantDeployableReleasePart
-} from "./chunk-A6QTTJUI.js";
+} from "./chunk-GWTFI3GA.js";
 import {
   getAccessToken
-} from "./chunk-LUTMOHOW.js";
+} from "./chunk-YGLMRH5U.js";
 import {
   pipedYes,
   retryCommand,
   withheldNote
-} from "./chunk-FMOEVAGT.js";
+} from "./chunk-6X3MY2JP.js";
 import {
   contextFlags
-} from "./chunk-SEUCZZCP.js";
+} from "./chunk-N5I37JFB.js";
 import {
   shellWord
 } from "./chunk-FWD7AL6N.js";
 import {
   readLockFile
-} from "./chunk-VD32O6KZ.js";
+} from "./chunk-CJDPSCMX.js";
 import {
   withoutReadAftermath
-} from "./chunk-MN2PB6WB.js";
+} from "./chunk-YR2I5HGE.js";
 import {
   CliError,
   LocalFileNotFoundError,
@@ -123,19 +130,19 @@ import {
   success,
   warn,
   withoutUrls
-} from "./chunk-SBR2WZXG.js";
+} from "./chunk-D7BUMOKU.js";
 import {
   envNamesRead
-} from "./chunk-OPG4DYX2.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-OOGXZL7Z.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-2S7E3SBZ.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) {
@@ -407,7 +415,7 @@ async function seedRowRemedies(release, tables, flags, named) {
   const resettable = seededHere === void 0 ? [] : tables.filter((t) => seededHere.has(t.name) && t.guid !== void 0);
   const r = shellWord(release.name);
   const before = [
-    `The release's rows land with a deploy of the release: \`xanosdk deploy release:${r}${flags}\` on this project's ephemeral, or \`xanosdk tenant deploy <tenant> ${r}${flags}\` on a tenant.`
+    `The release's rows land with a deploy of the release: \`xanosdk deploy release:${r} --ephemeral${flags}\` on this project's ephemeral, or \`xanosdk tenant deploy <tenant> ${r}${flags}\` on a tenant.`
   ];
   if (resettable.length === 0) return { before };
   const one = resettable.length === 1;
@@ -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-PZGUWD5J.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-DMDZVPMM.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-2B22WWKL.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

package/dist/{chunk-O5V3YH5P.js → chunk-JRVQ7M7W.js}

@@ -1,27 +1,27 @@
 import {
   BranchHttpError,
   BranchTakenError
-} from "./chunk-E65QIWOO.js";
+} from "./chunk-NPODGBVJ.js";
 import {
   SourceError
-} from "./chunk-2AUV6NXK.js";
+} from "./chunk-3II44CUJ.js";
 import {
   ReleaseHttpError
-} from "./chunk-A6QTTJUI.js";
+} from "./chunk-GWTFI3GA.js";
 import {
   ImportHttpError
-} from "./chunk-MEE5RZ6G.js";
+} from "./chunk-BL3AZ3AP.js";
 import {
   TenantHttpError
-} from "./chunk-KCAL4QYP.js";
+} from "./chunk-VW4CWVYX.js";
 import {
   TLS_CERTIFICATE_CODES,
   isTimeoutError,
   writeRefusedBy
-} from "./chunk-MN2PB6WB.js";
+} from "./chunk-YR2I5HGE.js";
 import {
   UsageError
-} from "./chunk-SBR2WZXG.js";
+} from "./chunk-D7BUMOKU.js";
 
 // src/emit/operation-outcome.ts
 var SettledWriteFailure = class extends Error {
@@ -82,4 +82,4 @@ export {
   SettledWriteFailure,
   classifyFailure
 };
-//# sourceMappingURL=chunk-O5V3YH5P.js.map
+//# sourceMappingURL=chunk-JRVQ7M7W.js.map

package/dist/{chunk-4APOHK7Y.js → chunk-JXVJGF3Y.js}

@@ -6,7 +6,7 @@ import {
   UsageError,
   style,
   terminalText
-} from "./chunk-SBR2WZXG.js";
+} from "./chunk-D7BUMOKU.js";
 
 // src/emit/prompt.ts
 import { createInterface } from "readline";
@@ -174,4 +174,4 @@ export {
   STDIN_IDLE_MS,
   readStdin
 };
-//# sourceMappingURL=chunk-4APOHK7Y.js.map
+//# sourceMappingURL=chunk-JXVJGF3Y.js.map

package/dist/chunk-KPFS3RGM.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-3EDSPMXN.js";
+import {
+  UsageError,
+  detail,
+  info,
+  warn
+} from "./chunk-D7BUMOKU.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-KPFS3RGM.js.map

package/dist/{chunk-PML67X22.js → chunk-LAOMN6QQ.js}

@@ -1,6 +1,6 @@
 import {
   classifyFailure
-} from "./chunk-O5V3YH5P.js";
+} from "./chunk-JRVQ7M7W.js";
 import {
   describeWrite
 } from "./chunk-4KHEMC32.js";
@@ -14,7 +14,7 @@ import {
   warn,
   writeJson,
   writeTargetPayload
-} from "./chunk-SBR2WZXG.js";
+} from "./chunk-D7BUMOKU.js";
 
 // src/emit/operation-result.ts
 var SERVER_PROCESSING_BOUND_MS = 6e5;
@@ -253,4 +253,4 @@ export {
   OperationError,
   runOperation
 };
-//# sourceMappingURL=chunk-PML67X22.js.map
+//# sourceMappingURL=chunk-LAOMN6QQ.js.map