@xano/sdk 1.0.4 → 1.0.6

package/dist/plugin.d.ts

@@ -10,12 +10,15 @@
  * A TOOLCHAIN module extends the **CLI** instead. It adds nothing to the
  * workspace — registering it into `xano/index.ts` would be meaningless, because
  * there is nothing to register. What it does is participate in the commands:
- * declare questions, contribute to files the project owns, and run when a
- * bundle is compiled or a workspace is checked.
+ * declare questions, contribute to files the project owns, add a section to
+ * the route manifest (`routes.gen.ts`), and run when a bundle is compiled or a
+ * workspace is checked.
  *
- * The shape this contract was built for is a module that renders the compiled
+ * The contract was first built for a module that renders the compiled
  * workspace to a committed tree on every deploy, so a backend change can be
- * reviewed as what the engine will actually run.
+ * reviewed as what the engine will actually run. The route-manifest hook was
+ * added for the second module, `@xano-sdk/zod`, which renders a runtime
+ * validator for every request input beside the SDK's own input types.
  *
  * ── Contributions apply to a PROJECT, not to a scaffold ─────────────────────
  *
@@ -322,14 +325,227 @@ interface PreflightContext {
     /** This module's block from the project's `package.json` `"xanosdk"` object. */
     readonly config: Readonly<Record<string, unknown>>;
 }
