@xano/sdk 1.0.0

package/dist/suggest-6FOOYKHG.js

@@ -0,0 +1,12 @@
+import {
+  orNames,
+  suggest,
+  suggestAll
+} from "./chunk-UTI5G6OJ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  orNames,
+  suggest,
+  suggestAll
+};
+//# sourceMappingURL=suggest-6FOOYKHG.js.map

package/dist/sveltekit.d.ts

@@ -0,0 +1,154 @@
+/**
+ * The server half of a static build: a directory a server-rendering build
+ * carries beside its static files (`@xano/sdk/sveltekit` writes it), which a
+ * local engine runs and every other host leaves out.
+ *
+ * It is a DOT directory on purpose. The server bundle can hold the app's
+ * private build-time env (SvelteKit inlines `$env/static/private` into it), and
+ * a Xano static-host build never publishes a hidden file, so a host that
+ * serves files only drops it even when it is uploaded.
+ *
+ * Not `.xano/`: that is the CLI's own state directory, which every scaffolded
+ * project's `.gitignore` ignores at any depth, so a committed build would lose
+ * its server bundle without a word.
+ */
+/** The directory, relative to the build's root. */
+declare const SERVER_DIR = ".xano-ssr";
+/** The server bundle, relative to the build's root. */
+declare const SERVER_BUNDLE = ".xano-ssr/server.js";
+
+/**
+ * `@xano/sdk/sveltekit`: a SvelteKit adapter whose output a Xano static host
+ * publishes, and a local engine also renders on the server.
+ *
+ * It goes wherever the project configures SvelteKit. A project `npx sv create`
+ * makes today has no `svelte.config.js`: the config is the object passed to
+ * `sveltekit()` in `vite.config.ts` (so is a `xanosdk init` scaffold's):
+ *
+ * ```ts
+ * // vite.config.ts
+ * import { sveltekit } from "@sveltejs/kit/vite";
+ * import adapter from "@xano/sdk/sveltekit";
+ * export default defineConfig({ plugins: [sveltekit({ adapter: adapter() })] });
+ * ```
+ *
+ * A project that keeps a `svelte.config.js` sets `kit.adapter` there instead:
+ *
+ * ```js
+ * // svelte.config.js
+ * import adapter from "@xano/sdk/sveltekit";
+ * export default { kit: { adapter: adapter() } };
+ * ```
+ *
+ * `vite build` then writes one directory (`build/` by default), which is what
+ * `xanosdk deploy --static build` uploads:
+ *
+ * - the STATIC half at its root: the client assets (`_app/…`), every prerendered
+ *   page, and a `404.html` fallback shell. Any static host serves these files,
+ *   and answers a path it holds no file for with `404.html` (status 404): the
+ *   shell boots the app, which renders a route it knows and `+error.svelte`
+ *   for one it does not. A prerendered `/404` route is kept as `404.html` only
+ *   when every page route is prerendered; otherwise the shell replaces it, so
+ *   the routes left to the browser still boot.
+ * - the SERVER half at `.xano-ssr/server.js`: SvelteKit's server and the app's
+ *   routes in one script, which answers every request that is not a file. A
+ *   local engine (`xanosdk deploy --local-engine --static build`) runs it, so a
+ *   dynamic route arrives as HTML with its own `<title>` and meta tags.
+ *
+ * ## The server bundle is never public
+ *
+ * SvelteKit inlines every `$env/static/private` value into the server code at
+ * build time, so `.xano-ssr/server.js` can hold secrets. It sits in a dot directory
+ * for that reason: `xanosdk deploy` sends it only to a local engine, which keeps
+ * it privately and answers `/.xano-ssr/…` with a 404, and a static host that is
+ * sent it anyway (an older SDK, another uploader) never publishes a hidden file.
+ *
+ * ## The contract
+ *
+ * `.xano-ssr/server.js` is a classic script (no `import`/`export`) that assigns
+ * `globalThis.__respond(request, clientAddress) -> Promise<Response>`, taking
+ * and returning web `Request`/`Response` objects. The host that runs it
+ * supplies, before loading it:
+ *
+ * - the web platform APIs a fetch handler expects (`fetch`, `URL`, `Headers`,
+ *   `TextEncoder`, `crypto`, timers);
+ * - `globalThis.__env`, which SvelteKit reads for `$env/dynamic/*`;
+ * - optionally `globalThis.__import(specifier) -> Promise<module>`, which
+ *   answers the dynamic imports the bundle cannot hold (see
+ *   {@link UNBUNDLABLE_IMPORT}). Without one they reject, and SvelteKit falls
+ *   back from both.
+ *
+ * The engine supplies all three. The engine sets `XANO_HOST` there: its own base URL, for
+ * a `load` that calls the workspace's API. A rendered page also gets the same
+ * `window.XANO_HOST` (and `--static-env`) globals the deploy writes into the
+ * prerendered documents.
+ *
+ * Needs `esbuild` in the app (`npm i -D esbuild`); it bundles the server half.
+ */
+
+interface XanoAdapterOptions {
+    /** The output directory, relative to the project. Default `build`. */
+    out?: string;
+    /**
+     * A fallback page for hosts that serve files only: SvelteKit's app shell,
+     * which renders the requested route in the browser. Written as `404.html`
+     * by default, which a multipage static host serves (with status 404) for a
+     * path it holds no file for. `false` writes none. A local engine that runs
+     * the server half never serves it: SvelteKit renders the route itself.
+     */
+    fallback?: string | false;
+    /** The JavaScript version the server bundle is lowered to. Default `es2017`. */
+    target?: string;
+}
+/**
+ * The parts of SvelteKit's `Builder` this adapter calls. Declared here so the
+ * SDK takes no dependency on `@sveltejs/kit`; SvelteKit 2 passes the real one.
+ */
+interface SvelteKitBuilder {
+    rimraf(dir: string): void;
+    mkdirp(dir: string): void;
+    writeClient(dest: string): string[];
+    writePrerendered(dest: string): string[];
+    writeServer(dest: string): string[];
+    generateFallback(dest: string): Promise<void>;
+    generateManifest(opts: {
+        relativePath: string;
+    }): string;
+    getBuildDirectory(name: string): string;
+    prerendered: {
+        paths: string[];
+    };
+    routes: {
+        id: string;
+        prerender: boolean | "auto";
+        page: {
+            methods: string[];
+        };
+    }[];
+    log: {
+        minor(msg: string): void;
+        warn(msg: string): void;
+    };
+}
+/** The shape SvelteKit expects from `kit.adapter`. */
+interface SvelteKitAdapter {
+    name: string;
+    adapt(builder: SvelteKitBuilder): Promise<void>;
+}
+/**
+ * The `import(` calls the engine cannot run, found in SvelteKit's server
+ * runtime. goja compiles no dynamic import, and SvelteKit calls it for two
+ * optional Node modules (`node:async_hooks`, and `node:crypto` through a
+ * variable), falling back when it fails. So exactly those two shapes (a
+ * `node:` literal, a variable argument) go to the host's `globalThis.__import`
+ * when it has one, and otherwise to a rejected promise. A relative `import('./nodes/0.js')` is left for esbuild to bundle,
+ * and `import(${…})` is left alone: SvelteKit WRITES that into the page's
+ * hydration script, which the browser must receive unchanged.
+ */
+declare const UNBUNDLABLE_IMPORT: RegExp;
+/** Rewrite the dynamic imports {@link UNBUNDLABLE_IMPORT} matches. Exported for tests. */
+declare function rewriteDynamicImports(source: string): string;
+/** The SvelteKit adapter. See the module comment for what it writes. */
+declare function adapter(options?: XanoAdapterOptions): SvelteKitAdapter;
+
+export { SERVER_BUNDLE, SERVER_DIR, type SvelteKitAdapter, type SvelteKitBuilder, UNBUNDLABLE_IMPORT, type XanoAdapterOptions, adapter as default, rewriteDynamicImports };