+/**
+ * The request inputs of every endpoint, realtime channel and realtime message a
+ * route manifest (`routes.gen.ts`) describes, read off the compiled payload.
+ *
+ * VALIDATOR-NEUTRAL on purpose. The SDK renders its own request types from this
+ * and a module renders its validators from the same value, so the two cannot
+ * disagree about what an input is: there is one reading of the stored inputs,
+ * not one per renderer. It is built from the payload alone because the decode
+ * paths (`pull`, `generate`, `init --from`) write the manifest with no compile
+ * of the workspace to ask.
+ *
+ * Keys are the manifest's FINAL keys, so a section built from this lines up
+ * with `ROUTES` and `CHANNELS` entry for entry. Entries are in a fixed order (see
+ * each list), so a renderer that walks them in order writes the same text for
+ * the same workspace.
+ */
+interface RouteInputs {
+    /** One per `ROUTES` key, in `ROUTES` order. */
+    readonly routes: readonly RouteInputSet[];
+    /** One per `CHANNELS` key, in `CHANNELS` order: the channel's path params. */
+    readonly channels: readonly RouteInputSet[];
+    /**
+     * One per message on a channel in `CHANNELS`, sorted by key: the message's
+     * payload. A message whose channel the manifest leaves out (its server's
+     * canonical resolves nowhere) is left out with it.
+     */
+    readonly messages: readonly MessageInputSet[];
+}
+/** The inputs of one endpoint or channel, under its manifest key. */
+interface RouteInputSet {
+    /**
+     * The manifest key: `"GET listings"` or `"v1:GET vehicles"` for an endpoint,
+     * `"rooms/{room_id}"` or `"chat:lobby"` for a channel.
+     */
+    readonly key: string;
+    /** In the order the def declares them. */
+    readonly inputs: readonly InputDescription[];
+}
+/**
+ * The payload inputs of one realtime message. Its `key` is
+ * `"<channel key> <message name>"` — `"rooms/{room_id} send"`. Read in the
+ * order a message is addressed, and collision-free: a message name holds no
+ * space and no `/`.
+ */
+interface MessageInputSet extends RouteInputSet {
+    /** The owning channel's `CHANNELS` key. */
+    readonly channel: string;
+    /** The message's name, as a client sends it. */
+    readonly name: string;
+}
+/**
+ * The stored input types whose description carries nothing beyond the common
+ * flags. Engine spellings, not authoring names: `epochms` is
+ * `input.timestamp()`, `blob_img` is `input.image()`, `file` is a raw upload.
+ */
+type InputScalarType = "text" | "int" | "decimal" | "bool" | "email" | "password" | "uuid" | "date" | "epochms" | "json" | "file" | "blob" | "blob_img" | "blob_video" | "blob_audio" | "geo_point" | "geo_multipoint" | "geo_linestring" | "geo_multilinestring" | "geo_polygon" | "geo_multipolygon";
+/**
+ * An enabled method on an input (`trim`, `min:8`), with its arguments as
+ * strings. The stored form is numeric and string inconsistently (`[8]` and
+ * `["8"]` are both real bytes), so the two are read as one.
+ */
+interface InputMethod {
+    readonly name: string;
+    readonly args: readonly string[];
+}
+/**
+ * A list input's length bounds. A bound the engine does not enforce is ABSENT,
+ * never `0`: unset is stored as `""` or `{}`, and the engine reads `0` as no
+ * bound too, so all of those describe the same unbounded side.
+ */
+interface InputListBounds {
+    readonly min?: number;
+    readonly max?: number;
+}
+/** The flags every described input carries, whatever its type. */
+interface InputDescriptionBase {
+    /** The key a client sends. */
+    readonly name: string;
+    /** A required input stays required when it carries a default. */
+    readonly required: boolean;
+    /**
+     * Whether `null` is accepted. A type nullable by default (files, geo, uuid,
+     * vector, `date`, `epochms`) reads `true` unless the def said otherwise, and
+     * a `json` input is always nullable.
+     */
+    readonly nullable: boolean;
+    /** `false` for a single value; the bounds for a list. */
+    readonly list: false | InputListBounds;
+    /**
+     * The enabled methods, in stored order. Always empty on an `obj`, and on an
+     * `enum` or `vector` input, whose methods the engine does not apply (a
+     * dbLink's customization of such a column is the exception: the engine
+     * applies those).
+     */
+    readonly methods: readonly InputMethod[];
+}
+/**
+ * One request input.
+ *
+ * A `dbLink` is the one entry that is not itself a request key: the engine
+ * expands it into the linked table's columns at the TOP level of the request,
+ * so a renderer spreads {@link DbLinkInputDescription.columns} into the
+ * surrounding object. A stored type this reading does not know is `unknown`,
+ * never guessed at.
+ */
+type InputDescription = (InputDescriptionBase & {
+    readonly type: InputScalarType;
+}) | (InputDescriptionBase & {
+    readonly type: "enum";
+    /** As stored: a numeric enum keeps numeric values. */
+    readonly values: readonly (string | number)[];
+}) | (InputDescriptionBase & {
+    readonly type: "vector";
+    readonly size: number;
+}) | (InputDescriptionBase & {
+    readonly type: "tableRef";
+    /** The referenced table's primary-key type, which is what a client sends. */
+    readonly keyType: "int" | "uuid";
+    /** The referenced table's guid. */
+    readonly table: string;
+}) | (InputDescriptionBase & {
+    readonly type: "obj";
+    readonly children: readonly InputDescription[];
+}) | DbLinkInputDescription | (InputDescriptionBase & {
+    readonly type: "unknown";
+    /** The stored type string, for a renderer's diagnostics. */
+    readonly storedType: string;
+});
+/**
+ * A database link: one stored input the engine expands into one input per
+ * column of the linked table.
+ */
+interface DbLinkInputDescription {
+    /** The stored entry's name (by convention `<table>__`). Not a request key. */
+    readonly name: string;
+    readonly type: "dbLink";
+    /** The linked table's guid. */
+    readonly table: string;
+    /**
+     * The request inputs it expands to, as the engine expands them: never the
+     * `id`, not a column the link hides, not a private or internal column unless
+     * the link customizes it, and a customized column with the customization's
+     * `required` and methods in place of its own.
+     *
+     * `undefined` when the payload does not carry the linked table, so the
+     * columns cannot be known. A renderer must not read that as "no columns":
+     * narrowing the request to nothing would reject a body the server accepts.
+     */
+    readonly columns: readonly InputDescription[] | undefined;
+}
+/**
+ * What {@link ToolchainPlugin.routesManifest} is handed.
+ *
+ * Everything the section can depend on is in here, and nothing else: the
+ * hook's output is a function of this value alone (see the hook for why).
+ */
+interface RoutesManifestContext {
+    /**
+     * Every endpoint's, channel's and message's request inputs, under the
+     * manifest's FINAL keys — the keys of `ROUTES`, `CHANNELS` and the generated
+     * input maps — in a fixed order. Walk it in order and the section comes out
+     * the same for the same workspace.
+     */
+    readonly inputs: RouteInputs;
+    /** This module's block from the project's `package.json` `"xanosdk"` object. */
+    readonly config: Readonly<Record<string, unknown>>;
+    /** The running `@xano/sdk` version, for a plugin's own peer-range check. */
+    readonly sdkVersion: string;
+}
+/**
+ * One module's section of `routes.gen.ts`: TypeScript source, plus the named
+ * package imports it needs.
+ *
+ * WHERE IT LANDS. The SDK composes the file: the merged imports of every
+ * module at the top (one `import { a, b } from "pkg";` per package, names
+ * sorted and deduped), then the core sections, then each module's `source` in
+ * a marked block naming the module's package and version, blocks ordered by
+ * package name. So the source is in the SAME FILE as the core sections and
+ * after them: it may name the generated types (`RouteInputs`, `ChannelInputs`,
+ * `MessageInputs`, `MessageName` — maps keyed by the manifest's keys, not the
+ * {@link RouteInputs} description type of this entry, and always present,
+ * empty or not) directly, without importing them. Anything it exports is
+ * exported from `routes.gen.ts`.
+ *
+ * ── Imports are declared, never written ─────────────────────────────────────
+ *
+ * The core sections import nothing, which is what keeps `routes.gen.ts` free
+ * of the SDK runtime in a frontend bundle. A module's imports are the only
+ * ones in the file, so they are data the SDK can check, never `import` lines
+ * inside `source`. A specifier that is not a bare package name is REFUSED:
+ * `@xano/sdk` and its subpaths (the bundle cost the file exists to avoid), a
+ * relative or absolute path (it would resolve against whichever directory the
+ * file was written into), and a protocol (`node:`) all fail the module by
+ * name. Each name must be a plain identifier: no `as` renames, no
+ * side-effect-only import.
+ *
+ * Imported names share one scope with the core sections and every other
+ * module's source, so pick names that will not collide; a collision fails the
+ * user's typecheck rather than being renamed for you.
+ *
+ * A blank `source` contributes no block at all, and its imports are dropped
+ * with it: that is how a module whose config turns the section off removes it.
+ */
+interface RoutesManifestSection {
+    /** Named imports from packages the consuming project can resolve. */
+    readonly imports?: readonly {
+        readonly from: string;
+        readonly names: readonly string[];
+    }[];
+    /** TypeScript placed after the core sections. Must not spell a block marker (`// xanosdk:begin`, `// xanosdk:end`). */
+    readonly source: string;
+}
 /**
  * What a toolchain module's `xanosdk.plugin` file default-exports.
  *
- * Five hooks, and deliberately no more. This contract was designed from one
- * example, and a contract designed from one example generalizes badly — so it
- * covers exactly what that first module needs and stops. The SECOND toolchain
- * module is the one that should generalize it, with the real second set of
- * requirements in hand.
+ * Six hooks. The first five were designed from one example (a module that
+ * renders the workspace to a committed tree) and covered exactly what it
+ * needed. The sixth, {@link ToolchainPlugin.routesManifest}, was added when the
+ * second module, `@xano-sdk/zod`, brought a second real set of requirements: a
+ * module that writes into a file the SDK generates, rather than into a tree of
+ * its own. A hook is added when a module needs it, not in anticipation.
  *
  * Every hook is optional: a module that only adds a `.gitattributes` line
  * declares {@link ToolchainPlugin.contributes} alone.
@@ -391,6 +607,34 @@ interface ToolchainPlugin {
     readonly onBundle?: (ctx: BundleContext) => Promise<HookResult>;
     /** Runs on `preflight`, contributing a comparison to the report. */
     readonly onPreflight?: (ctx: PreflightContext) => Promise<HookResult>;
+    /**
+     * This module's section of the route manifest (`routes.gen.ts`), computed
+     * from the request inputs the SDK read off the payload. See
+     * {@link RoutesManifestSection} for where it lands and what it may import.
+     *
+     * Runs wherever the manifest is written: `routes --emit` (the `xano:routes`
+     * and `xano:check` scripts), `init` when it writes the project's first
+     * manifest, the refresh `marketplace install`, `reinstall` and `remove`
+     * make, and the decode paths `pull` and `generate`. Not `init --from`: a
+     * project it creates has no module installed yet, and the first
+     * `xano:routes` after an install adds the section.
+     *
+     * SYNCHRONOUS AND PURE. No filesystem, no network, no clock, no randomness:
+     * the same context returns the same section, every time. Every writer of
+     * `routes.gen.ts` must produce identical bytes for the same workspace, or
+     * `routes --emit --strict` flips between red and green depending on which
+     * command last wrote the file; and the decode paths place the file
+     * synchronously, so a promise has nowhere to be awaited. A promise, or any
+     * value that is not a {@link RoutesManifestSection}, is refused.
+     *
+     * A throw (or a refused section) is this module failing, not the manifest:
+     * the core sections are still refreshed, the module's previous block is kept
+     * as it was (none is written when the file has none yet), and a warning
+     * names the module. A module that fails to load is handled the same way. On a verifying run
+     * (`routes --emit --strict`) it is fatal instead, because a check that did
+     * not run must not read as one that passed.
+     */
+    readonly routesManifest?: (ctx: RoutesManifestContext) => RoutesManifestSection;
 }
 