package/dist/sveltekit.js

@@ -0,0 +1,109 @@
+import {
+  SERVER_BUNDLE,
+  SERVER_DIR
+} from "./chunk-OOXWYAA4.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/sveltekit.ts
+import { readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+var ADAPTER_NAME = "@xano/sdk/sveltekit";
+var ENTRY = `import { Server } from './server/index.js';
+import { manifest } from './manifest.js';
+
+const server = new Server(manifest);
+let ready;
+
+globalThis.__respond = async (request, clientAddress) => {
+	ready = ready || server.init({ env: globalThis.__env || {} });
+	await ready;
+	return server.respond(request, { getClientAddress: () => clientAddress });
+};
+`;
+var UNBUNDLABLE_IMPORT = /\bimport\(\s*(?:\/\*[\s\S]*?\*\/\s*)?(?=["']node:|(?!\$\{)[A-Za-z_$])/g;
+function rewriteDynamicImports(source) {
+  return source.replace(UNBUNDLABLE_IMPORT, HOST_IMPORT);
+}
+var HOST_IMPORT = '(globalThis.__import || (function (s) { return Promise.reject(new Error("cannot import " + s)); }))(';
+function adapter(options = {}) {
+  const out = options.out ?? "build";
+  const fallback = options.fallback ?? "404.html";
+  const target = options.target ?? "es2017";
+  return {
+    name: ADAPTER_NAME,
+    async adapt(builder) {
+      let esbuild;
+      try {
+        esbuild = await import("esbuild");
+      } catch {
+        throw new Error(
+          `${ADAPTER_NAME} bundles the server half with esbuild, which this project does not have. Install it (\`npm i -D esbuild\`) and build again.`
+        );
+      }
+      builder.rimraf(out);
+      builder.writeClient(out);
+      const prerendered = builder.writePrerendered(out);
+      if (fallback !== false) {
+        const browserRendered = builder.routes.filter((r) => r.prerender !== true && r.page.methods.length > 0).map((r) => r.id);
+        if (!prerendered.includes(fallback)) {
+          await builder.generateFallback(`${out}/${fallback}`);
+        } else if (browserRendered.length > 0) {
+          builder.rimraf(`${out}/${fallback}`);
+          await builder.generateFallback(`${out}/${fallback}`);
+          builder.log.warn(
+            `${ADAPTER_NAME}: wrote the app shell over the prerendered ${fallback}, so a host that serves files only boots the routes that are not prerendered (${browserRendered.join(", ")}). An unknown path still answers 404 there, and renders +error.svelte.`
+          );
+        } else {
+          builder.log.minor(`${ADAPTER_NAME}: every page route is prerendered, so the prerendered ${fallback} is kept.`);
+        }
+      }
+      const tmp = builder.getBuildDirectory("xanosdk-sveltekit");
+      builder.rimraf(tmp);
+      builder.mkdirp(tmp);
+      builder.writeServer(`${tmp}/server`);
+      writeFileSync(
+        `${tmp}/manifest.js`,
+        `export const manifest = ${builder.generateManifest({ relativePath: "./server" })};
+`
+      );
+      writeFileSync(`${tmp}/entry.js`, ENTRY);
+      const result = await esbuild.build({
+        plugins: [
+          {
+            name: "xanosdk-no-dynamic-import",
+            setup(build) {
+              build.onLoad({ filter: /\.js$/ }, (args) => ({
+                contents: rewriteDynamicImports(readFileSync(args.path, "utf8")),
+                loader: "js"
+              }));
+            }
+          }
+        ],
+        // Absolute, and with the working directory named: esbuild's service
+        // process keeps the one it started in, which a later build in the same
+        // process (a second app, a test) does not share.
+        entryPoints: [resolve(tmp, "entry.js")],
+        absWorkingDir: process.cwd(),
+        bundle: true,
+        format: "iife",
+        platform: "neutral",
+        mainFields: ["module", "main"],
+        conditions: ["worker", "browser", "import"],
+        target,
+        outfile: resolve(out, SERVER_BUNDLE),
+        metafile: true,
+        logLevel: "warning"
+      });
+      const bytes = Object.values(result.metafile.outputs).reduce((n, o) => n + o.bytes, 0);
+      builder.log.minor(`server bundle: ${out}/${SERVER_BUNDLE} (${bytes} bytes, ${target})`);
+    }
+  };
+}
+export {
+  SERVER_BUNDLE,
+  SERVER_DIR,
+  UNBUNDLABLE_IMPORT,
+  adapter as default,
+  rewriteDynamicImports
+};
+//# sourceMappingURL=sveltekit.js.map

package/dist/sync-contributions-UCEROO26.js

@@ -0,0 +1,415 @@
+import {
+  discoverToolchainPlugins
+} from "./chunk-4Q2GN7NW.js";
+import {
+  contributionOutcomes,
+  recordedConfig,
+  runPluginQuestionnaire
+} from "./chunk-6ZGJCBZS.js";
+import {
+  pluginPrompter
+} from "./chunk-IDOTCMDV.js";
+import {
+  flagFor,
+  hostHelpTarget
+} from "./chunk-H5C7MBCR.js";
+import "./chunk-65HWOMGV.js";
+import "./chunk-2TFRR6JV.js";
+import {
+  SDK_PACKAGE,
+  declaredDependencies,
+  writeToolchainConfig
+} from "./chunk-JTUKLCXS.js";
+import "./chunk-4KHEMC32.js";
+import "./chunk-3LDULPRE.js";
+import {
+  assertWritable,
+  atomicWrite
+} from "./chunk-LLNZGEFK.js";
+import {
+  HASH_DIALECT,
+  blockPackages,
+  composeBlock,
+  findBlock,
+  gitattributesSpec,
+  linesOutsideBlocks,
+  removeBlock,
+  upsertBlock
+} from "./chunk-DGWHAVRG.js";
+import {
+  UsageError,
+  warn
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import {
+  withArticle
+} from "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/emit/sync-contributions.ts
+import { existsSync, readFileSync, rmSync } from "fs";
+import { join } from "path";
+async function syncContributions(projectDir, opts) {
+  if (opts.ask === "package" && (opts.pkg ?? "") === "") {
+    throw new Error(
+      'syncContributions({ ask: "package" }) needs the package to re-ask'
+    );
+  }
+  const manifestPath = join(projectDir, "package.json");
+  const raw = readManifestText(manifestPath);
+  const manifest = parseManifest(manifestPath, raw);
+  const block = readWritableBlock(manifestPath, manifest);
+  const depended = new Set(declaredDependencies(manifest));
+  const gitattributesPath = join(projectDir, ".gitattributes");
+  const before = existsSync(gitattributesPath) ? readFileSync(gitattributesPath, "utf8") : null;
+  const removed = [
+    .../* @__PURE__ */ new Set([
+      ...Object.keys(block),
+      ...blockPackages(before ?? "", HASH_DIALECT)
+    ])
+  ].filter((pkg) => pkg !== SDK_PACKAGE && !depended.has(pkg));
+  const { loaded, untouchable, configured, recomputable, sources, flags, outcomes } = await interrogate(projectDir, opts);
+  const decided = {
+    dropped: removed,
+    enable: opts.enable ?? [],
+    outcomes
+  };
+  const base = { text: before, block };
+  const projected = applyDecisions(base, decided);
+  const after = projected.state.text;
+  const actions = projected.actions;
+  warnDuplicated(base, outcomes);
+  const applied = opts.apply ? applyToDisk({ manifestPath, gitattributesPath, projectDir }, decided) : { written: [], changed: differs(base, projected.state) };
+  const { written, changed } = applied;
+  const modules = describeRun({
+    loaded,
+    actions,
+    dropped: removed,
+    block,
+    projected: projected.state,
+    before,
+    after,
+    configured,
+    recomputable,
+    untouchable,
+    sources,
+    flags
+  });
+  return {
+    projectDir,
+    modules,
+    // DERIVED from `modules`, not accumulated alongside it. Both were built in
+    // the same loop that built `modules` and were exact projections of it, with
+    // nothing enforcing the agreement — so a later edit to one arm of the
+    // classification could leave a package reported `unconfigured` in the list
+    // and something else in the table. Computed from the table, they cannot.
+    unconfigured: packagesWhere(modules, "unconfigured"),
+    removed: packagesWhere(modules, "removed"),
+    written,
+    changed
+  };
+}
+async function interrogate(projectDir, opts) {
+  const { loaded, skipped, unconfigured: neverConfigured } = await discoverToolchainPlugins(projectDir, {
+    frozen: false,
+    configuring: true,
+    // `enable` is applied HERE and nowhere else — folding the pending flag
+    // into what discovery reads is what lets the re-enabling land inside the
+    // reconciler's single write. See `SyncOptions.enable`.
+    ...opts.enable === void 0 || opts.enable.length === 0 ? {} : {
+      configOverride: Object.fromEntries(
+        opts.enable.map((pkg) => [pkg, { enabled: true }])
+      )
+    }
+  });
+  const untouchable = /* @__PURE__ */ new Set([
+    ...skipped.map((s) => s.pkg),
+    ...loaded.map((p) => p.pkg)
+  ]);
+  const neverConfiguredSet = new Set(neverConfigured);
+  const configured = new Set(
+    loaded.map((p) => p.pkg).filter((pkg) => !neverConfiguredSet.has(pkg))
+  );
+  const askSet = whoToAsk(opts, loaded, configured);
+  const actionable = loaded.filter(
+    (p) => configured.has(p.pkg) || askSet.has(p.pkg)
+  );
+  const { answers, sources, flags, prior } = await runPluginQuestionnaire(actionable, {
+    host: opts.host,
+    unknownFlags: opts.unknownFlags ?? [],
+    prompter: gate(
+      askSet,
+      opts.prompter ?? pluginPrompter({ json: opts.json })
+    )
+  });
+  const recomputable = new Set(
+    actionable.filter(
+      (p) => askSet.has(p.pkg) || (p.plugin.questions?.length ?? 0) === 0 || prior[p.pkg]
+    ).map((p) => p.pkg)
+  );
+  assertNoFlagsForCarried(actionable, recomputable, sources, opts.host);
+  const outcomes = contributionOutcomes(
+    actionable.filter((p) => recomputable.has(p.pkg)),
+    answers,
+    opts.host
+  );
+  return { loaded, untouchable, configured, recomputable, sources, flags, outcomes };
+}
+function applyToDisk(paths, decisions) {
+  const freshManifest = parseManifest(
+    paths.manifestPath,
+    readManifestText(paths.manifestPath)
+  );
+  const fresh = {
+    text: existsSync(paths.gitattributesPath) ? readFileSync(paths.gitattributesPath, "utf8") : null,
+    block: readWritableBlock(paths.manifestPath, freshManifest)
+  };
+  const depended = new Set(declaredDependencies(freshManifest));
+  const stillGone = decisions.dropped.filter((pkg) => !depended.has(pkg));
+  const final = applyDecisions(fresh, { ...decisions, dropped: stillGone }).state;
+  const written = [];
+  refuseUnwritable(paths.manifestPath);
+  refuseUnwritable(paths.gitattributesPath);
+  if (textChanged(fresh.text, final.text) && final.text !== null) {
+    if (final.text === "" && fresh.text !== null && fresh.text !== "") {
+      rmSync(paths.gitattributesPath, { force: true });
+    } else {
+      write(paths.gitattributesPath, final.text);
+    }
+    written.push(paths.gitattributesPath);
+  }
+  if (!sameBlock(fresh.block, final.block)) {
+    try {
+      if (writeToolchainConfig(paths.projectDir, final.block))
+        written.push(paths.manifestPath);
+    } catch (error) {
+      throw writeFailure(paths.manifestPath, error, written.length > 0);
+    }
+  }
+  return { written, changed: differs(fresh, final) };
+}
+function packagesWhere(modules, action) {
+  return modules.filter((m) => m.action === action).map((m) => m.pkg);
+}
+function describeRun(ctx) {
+  const nextBlock = ctx.projected.block;
+  const modules = [];
+  for (const p of ctx.loaded) {
+    const action = ctx.actions.get(p.pkg) ?? classify(p, {
+      configured: ctx.configured,
+      nextBlock,
+      recomputable: ctx.recomputable
+    });
+    modules.push({
+      pkg: p.pkg,
+      action: action === "configured" && !changedFor(p.pkg, ctx.block, nextBlock, ctx.before, ctx.after) ? "unchanged" : action,
+      ...ctx.sources[p.pkg] === void 0 ? {} : { sources: ctx.sources[p.pkg] },
+      ...ctx.flags[p.pkg] === void 0 ? {} : { flags: ctx.flags[p.pkg] },
+      ...nextBlock[p.pkg] === void 0 ? {} : { config: nextBlock[p.pkg] }
+    });
+  }
+  for (const pkg of ctx.dropped) modules.push({ pkg, action: "removed" });
+  for (const [pkg, config] of Object.entries(ctx.block)) {
+    if (pkg === SDK_PACKAGE || ctx.untouchable.has(pkg) || ctx.dropped.includes(pkg)) continue;
+    if (config?.enabled === false)
+      modules.push({ pkg, action: "disabled" });
+  }
+  return modules;
+}
+function applyDecisions(base, decisions) {
+  let text = base.text;
+  const block = { ...base.block };
+  for (const pkg of decisions.dropped) {
+    delete block[pkg];
+    text = removeBlock(text, gitattributesSpec(pkg)).text;
+  }
+  for (const pkg of decisions.enable) {
+    const stored = block[pkg];
+    block[pkg] = {
+      ...typeof stored === "object" && stored !== null && !Array.isArray(stored) ? stored : {},
+      enabled: true
+    };
+  }
+  const actions = /* @__PURE__ */ new Map();
+  for (const outcome of decisions.outcomes) {
+    if (outcome.status === "failed") {
+      actions.set(outcome.pkg, "failed");
+      continue;
+    }
+    if (outcome.status === "contributed") {
+      const spec = gitattributesSpec(outcome.pkg);
+      const lines = outcome.parts?.gitattributes ?? [];
+      text = upsertBlock(text, spec, composeBlock(spec, lines, outcome.version)).text;
+    }
+    const record = recordedConfig(outcome, block[outcome.pkg]);
+    if (record !== void 0) block[outcome.pkg] = record;
+  }
+  return { state: { text, block }, actions };
+}
+function refuseUnwritable(path) {
+  try {
+    assertWritable(path);
+  } catch (error) {
+    throw writeFailure(path, error);
+  }
+}
+function textChanged(before, after) {
+  if (before === null) return (after ?? "").trim() !== "";
+  return after !== null && after !== before;
+}
+function sameBlock(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function differs(before, after) {
+  return textChanged(before.text, after.text) || !sameBlock(before.block, after.block);
+}
+function warnDuplicated(base, outcomes) {
+  if (base.text === null) return;
+  const unmarked = new Set(linesOutsideBlocks(base.text, HASH_DIALECT));
+  for (const outcome of outcomes) {
+    if (outcome.status !== "contributed") continue;
+    warnIfDuplicated(base.text, outcome.pkg, outcome.parts?.gitattributes ?? [], unmarked);
+  }
+}
+function whoToAsk(opts, loaded, configured) {
+  if (opts.ask === "none") return /* @__PURE__ */ new Set();
+  if (opts.ask === "package") {
+    return new Set(loaded.filter((p) => p.pkg === opts.pkg).map((p) => p.pkg));
+  }
+  return new Set(
+    loaded.filter((p) => !configured.has(p.pkg)).map((p) => p.pkg)
+  );
+}
+function gate(askSet, inner) {
+  return {
+    ask: (pkg, question, fallback) => askSet.has(pkg) ? inner.ask(pkg, question, fallback) : Promise.resolve(void 0)
+  };
+}
+function warnIfDuplicated(text, pkg, lines, outside) {
+  if (text === null || lines.length === 0) return;
+  if (findBlock(text, gitattributesSpec(pkg)) !== null) return;
+  const already = lines.map((l) => l.trim()).filter((l) => l !== "" && outside.has(l));
+  if (already.length === 0) return;
+  warn(
+    `.gitattributes already carries ${already.length === 1 ? "a rule" : "rules"} ${pkg} contributes, outside any managed block.`,
+    "module.gitattributes-conflict",
+    [
+      ...already,
+      `A block for ${pkg} was added anyway \u2014 the SDK can only rewrite the span it marks. Delete the unmarked ${already.length === 1 ? "copy" : "copies"} by hand.`
+    ]
+  );
+}
+function classify(p, ctx) {
+  if (ctx.recomputable.has(p.pkg)) return "configured";
+  if (ctx.configured.has(p.pkg)) return "carried";
+  return "unconfigured";
+}
+function changedFor(pkg, block, nextBlock, before, after) {
+  if (JSON.stringify(block[pkg]) !== JSON.stringify(nextBlock[pkg]))
+    return true;
+  return blockText(before, pkg) !== blockText(after, pkg);
+}
+function blockText(text, pkg) {
+  if (text === null) return null;
+  try {
+    return findBlock(text, gitattributesSpec(pkg))?.text ?? null;
+  } catch {
+    return null;
+  }
+}
+function readManifestText(path) {
+  if (!existsSync(path)) {
+    throw new UsageError(
+      `${path} does not exist, so there is no project here to reconcile.`,
+      {
+        suggestion: "Run this from a project directory, or scaffold one with `xanosdk init`."
+      }
+    );
+  }
+  return readFileSync(path, "utf8");
+}
+function parseManifest(path, raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new UsageError(
+      `${path} is not valid JSON, so this project's toolchain modules cannot be reconciled: ${error instanceof Error ? error.message : String(error)}`,
+      { suggestion: "Repair the file and re-run. Nothing was written." }
+    );
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new UsageError(
+      `${path} is not a JSON object, so it is not a usable package manifest.`,
+      {
+        suggestion: "Repair the file and re-run. Nothing was written."
+      }
+    );
+  }
+  return parsed;
+}
+function readWritableBlock(path, manifest) {
+  const block = manifest["xanosdk"];
+  if (block === void 0) return {};
+  if (typeof block !== "object" || block === null || Array.isArray(block)) {
+    throw new UsageError(
+      `the "xanosdk" key in ${path} is ${describe(block)} where a map from package name to that module's settings is expected, so this run would have written over it.`,
+      {
+        suggestion: "Repair or delete the key and re-run. Nothing was written."
+      }
+    );
+  }
+  for (const [pkg, own] of Object.entries(block)) {
+    if (typeof own !== "object" || own === null || Array.isArray(own)) {
+      throw new UsageError(
+        `the "xanosdk" entry for ${pkg} in ${path} is ${describe(own)} where that module's settings object is expected, so this run would have written over it.`,
+        {
+          suggestion: "Repair or delete the entry and re-run. Nothing was written."
+        }
+      );
+    }
+  }
+  return block;
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  return withArticle(typeof value);
+}
+function write(path, text) {
+  try {
+    assertWritable(path);
+    atomicWrite(path, text);
+  } catch (error) {
+    throw writeFailure(path, error);
+  }
+}
+function writeFailure(path, error, partial = false) {
+  return new UsageError(
+    `${path} could not be written: ${error instanceof Error ? error.message : String(error)}`,
+    {
+      suggestion: partial ? `Check the file's permissions and re-run. \`.gitattributes\` was already written, but nothing was recorded in package.json \u2014 so re-running re-asks and completes the job, and the block it writes is the one already there.` : "Check the file's permissions and re-run."
+    }
+  );
+}
+function assertNoFlagsForCarried(actionable, recomputable, sources, host) {
+  for (const p of actionable) {
+    if (recomputable.has(p.pkg)) continue;
+    const names = Object.entries(sources[p.pkg] ?? {}).filter(([, source]) => source === "flag").flatMap(([id]) => (p.plugin.questions ?? []).filter((q) => q.id === id)).map((q) => `\`--${flagFor(q)}\``);
+    if (names.length === 0) continue;
+    throw new UsageError(
+      `${names.join(", ")} answers a question for ${p.pkg}, but this run does not re-derive that module's contributions \u2014 it has no way to read its stored settings back, so it carries them forward untouched and the flag would have changed nothing.`,
+      {
+        helpFor: hostHelpTarget(host),
+        suggestion: `Run \`xanosdk marketplace reinstall ${p.pkg}\` with the flag: that is the verb that re-asks one module and rewrites what it contributes.`
+      }
+    );
+  }
+}
+export {
+  syncContributions
+};
+//# sourceMappingURL=sync-contributions-UCEROO26.js.map