-export type { BundleContext, BundlePayload, EngineRendering, HookCommand, HookResult, PluginAnswers, PluginQuestion, PreflightContext, ProjectContributions, ToolchainPlugin };
+export type { BundleContext, BundlePayload, DbLinkInputDescription, EngineRendering, HookCommand, HookResult, InputDescription, InputDescriptionBase, InputListBounds, InputMethod, InputScalarType, MessageInputSet, PluginAnswers, PluginQuestion, PreflightContext, ProjectContributions, RouteInputSet, RouteInputs, RoutesManifestContext, RoutesManifestSection, ToolchainPlugin };

package/dist/{preflight-command-EBQ6XQF3.js → preflight-command-OHJXYND3.js}

@@ -4,69 +4,69 @@ import {
 } from "./chunk-6KEB3C3U.js";
 import {
   sectionKind
-} from "./chunk-HMLGM2MW.js";
-import "./chunk-XXZZGXW2.js";
+} from "./chunk-IYXL5NYU.js";
 import {
   assertBundleFile,
   assertBundleInput,
   assertEntryFile,
   loadBundleText,
   refuseValueFlagsBesideBundle
-} from "./chunk-WYEQFD6A.js";
-import "./chunk-DIG3NITC.js";
-import "./chunk-664LSWE5.js";
-import "./chunk-LIVN53UV.js";
-import "./chunk-HSEQYBDO.js";
-import "./chunk-T4DUFQ2S.js";
-import "./chunk-2AUV6NXK.js";
-import "./chunk-A6QTTJUI.js";
-import "./chunk-MEE5RZ6G.js";
-import "./chunk-LUTMOHOW.js";
-import "./chunk-3P3HXN76.js";
-import "./chunk-W5ONYLOP.js";
-import "./chunk-KCAL4QYP.js";
+} from "./chunk-XFBGXB7X.js";
+import "./chunk-WBH4KJWM.js";
+import "./chunk-HCG7NDIL.js";
+import "./chunk-I3VHW6XM.js";
+import "./chunk-WZHLMU6T.js";
+import "./chunk-CCU5CCRX.js";
+import "./chunk-3II44CUJ.js";
+import "./chunk-GWTFI3GA.js";
+import "./chunk-BL3AZ3AP.js";
+import "./chunk-YGLMRH5U.js";
+import "./chunk-ITC2R2OT.js";
+import "./chunk-IXFJORNH.js";
+import "./chunk-VW4CWVYX.js";
 import "./chunk-2MNLRIOX.js";
-import "./chunk-WL2DSNJV.js";
-import "./chunk-AM4FKL4J.js";
-import "./chunk-JP7M7OU7.js";
-import "./chunk-UDE5C2XN.js";
-import "./chunk-MLGI2SRQ.js";
-import "./chunk-UKUIUS3E.js";
+import "./chunk-Q22BMRPF.js";
+import "./chunk-PL7AIAWS.js";
+import "./chunk-FU3VCE5A.js";
+import "./chunk-VDHA5SSQ.js";
+import "./chunk-PFBXSVZF.js";
+import "./chunk-U6MTGB46.js";
 import "./chunk-ZYJP6BOO.js";
 import "./chunk-QO6BVGS5.js";
-import "./chunk-3H3EPMFY.js";
-import "./chunk-BUECLQXK.js";
-import "./chunk-CFSFBKHP.js";
-import "./chunk-FMOEVAGT.js";
+import "./chunk-5TVFLG3C.js";
+import "./chunk-SPKA2LV6.js";
+import "./chunk-7GAIJW62.js";
+import "./chunk-6X3MY2JP.js";
 import "./chunk-622HUCZT.js";
-import "./chunk-SEUCZZCP.js";
-import "./chunk-E6H5ZEV3.js";
-import "./chunk-HUSH7LRI.js";
-import "./chunk-ZG7E72VI.js";
-import "./chunk-S7E2AHV3.js";
+import "./chunk-N5I37JFB.js";
+import "./chunk-TTEIDD5Q.js";
+import "./chunk-LL7SGTRC.js";
+import "./chunk-YYC2DZMG.js";
+import "./chunk-PMMHSX4H.js";
 import "./chunk-ZFDZKNGG.js";
 import "./chunk-FWD7AL6N.js";
-import "./chunk-3FN2BIGB.js";
-import "./chunk-JTUKLCXS.js";
+import "./chunk-QJM5XZ4K.js";
+import "./chunk-DXUICABI.js";
 import "./chunk-4KHEMC32.js";
-import "./chunk-37AHZ7JX.js";
+import "./chunk-3BBIDW3Y.js";
 import "./chunk-ROY4YAEQ.js";
-import "./chunk-VD32O6KZ.js";
-import "./chunk-RX3EMQGN.js";
-import "./chunk-WRBKLYSJ.js";
-import "./chunk-DYG5D3FD.js";
-import "./chunk-I2BGYNHD.js";
+import "./chunk-CJDPSCMX.js";
+import "./chunk-MFWF2NZJ.js";
+import "./chunk-DNBP4GJN.js";
+import "./chunk-763M6LX3.js";
+import "./chunk-WAVNUTMT.js";
+import "./chunk-M5CSVB23.js";
 import "./chunk-AWQ7BQTQ.js";
 import "./chunk-EUUUMY7J.js";
-import "./chunk-MN2PB6WB.js";
-import "./chunk-FPBGAT5D.js";
+import "./chunk-YR2I5HGE.js";
+import "./chunk-26MOFAJT.js";
 import "./chunk-LLNZGEFK.js";
-import "./chunk-QXTKSOFI.js";
+import "./chunk-MF4W6FHU.js";
 import "./chunk-X2NL4KUO.js";
-import "./chunk-OPHB5ORL.js";
-import "./chunk-UCQ2VUTG.js";
-import "./chunk-DGWHAVRG.js";
-import "./chunk-6R7S775T.js";
+import "./chunk-EQFYOOO6.js";
+import "./chunk-M6ZFSTIZ.js";
+import "./chunk-3EDSPMXN.js";
+import "./chunk-7REDHC4N.js";
 import {
   UsageError,
   blank,
@@ -78,42 +78,42 @@ import {
   success,
   warn,
   writeJson
-} from "./chunk-SBR2WZXG.js";
-import "./chunk-II747OWE.js";
-import "./chunk-5W7DOMIU.js";
+} from "./chunk-D7BUMOKU.js";
+import "./chunk-FQ53GTII.js";
+import "./chunk-VJFMUJWZ.js";
 import "./chunk-6JAEMMZ7.js";
-import "./chunk-5YL5OC2G.js";
+import "./chunk-5QMJOE2K.js";
 import "./chunk-45ZUMF4E.js";
 import "./chunk-7KPKDHHI.js";
-import "./chunk-EESV6NU2.js";
-import "./chunk-OPG4DYX2.js";
+import "./chunk-7FIMUFBP.js";
+import "./chunk-T4LJ5UR2.js";
 import "./chunk-ICK36EGF.js";
 import "./chunk-BEXZ4XRV.js";
 import "./chunk-ETAZIGNT.js";
 import "./chunk-GSGDWJB5.js";
-import "./chunk-4PQHO74B.js";
+import "./chunk-SLGJIWCY.js";
 import "./chunk-ERVIASGL.js";
 import "./chunk-VTMTIBKP.js";
 import "./chunk-H2V3N23D.js";
 import "./chunk-3JDU4VRL.js";
 import "./chunk-WTPZRR4I.js";
-import "./chunk-GPI3OWRE.js";
+import "./chunk-YHB34BN6.js";
 import "./chunk-UTI5G6OJ.js";
-import "./chunk-OOGXZL7Z.js";
+import "./chunk-5KJBWIDZ.js";
 import "./chunk-5ZSO4T2G.js";
-import "./chunk-XNCP4KYO.js";
+import "./chunk-VQPDATQT.js";
 import "./chunk-UDZX2ZL4.js";
 import "./chunk-ZY55DO5P.js";
 import "./chunk-A2AOUBJS.js";
 import "./chunk-TFFGOFVZ.js";
-import "./chunk-3HOGFGKG.js";
-import "./chunk-7GX445AE.js";
-import "./chunk-37FBPMNE.js";
+import "./chunk-D3KEPRRN.js";
+import "./chunk-4XHAT7C5.js";
+import "./chunk-S56YBYMN.js";
 import "./chunk-UVF45BVU.js";
 import "./chunk-VAX3UZOY.js";
 import "./chunk-LL6ED5IB.js";
 import "./chunk-4BW2SG2N.js";
-import "./chunk-4DJTQ6W4.js";
+import "./chunk-JIKGT7DO.js";
 import "./chunk-4MIV244X.js";
 import "./chunk-OHX6MIUZ.js";
 import "./chunk-36JUQZVQ.js";
@@ -131,22 +131,22 @@ async function runPreflightCommand(args) {
       helpFor: { command: "preflight" }
     });
   }
-  const { resolveValidateConfig, envNamesValidateTarget, verifyToken } = await import("./config-JU6OQC77.js");
-  const { MetaClient } = await import("./meta-client-73PX6UGJ.js");
+  const { resolveValidateConfig, envNamesValidateTarget, verifyToken } = await import("./config-MZ5KG4EP.js");
+  const { MetaClient } = await import("./meta-client-TMHVBZFY.js");
   const fromEnv = envNamesValidateTarget(args.instance);
   if (fromEnv) refuseCredentialFlagsDisplacedByEnv(args);
-  const credential = fromEnv ? void 0 : await (await import("./token-CMAB35GD.js")).getAccessToken(args);
+  const credential = fromEnv ? void 0 : await (await import("./token-7AWSJLKO.js")).getAccessToken(args);
   const config = credential === void 0 ? resolveValidateConfig({ instance: args.instance }) : validateTargetOf(credential);
   const host = new URL(config.instance).host;
   let who;
   try {
     who = await verifyToken(config, fromEnv ? "env" : "credential");
   } catch (err) {
-    const { unansweredRead } = await import("./source-resolve-DMDZVPMM.js");
+    const { unansweredRead } = await import("./source-resolve-MKLNYFWG.js");
     throw unansweredRead(err, "check the credential", "workspace");
   }
   step(`Validating against ${host}${who.name ? ` (as ${who.name})` : ""}`);
-  const { discoverToolchainPlugins } = await import("./toolchain-modules-3M7QDJBV.js");
+  const { discoverToolchainPlugins } = await import("./toolchain-modules-VU7SURVJ.js");
   const toolchain = await discoverToolchainPlugins(process.cwd(), { frozen: true });
   const { bundle } = await loadBundleText(args, { command: "preflight" });
   const client = new MetaClient(config);
@@ -174,8 +174,8 @@ function validateTargetOf(auth) {
   return { instance: auth.instance, token: auth.access_token, workspaceId: auth.workspaceId };
 }
 async function validateWithClient(args, client, bundle, plugins, credential) {
-  const { runValidateLoop, runnableFunctionNames } = await import("./loop-UFHKSOQ4.js");
-  const { anyDeclares } = await import("./toolchain-hooks-BGZBDFAT.js");
+  const { runValidateLoop, runnableFunctionNames } = await import("./loop-SUB6C2LK.js");
+  const { anyDeclares } = await import("./toolchain-hooks-4ZMQLBPQ.js");
   const wantsPluginInputs = anyDeclares(plugins, "onPreflight");
   const result = await runValidateLoop(client, bundle, {
     includeEngineRendering: wantsPluginInputs
@@ -207,7 +207,7 @@ async function validateWithClient(args, client, bundle, plugins, credential) {
   };
   if (!result.accepted) {
     if (credential !== void 0) {
-      const { refuseUnreachableWorkspace } = await import("./workspace-binding-2TWZBHQY.js");
+      const { refuseUnreachableWorkspace } = await import("./workspace-binding-JE6YNDZJ.js");
       await refuseUnreachableWorkspace(credential);
     }
     warn("Import rejected by the engine:", "preflight.import-rejected", [result.importError ?? "(no message)"]);
@@ -250,7 +250,7 @@ async function validateWithClient(args, client, bundle, plugins, credential) {
     );
     failed = true;
   } else if (wantsPluginInputs && result.engineComparison !== void 0) {
-    const { fireOnPreflight } = await import("./toolchain-hooks-BGZBDFAT.js");
+    const { fireOnPreflight } = await import("./toolchain-hooks-4ZMQLBPQ.js");
     const { readVersion } = await import("./cli.js");
     const outcome = await fireOnPreflight(plugins, {
       engineRendering: result.engineComparison.engineRendering,
@@ -287,7 +287,7 @@ async function validateWithClient(args, client, bundle, plugins, credential) {
   }
   let captured = null;
   if (args.capture) {
-    const { captureFixtures } = await import("./capture-3JNUA6C2.js");
+    const { captureFixtures } = await import("./capture-GW5KNKMB.js");
     const written = captureFixtures(result.roundTrip, args.out);
     captured = written;
     if (written.length === 0) warn("nothing to capture (no objects round-tripped)", "preflight.nothing-captured");
@@ -319,4 +319,4 @@ function fmt(v) {
 export {
   runPreflightCommand
 };
-//# sourceMappingURL=preflight-command-EBQ6XQF3.js.map
+//# sourceMappingURL=preflight-command-OHJXYND3.js.map