atmn 2.0.11 → 2.0.12

package/dist/bin.js

@@ -4,7 +4,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/cli.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 import { Command } from "commander";
 
 // src/auth/oauthConfig.ts
@@ -6787,7 +6787,7 @@ var createClient = (options) => ({
 });
 
 // src/version.ts
-var version = "2.0.11";
+var version = "2.0.12";
 
 // src/http/autumnFetch.ts
 var runtime = typeof Bun !== "undefined" ? `bun ${Bun.version}` : `node ${process.versions.node}`;
@@ -7183,8 +7183,8 @@ var fetchOrgInfo = async ({
 };
 
 // src/actions/init/runInit.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname5, join as join8, relative as relative2, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname5, join as join9, relative as relative3, resolve as resolve2 } from "node:path";
 
 // src/config/configPackageName.ts
 var PUBLISHED_PACKAGE = "atmn";
@@ -7723,6 +7723,7 @@ import { dirname as dirname3, join as join6 } from "node:path";
 // src/generated/emit.ts
 var COLLECTIONS = {
   features: {
+    wireKey: "features",
     builder: "feature",
     idField: "featureId",
     responseIdField: "id",
@@ -7798,11 +7799,13 @@ var COLLECTIONS = {
       "providerMarkups.*.markup",
       "type"
     ],
+    mappings: { properties: { processors: { mapping: true } } },
     defaults: {},
     pull: true,
     deprecated: []
   },
   plans: {
+    wireKey: "plans",
     builder: "plan",
     idField: "planId",
     responseIdField: "id",
@@ -8583,6 +8586,43 @@ var COLLECTIONS = {
       "variants.versionSlug",
       "versionSlug"
     ],
+    mappings: {
+      properties: {
+        processors: { mapping: true },
+        price: { properties: { processors: { mapping: true } } },
+        items: {
+          items: {
+            properties: {
+              price: { properties: { processors: { mapping: true } } }
+            }
+          },
+          identity: {
+            responseField: "mappingIdentity",
+            components: [
+              { paths: ["featureId"], default: "" },
+              { paths: ["price.billingMethod"], default: "" },
+              { paths: ["price.interval", "reset.interval"], default: "" },
+              {
+                paths: ["price.intervalCount", "reset.intervalCount"],
+                default: "",
+                defaultWhen: { component: 2, value: 1 }
+              }
+            ]
+          }
+        },
+        variants: {
+          items: {
+            properties: {
+              processors: { mapping: true, sourcePath: ["plan", "processors"] }
+            }
+          },
+          identity: {
+            responseField: "mappingIdentity",
+            components: [{ paths: ["variantPlanId"], default: "" }]
+          }
+        }
+      }
+    },
     defaults: {
       addOn: false,
       autoEnable: false,
@@ -8678,6 +8718,7 @@ var COLLECTIONS = {
     ]
   },
   rewards: {
+    wireKey: "rewards",
     builder: "reward",
     idField: "id",
     responseIdField: "id",
@@ -8820,6 +8861,7 @@ var COLLECTIONS = {
     ]
   },
   referralPrograms: {
+    wireKey: "referral_programs",
     builder: "referralProgram",
     idField: "id",
     responseIdField: "id",
@@ -8974,6 +9016,10 @@ var scaffoldConfig = ({
   return configPath;
 };
 
+// src/actions/skills/ignoreBundledSkills.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join8, relative as relative2, sep } from "node:path";
+
 // src/actions/skills/skills.ts
 import { spawnSync } from "node:child_process";
 import {
@@ -8988,16 +9034,16 @@ import { dirname as dirname4, join as join7 } from "node:path";
 import chalk3 from "chalk";
 
 // src/generated/skills.ts
-var SKILLS_VERSION = "2.0.11";
+var SKILLS_VERSION = "2.0.12";
 var SKILLS = [
   {
     name: "autumn-setup",
     description: "First-time Autumn setup — install the atmn CLI, connect to an org (sign in, or keyless with no account), turn the user's pricing into autumn.config.ts, and push it to a sandbox org. Use when the user is new to Autumn, pastes an Autumn setup prompt, or asks to set up Autumn, add billing, monetization, subscriptions, usage-based billing, pricing, or plans. If Autumn is already set up, use autumn-catalog instead.",
-    version: "2.0.11",
+    version: "2.0.12",
     markdown: `---
 name: autumn-setup
 description: First-time Autumn setup — install the atmn CLI, connect to an org (sign in, or keyless with no account), turn the user's pricing into autumn.config.ts, and push it to a sandbox org. Use when the user is new to Autumn, pastes an Autumn setup prompt, or asks to set up Autumn, add billing, monetization, subscriptions, usage-based billing, pricing, or plans. If Autumn is already set up, use autumn-catalog instead.
-version: 2.0.11
+version: 2.0.12
 ---
 
 # Setup
@@ -9155,11 +9201,11 @@ Then stop. Don't keep building, don't tour the dashboard, don't deploy anything.
   {
     name: "autumn-catalog",
     description: "Modeling a user's pricing into an Autumn catalog — deciding the structure (plans, variants, add-ons, licenses, credit systems, pooled balances) before writing config, then filling in the numbers. Use when the user describes their pricing or asks to model, change, or push a catalog.",
-    version: "2.0.11",
+    version: "2.0.12",
     markdown: `---
 name: autumn-catalog
 description: Modeling a user's pricing into an Autumn catalog — deciding the structure (plans, variants, add-ons, licenses, credit systems, pooled balances) before writing config, then filling in the numbers. Use when the user describes their pricing or asks to model, change, or push a catalog.
-version: 2.0.11
+version: 2.0.12
 ---
 
 # Catalog
@@ -13041,11 +13087,11 @@ Pitch: "Pro $20/mo or $200/yr — 1,000 messages per month either way."
   {
     name: "autumn-integrate",
     description: "Integrating Autumn into an app's backend — creating customers, billing flows (attach, checkout, upgrade, cancel), gating features with check, recording usage with track, and exposing billing data to the frontend. Use when the user asks to integrate Autumn, add billing/payments to their app, gate features, meter usage, or build checkout/upgrade flows. Requires a pushed catalog; use autumn-catalog first if plans don't exist yet.",
-    version: "2.0.11",
+    version: "2.0.12",
     markdown: `---
 name: autumn-integrate
 description: Integrating Autumn into an app's backend — creating customers, billing flows (attach, checkout, upgrade, cancel), gating features with check, recording usage with track, and exposing billing data to the frontend. Use when the user asks to integrate Autumn, add billing/payments to their app, gate features, meter usage, or build checkout/upgrade flows. Requires a pushed catalog; use autumn-catalog first if plans don't exist yet.
-version: 2.0.11
+version: 2.0.12
 ---
 
 # Integrate
@@ -17569,7 +17615,8 @@ Fail-open is **enabled by default**. When Autumn is unreachable (network errors,
 |--------|-----------------|--------|
 | \`check()\` | \`{ allowed: true }\` | Users retain access to features |
 | \`track()\` | \`{ value: 0, balance: null }\` | Usage event is silently dropped |
-| \`customers.getOrCreate()\` | Sentinel customer with \`id: null\` | Returns a valid but empty customer object |
+
+Customer and entity operations, including \`customers.getOrCreate()\`, \`customers.get()\`, \`entities.get()\`, and \`entities.create()\`, propagate errors even when fail-open is enabled. Only \`check()\` and \`track()\` return fail-open defaults.
 
 When fail-open triggers, the SDK logs a prominent error to your console so you're immediately aware of the issue.
 
@@ -17618,18 +17665,6 @@ const result = await autumn.check({
 // Fail-open response: allowed is always true, customerId is ""
 \`\`\`
 
-When \`customers.getOrCreate()\` fails open, the returned customer will have \`id: null\`:
-
-\`\`\`typescript
-const customer = await autumn.customers.getOrCreate({
-  customerId: "cus_123",
-});
-
-if (customer.id === null) {
-  // Autumn was unreachable, handle gracefully
-}
-\`\`\`
-
 ## Console output
 
 When fail-open triggers, you'll see this in your server logs:
@@ -17654,11 +17689,11 @@ Monitor your logs for this message. If you see it, check [status.useautumn.com](
   {
     name: "autumn-concepts",
     description: "Understanding Autumn's billing objects before acting on them — what a plan version is and what active means, when a trial starts or ends billing, how entity- and seat-scoped subscriptions differ from the customer's own, what a customize diff actually changes, and how caps, overage, and top-ups behave. Load before versioning, editing, or drafting a plan, or when a customer's state does not match the plain reading of their plan.",
-    version: "2.0.11",
+    version: "2.0.12",
     markdown: `---
 name: autumn-concepts
 description: Understanding Autumn's billing objects before acting on them — what a plan version is and what active means, when a trial starts or ends billing, how entity- and seat-scoped subscriptions differ from the customer's own, what a customize diff actually changes, and how caps, overage, and top-ups behave. Load before versioning, editing, or drafting a plan, or when a customer's state does not match the plain reading of their plan.
-version: 2.0.11
+version: 2.0.12
 ---
 
 # Concepts
@@ -18210,6 +18245,30 @@ var updateSkills = ({
   return { updated };
 };
 
+// src/actions/skills/ignoreBundledSkills.ts
+var ignoreBundledSkills = ({
+  repoRoot,
+  configDir
+}) => {
+  const path = relative2(repoRoot, join8(configDir, SKILLS_DIR_NAME));
+  if (isAbsolute2(path) || path === ".." || path.startsWith(`..${sep}`))
+    return;
+  if (/[\r\n]/.test(path))
+    return;
+  const pattern = `/${path.split(sep).join("/").replace(/[\\*?[\] ]/g, "\\$&")}/`;
+  const ignorePath = join8(repoRoot, ".gitignore");
+  const contents = existsSync8(ignorePath) ? readFileSync7(ignorePath, "utf8") : "";
+  if (contents.split(/\r?\n/).includes(pattern))
+    return;
+  const newline = contents.includes(`\r
+`) ? `\r
+` : `
+`;
+  const separator = contents.length > 0 && !contents.endsWith(`
+`) ? newline : "";
+  writeFileSync5(ignorePath, `${contents}${separator}${pattern}${newline}`, "utf8");
+};
+
 // src/actions/init/runInit.ts
 var DEFAULT_PACKAGE_DIR = "packages/autumn";
 var DEFAULT_CONFIG_DIR = "autumn";
@@ -18294,8 +18353,8 @@ var authenticate = async ({
 `);
   return after.info;
 };
-var readJson2 = (path) => JSON.parse(readFileSync7(path, "utf8"));
-var writeJson2 = (path, value) => writeFileSync5(path, `${JSON.stringify(value, null, "\t")}
+var readJson2 = (path) => JSON.parse(readFileSync8(path, "utf8"));
+var writeJson2 = (path, value) => writeFileSync6(path, `${JSON.stringify(value, null, "\t")}
 `, "utf8");
 var packageJsonFor = ({
   name,
@@ -18307,8 +18366,8 @@ var packageJsonFor = ({
   dependencies: { [PACKAGE_NAME]: dependencySpec }
 });
 var ensureRootManifest = ({ repoRoot }) => {
-  const manifestPath = join8(repoRoot, "package.json");
-  if (!existsSync8(manifestPath))
+  const manifestPath = join9(repoRoot, "package.json");
+  if (!existsSync9(manifestPath))
     writeJson2(manifestPath, { name: "autumn", private: true, type: "module" });
   return manifestPath;
 };
@@ -18316,7 +18375,7 @@ var addDependency = ({
   manifestPath,
   dependencySpec
 }) => {
-  if (!existsSync8(manifestPath))
+  if (!existsSync9(manifestPath))
     return false;
   const manifest = readJson2(manifestPath);
   const deps = manifest.dependencies ?? {};
@@ -18330,11 +18389,11 @@ var addDependency = ({
   return true;
 };
 var packageManager = ({ repoRoot }) => {
-  if (existsSync8(join8(repoRoot, "bun.lock")) || existsSync8(join8(repoRoot, "bun.lockb")))
+  if (existsSync9(join9(repoRoot, "bun.lock")) || existsSync9(join9(repoRoot, "bun.lockb")))
     return "bun";
-  if (existsSync8(join8(repoRoot, "pnpm-lock.yaml")))
+  if (existsSync9(join9(repoRoot, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync8(join8(repoRoot, "yarn.lock")))
+  if (existsSync9(join9(repoRoot, "yarn.lock")))
     return "yarn";
   return "npm";
 };
@@ -18373,9 +18432,9 @@ var runInit = async ({
       defaultValue: DEFAULT_PACKAGE_DIR
     });
     configDir = resolve2(repoRoot, chosen);
-    prompter.write(`${done(`Path ${relative2(repoRoot, configDir) || "."}`)}
+    prompter.write(`${done(`Path ${relative3(repoRoot, configDir) || "."}`)}
 `);
-    const existingName = existsSync8(join8(configDir, "package.json")) ? readJson2(join8(configDir, "package.json")).name : undefined;
+    const existingName = existsSync9(join9(configDir, "package.json")) ? readJson2(join9(configDir, "package.json")).name : undefined;
     packageName = await ask({
       prompter,
       value: name ?? existingName,
@@ -18389,27 +18448,27 @@ var runInit = async ({
   } else {
     const found = resolveProject({ cwd }).configPath;
     configDir = resolve2(repoRoot, path ?? (found === null ? DEFAULT_CONFIG_DIR : dirname5(found)));
-    prompter.write(`${done(`Path ${relative2(repoRoot, configDir) || "."}`)}
+    prompter.write(`${done(`Path ${relative3(repoRoot, configDir) || "."}`)}
 `);
   }
-  const configPath = join8(configDir, "autumn.config.ts");
+  const configPath = join9(configDir, "autumn.config.ts");
   mkdirSync3(configDir, { recursive: true });
   const wrote = [];
   let dependencyAdded = false;
-  const manifestPath = join8(configDir, "package.json");
-  if (packageName !== undefined && !existsSync8(manifestPath)) {
+  const manifestPath = join9(configDir, "package.json");
+  if (packageName !== undefined && !existsSync9(manifestPath)) {
     writeJson2(manifestPath, packageJsonFor({ name: packageName, dependencySpec }));
-    wrote.push(`${relative2(repoRoot, manifestPath)}`);
+    wrote.push(`${relative3(repoRoot, manifestPath)}`);
     dependencyAdded = true;
   } else if (addDependency({
-    manifestPath: existsSync8(manifestPath) ? manifestPath : ensureRootManifest({ repoRoot }),
+    manifestPath: existsSync9(manifestPath) ? manifestPath : ensureRootManifest({ repoRoot }),
     dependencySpec
   })) {
     dependencyAdded = true;
     prompter.write(`${done(`Added ${PACKAGE_NAME} to package.json`)}
 `);
   }
-  if (!existsSync8(configPath)) {
+  if (!existsSync9(configPath)) {
     scaffoldConfig({ directory: configDir });
     wrote.push("autumn.config.ts", "features.ts", "plans.ts", "rewards.ts");
   }
@@ -18432,16 +18491,17 @@ var runInit = async ({
   const count = pulled.appended.length + pulled.replaced.length + pulled.deleted.length;
   prompter.write(`${done(count === 0 ? "Sandbox matches the config; nothing to pull" : `Pulled ${count} ${count === 1 ? "entry" : "entries"}`)}
 `);
-  const skillsDir = join8(configDir, SKILLS_DIR_NAME);
+  const skillsDir = join9(configDir, SKILLS_DIR_NAME);
   const { written } = installSkills({ dir: skillsDir, write: () => {} });
-  prompter.write(`${done(`Skills: ${relative2(repoRoot, skillsDir)}/${written.join(", ")}`)}
+  ignoreBundledSkills({ repoRoot, configDir });
+  prompter.write(`${done(`Skills: ${relative3(repoRoot, skillsDir)}/${written.join(", ")}`)}
 `);
   prompter.write(`
 Next:
 `);
   prompter.write(`${hint(`${runner} atmn push`)}          preview your catalog against the sandbox
 `);
-  prompter.write(`${hint(`npx skills add ${relative2(repoRoot, skillsDir)} -y`)}      make the skills visible to your agent
+  prompter.write(`${hint(`npx skills add ${relative3(repoRoot, skillsDir)} -y`)}      make the skills visible to your agent
 `);
   return { repoRoot, configDir, configPath, org };
 };
@@ -18888,33 +18948,33 @@ Wrote ${writtenKeys.join(" and ")} to ${envPath}
 
 // src/actions/pull.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   unlinkSync,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "node:fs";
-import { basename as basename3, dirname as dirname11, join as join12 } from "node:path";
+import { basename as basename3, dirname as dirname11, join as join13 } from "node:path";
 
 // src/config/loadConfig.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync9 } from "node:fs";
-import { dirname as dirname7, join as join10 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "node:fs";
+import { dirname as dirname7, join as join11 } from "node:path";
 
 // src/surgery/fixtureLocation.ts
-import { readFileSync as readFileSync8 } from "node:fs";
-import { dirname as dirname6, relative as relative3 } from "node:path";
+import { readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname6, relative as relative4 } from "node:path";
 
 // src/actions/pull/listSourceFiles.ts
 import { readdirSync } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 var listSourceFiles = ({
   directory
 }) => {
   const files = [];
   const walk = (dir) => {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const path = join9(dir, entry.name);
+      const path = join10(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith("."))
           continue;
@@ -19092,7 +19152,7 @@ var candidateFixtures = ({
     });
   });
 };
-var findFixture = ({
+var findFixtures = ({
   source,
   builder,
   idField,
@@ -19101,6 +19161,7 @@ var findFixture = ({
   allowDynamic = false
 }) => {
   const root = parse3(Lang.TypeScript, source).root();
+  const matches = [];
   for (const { node, object } of candidateFixtures({ root, builder })) {
     const idValue = topLevelPairValue({ object, key: idField });
     if (idValue === null || stringLiteralValue(idValue) !== id)
@@ -19109,10 +19170,11 @@ var findFixture = ({
       continue;
     if (where !== undefined && !satisfiesFixtureConstraints({ object, where }))
       continue;
-    return node;
+    matches.push(node);
   }
-  return null;
+  return matches;
 };
+var findFixture = (params) => findFixtures(params)[0] ?? null;
 var SIMPLE_ESCAPES = {
   n: `
 `,
@@ -19170,7 +19232,7 @@ var topLevelPairValue = ({
     if (member.kind() !== "pair")
       continue;
     const [name, value] = member.namedChildren();
-    if (name?.text() === key && value !== undefined)
+    if (name !== undefined && (name.text() === key || stringLiteralValue(name) === key) && value !== undefined)
       return value;
   }
   return null;
@@ -19196,7 +19258,10 @@ var satisfiesConstraint = ({
   object,
   constraint
 }) => {
-  const pair = object.children().find((child) => child.kind() === "pair" && child.namedChildren()[0]?.text() === constraint.field);
+  const pair = object.children().find((child) => {
+    const key = child.field("key");
+    return child.kind() === "pair" && key !== null && (key.text() === constraint.field || stringLiteralValue(key) === constraint.field);
+  });
   if (pair === undefined)
     return constraint.absentMeans === constraint.equals;
   const value = pair.namedChildren()[1];
@@ -19212,7 +19277,8 @@ var locateFixture = ({
   id,
   internalId,
   where,
-  allowDynamic = false
+  allowDynamic = false,
+  requireUnique = false
 }) => {
   const others = [...files.keys()].filter((file) => file !== configPath);
   const ordered = [configPath, ...others];
@@ -19222,21 +19288,37 @@ var locateFixture = ({
   ];
   const shapes = Array.isArray(builder) ? builder : [builder];
   for (const attempt of attempts) {
+    const matches = new Map;
     for (const file of ordered) {
       const source = files.get(file);
       if (source === undefined)
         continue;
       for (const shape of shapes) {
-        const node = findFixture({
+        const nodes = findFixtures({
           source,
           builder: shape,
           allowDynamic,
           ...attempt
         });
-        if (node !== null)
-          return { file, source, node, builder: shape, ...attempt };
+        for (const node of nodes) {
+          const located = { file, source, node, builder: shape, ...attempt };
+          if (!requireUnique)
+            return located;
+          const range = node.range();
+          const key = JSON.stringify([
+            file,
+            range.start.index,
+            range.end.index
+          ]);
+          matches.set(key, located);
+          if (matches.size > 1)
+            return null;
+        }
       }
     }
+    const match = matches.values().next().value;
+    if (match !== undefined)
+      return match;
   }
   return null;
 };
@@ -19250,16 +19332,16 @@ var fixtureLocation = ({
 }) => {
   const directory = dirname6(configPath);
   const files = new Map;
-  files.set(configPath, readFileSync8(configPath, "utf8"));
+  files.set(configPath, readFileSync9(configPath, "utf8"));
   for (const file of listSourceFiles({ directory })) {
     if (!files.has(file))
-      files.set(file, readFileSync8(file, "utf8"));
+      files.set(file, readFileSync9(file, "utf8"));
   }
   const located = locateFixture({ configPath, files, builder, idField, id });
   if (located === null)
     return null;
   return {
-    file: relative3(directory, located.file),
+    file: relative4(directory, located.file),
     line: located.node.range().start.line + 1
   };
 };
@@ -19300,8 +19382,8 @@ Run \`${configPackageName()} init\` to create one, or pass -c <dir>.`);
 var findConfigPath = ({ dirs }) => {
   for (const dir of dirs) {
     for (const filename of CONFIG_FILENAMES2) {
-      const path = join10(dir, filename);
-      if (existsSync9(path))
+      const path = join11(dir, filename);
+      if (existsSync10(path))
         return path;
     }
   }
@@ -19364,10 +19446,10 @@ var loadConfig = async ({
   dirs,
   configPath
 }) => {
-  const path = configPath !== undefined ? existsSync9(configPath) ? configPath : null : findConfigPath({ dirs });
+  const path = configPath !== undefined ? existsSync10(configPath) ? configPath : null : findConfigPath({ dirs });
   if (!path)
     throw new ConfigNotFoundError(configPath ? [configPath] : dirs);
-  if (isLegacyConfigText({ text: readFileSync9(path, "utf8") })) {
+  if (isLegacyConfigText({ text: readFileSync10(path, "utf8") })) {
     throw new LegacyConfigError({ path });
   }
   let module;
@@ -19417,7 +19499,7 @@ var looksLikeV2Config = ({
 };
 
 // src/project/chooseConfigDir.ts
-import { relative as relative4, resolve as resolve3 } from "node:path";
+import { relative as relative5, resolve as resolve3 } from "node:path";
 var defaultConfigDirName = ({ cwd }) => findRepoLayout({ cwd }).hasWorkspaces ? "packages/autumn/" : "autumn/";
 var configFiles = ["autumn.config.ts", ...Object.keys(COLLECTION_FILES)];
 var chooseConfigDir = async ({
@@ -19438,7 +19520,7 @@ var chooseConfigDir = async ({
     defaultValue: fallback
   });
   const configDir = resolve3(repoRoot, chosen);
-  prompter.write(`${done(`Path ${relative4(repoRoot, configDir) || "."}`)}
+  prompter.write(`${done(`Path ${relative5(repoRoot, configDir) || "."}`)}
 `);
   return { configDir, repoRoot };
 };
@@ -19784,9 +19866,496 @@ var emitFixture = ({
 `);
 };
 
-// src/surgery/appendToBinding.ts
+// src/generated/mappingAssignments.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var valueAt = ({
+  value,
+  path
+}) => {
+  for (const key of path) {
+    if (typeof value === "symbol")
+      return value;
+    value = isRecord(value) ? value[key] : undefined;
+  }
+  return value;
+};
+var mappingIdentityOf = ({
+  value,
+  identity
+}) => {
+  const values = [];
+  for (const component of identity.components) {
+    let selected;
+    for (const path of component.paths) {
+      selected = valueAt({ value, path: path.split(".") });
+      if (selected !== undefined && selected !== null)
+        break;
+    }
+    if (selected === undefined || selected === null) {
+      selected = component.defaultWhen && values[component.defaultWhen.component] ? component.defaultWhen.value : component.default;
+    }
+    if (typeof selected !== "string" && typeof selected !== "number")
+      return;
+    values.push(selected);
+  }
+  return JSON.stringify(values);
+};
+var hasMappings = ({
+  node,
+  value,
+  local = false
+}) => {
+  if (value === undefined || value === null)
+    return false;
+  if (node.mapping)
+    return true;
+  const items = node.items;
+  if (items)
+    return Array.isArray(value) && value.some((entry) => hasMappings({ node: items, value: entry, local }));
+  return Object.entries(node.properties ?? {}).some(([key, child]) => hasMappings({
+    node: child,
+    value: valueAt({
+      value,
+      path: local ? [key] : child.sourcePath ?? [key]
+    }),
+    local
+  }));
+};
+var mappingAssignments = ({
+  projection,
+  local,
+  remote
+}) => {
+  const assignments = [];
+  const errors = [];
+  const visit = ({
+    node,
+    localValue,
+    remoteValue,
+    path
+  }) => {
+    if (node.mapping) {
+      if (remoteValue === undefined || remoteValue === null) {
+        if (localValue !== undefined)
+          assignments.push({ path, text: null });
+        return;
+      }
+      assignments.push({ path, text: JSON.stringify(remoteValue) });
+      return;
+    }
+    if (!hasMappings({ node, value: remoteValue }) && !hasMappings({ node, value: localValue, local: true }))
+      return;
+    if (remoteValue === undefined || remoteValue === null)
+      return;
+    if (typeof localValue === "symbol") {
+      errors.push(`${path.join(".")}: cannot address a computed value`);
+      return;
+    }
+    if (localValue === undefined || localValue === null) {
+      errors.push(`${path.join(".")}: mapping container is not stated in the fixture`);
+      return;
+    }
+    if (node.items) {
+      if (!Array.isArray(localValue) || !Array.isArray(remoteValue) || !node.identity) {
+        errors.push(`${path.join(".")}: array identity is unavailable`);
+        return;
+      }
+      const identity = node.identity;
+      const localKeys = localValue.map((value) => mappingIdentityOf({ value, identity }));
+      const remoteKeys = remoteValue.map((value) => valueAt({ value, path: identity.responseField.split(".") }));
+      for (const [index, value] of localValue.entries()) {
+        const key = localKeys[index];
+        const matches = remoteKeys.flatMap((candidate, position) => candidate === key ? [position] : []);
+        const match = matches[0];
+        if (key === undefined || match === undefined || localKeys.filter((candidate) => candidate === key).length !== 1 || matches.length !== 1) {
+          errors.push(`${[...path, index].join(".")}: no unique server identity match`);
+          continue;
+        }
+        visit({
+          node: node.items,
+          localValue: value,
+          remoteValue: remoteValue[match],
+          path: [...path, index]
+        });
+      }
+      return;
+    }
+    for (const [key, child] of Object.entries(node.properties ?? {})) {
+      visit({
+        node: child,
+        localValue: valueAt({ value: localValue, path: [key] }),
+        remoteValue: valueAt({
+          value: remoteValue,
+          path: child.sourcePath ?? [key]
+        }),
+        path: [...path, key]
+      });
+    }
+  };
+  visit({ node: projection, localValue: local, remoteValue: remote, path: [] });
+  return { assignments, errors };
+};
+
+// src/surgery/patchFixturePaths.ts
+import { isDeepStrictEqual } from "node:util";
 import { Lang as Lang2, parse as parse4 } from "@ast-grep/napi";
 
+// src/surgery/appendPropertyEdit.ts
+var isMember = (child) => child.kind() === "pair" || child.kind() === "spread_element" || child.kind() === "shorthand_property_identifier";
+var appendPropertyEdit = ({
+  source,
+  object,
+  pair
+}) => {
+  const closing = object.range().end.index - 1;
+  const multiline = source.slice(object.range().start.index, closing).includes(`
+`);
+  const members = object.children().filter(isMember);
+  const last = members[members.length - 1];
+  if (last === undefined) {
+    return multiline ? {
+      startPos: lineStartOf(source, closing),
+      endPos: lineStartOf(source, closing),
+      insertedText: `${leadingIndentOfLine(source, object.range().start.index)}	${pair},
+`
+    } : {
+      startPos: object.range().start.index + 1,
+      endPos: closing,
+      insertedText: ` ${pair} `
+    };
+  }
+  const lastEnd = last.range().end.index;
+  const between = source.slice(lastEnd, closing);
+  const trailingComma = between.trimStart().startsWith(",");
+  const afterComma = trailingComma ? lastEnd + between.indexOf(",") + 1 : lastEnd;
+  if (multiline) {
+    const indent = leadingIndentOfLine(source, last.range().start.index);
+    return {
+      startPos: afterComma,
+      endPos: afterComma,
+      insertedText: trailingComma ? `
+${indent}${pair},` : `,
+${indent}${pair},`
+    };
+  }
+  return {
+    startPos: afterComma,
+    endPos: afterComma,
+    insertedText: trailingComma ? ` ${pair},` : `, ${pair}`
+  };
+};
+var holdsSpread = ({ object }) => object.children().some((child) => child.kind() === "spread_element");
+
+// src/surgery/readFixtureValue.ts
+var DYNAMIC_VALUE = Symbol("dynamic-fixture-value");
+var fixtureKeyOf = ({ node }) => {
+  if (node.kind() === "property_identifier" || node.kind() === "shorthand_property_identifier")
+    return node.text();
+  return stringLiteralValue(node);
+};
+var fixtureArrayElements = ({
+  node
+}) => {
+  const elements = [];
+  let expectsElement = true;
+  for (const child of node.children()) {
+    const kind = child.kind();
+    if (kind === "[" || kind === "]" || kind === "comment")
+      continue;
+    if (kind === ",") {
+      if (expectsElement)
+        return null;
+      expectsElement = true;
+      continue;
+    }
+    if (!expectsElement || kind === "spread_element")
+      return null;
+    elements.push(child);
+    expectsElement = false;
+  }
+  return elements;
+};
+var readFixtureValue = ({
+  node,
+  builders = []
+}) => {
+  const kind = node.kind();
+  if (kind === "call_expression" && builders.includes(node.field("function")?.text() ?? "")) {
+    const args = node.field("arguments")?.namedChildren().filter((child) => child.kind() !== "comment");
+    return args?.length === 1 && args[0]?.kind() === "object" ? readFixtureValue({ node: args[0], builders }) : DYNAMIC_VALUE;
+  }
+  if (kind === "string")
+    return stringLiteralValue(node) ?? DYNAMIC_VALUE;
+  if (kind === "true")
+    return true;
+  if (kind === "false")
+    return false;
+  if (kind === "null")
+    return null;
+  if (kind === "number" || kind === "unary_expression" && /^[+-]\s*[\d.]/.test(node.text())) {
+    const value2 = Number(node.text().replaceAll("_", "").replace(/\s/g, ""));
+    return Number.isFinite(value2) ? value2 : DYNAMIC_VALUE;
+  }
+  if (kind === "array") {
+    const elements = fixtureArrayElements({ node });
+    return elements === null ? DYNAMIC_VALUE : elements.map((element) => readFixtureValue({ node: element, builders }));
+  }
+  if (kind !== "object")
+    return DYNAMIC_VALUE;
+  const value = {};
+  for (const member of node.namedChildren()) {
+    if (member.kind() === "comment")
+      continue;
+    const shorthand = member.kind() === "shorthand_property_identifier";
+    if (member.kind() !== "pair" && !shorthand)
+      return DYNAMIC_VALUE;
+    const keyNode = shorthand ? member : member.field("key");
+    const key = keyNode === null ? null : fixtureKeyOf({ node: keyNode });
+    if (key === null || Object.getOwnPropertyDescriptor(value, key) !== undefined)
+      return DYNAMIC_VALUE;
+    const child = member.field("value");
+    Object.defineProperty(value, key, {
+      value: child === null ? DYNAMIC_VALUE : readFixtureValue({ node: child, builders }),
+      enumerable: true
+    });
+  }
+  return value;
+};
+
+// src/surgery/patchFixturePaths.ts
+var isDynamic = (value) => {
+  if (value === DYNAMIC_VALUE)
+    return true;
+  if (value === null || typeof value !== "object")
+    return false;
+  return Object.values(value).some(isDynamic);
+};
+var matchesLiteral = ({
+  value,
+  text
+}) => {
+  const root = parse4(Lang2.TypeScript, `const value = (${text});`).root();
+  if (root.find({ rule: { kind: "ERROR" } }) !== null)
+    return false;
+  const expression = root.find({ rule: { kind: "variable_declarator" } })?.field("value");
+  if (expression?.kind() !== "parenthesized_expression")
+    return false;
+  const literal = expression.namedChildren().filter((node) => node.kind() !== "comment");
+  if (literal.length !== 1 || literal[0] === undefined)
+    return false;
+  const proposed = readFixtureValue({ node: literal[0] });
+  return !isDynamic(proposed) && isDeepStrictEqual(value, proposed);
+};
+var removeMemberEdits = ({ member }) => {
+  const siblings = member.parent()?.children() ?? [];
+  const index = siblings.findIndex((sibling) => sibling.range().start.index === member.range().start.index);
+  const next = siblings.slice(index + 1).find((sibling) => sibling.kind() !== "comment");
+  const previous = siblings.slice(0, index).reverse().find((sibling) => sibling.kind() !== "comment");
+  const comma = next?.kind() === "," ? next : previous?.kind() === "," ? previous : null;
+  return [member, ...comma === null ? [] : [comma]].map((node) => ({
+    startPos: node.range().start.index,
+    endPos: node.range().end.index,
+    insertedText: ""
+  }));
+};
+var pathEdits = ({
+  source,
+  object,
+  path,
+  text,
+  builders
+}) => {
+  let current = object;
+  for (let index = 0;index < path.length; index += 1) {
+    if (current.kind() === "call_expression" && builders.includes(current.field("function")?.text() ?? "")) {
+      const args = current.field("arguments")?.namedChildren().filter((child) => child.kind() !== "comment");
+      if (args?.length !== 1 || args[0]?.kind() !== "object")
+        return "dynamic-value";
+      current = args[0];
+    }
+    const segment = path[index];
+    const last = index === path.length - 1;
+    let member;
+    let value;
+    if (typeof segment === "number") {
+      if (current.kind() !== "array" || !Number.isSafeInteger(segment) || segment < 0)
+        return "invalid-array-path";
+      const elements = fixtureArrayElements({ node: current });
+      if (elements === null)
+        return "dynamic-array";
+      value = elements[segment];
+      if (value === undefined)
+        return "missing-array-element";
+      if (last && text === null)
+        return "array-element-removal";
+    } else {
+      if (current.kind() !== "object")
+        return "non-object-container";
+      if (readFixtureValue({ node: current }) === DYNAMIC_VALUE)
+        return "ambiguous-object";
+      member = current.namedChildren().find((child) => {
+        const key = child.kind() === "pair" ? child.field("key") : child;
+        return key !== null && fixtureKeyOf({ node: key }) === segment;
+      });
+      if (member === undefined) {
+        if (text === null)
+          return [];
+        const remaining = path.slice(index + 1);
+        if (remaining.some((key) => typeof key === "number"))
+          return "missing-array-element";
+        let inserted = text;
+        for (const key of remaining.reverse())
+          inserted = `{ ${JSON.stringify(key)}: ${inserted} }`;
+        const pair = `${JSON.stringify(segment)}: ${inserted}`;
+        const members = current.namedChildren().filter((child) => child.kind() !== "comment");
+        if (members.length === 0) {
+          const closing = current.range().end.index - 1;
+          return [
+            { startPos: closing, endPos: closing, insertedText: ` ${pair} ` }
+          ];
+        }
+        return [appendPropertyEdit({ source, object: current, pair })];
+      }
+      value = member.field("value");
+    }
+    if (value == null)
+      return "dynamic-value";
+    if (!last) {
+      current = value;
+      continue;
+    }
+    const currentValue = readFixtureValue({ node: value });
+    if (isDynamic(currentValue))
+      return "dynamic-value";
+    if (text === null)
+      return member === undefined ? "array-element-removal" : removeMemberEdits({ member });
+    if (matchesLiteral({ value: currentValue, text }))
+      return [];
+    return [
+      {
+        startPos: value.range().start.index,
+        endPos: value.range().end.index,
+        insertedText: text
+      }
+    ];
+  }
+  return "empty-path";
+};
+var patchFixturePaths = ({
+  source,
+  builder,
+  idField,
+  id,
+  where,
+  assignments,
+  builders = []
+}) => {
+  const selector = { builder, idField, id, where, allowDynamic: true };
+  const initial = findFixtures({ source, ...selector });
+  if (initial.length === 0)
+    return null;
+  const skipped = [];
+  for (const assignment of assignments) {
+    const matches = findFixtures({ source, ...selector });
+    const match = matches[0];
+    const object = matches.length === 1 && match !== undefined ? fixtureObjectOf(match) : null;
+    const edits = object === null ? "ambiguous-fixture" : pathEdits({ source, object, builders, ...assignment });
+    if (typeof edits === "string") {
+      skipped.push({ path: assignment.path, reason: edits });
+      continue;
+    }
+    source = parse4(Lang2.TypeScript, source).root().commitEdits(edits);
+  }
+  return { source, skipped };
+};
+
+// src/actions/pull/applyMappings.ts
+var applyMappings = ({
+  catalog,
+  configPath,
+  files
+}) => {
+  const replaced = [];
+  const unlocated = [];
+  const builders = Object.values(NESTED_FIXTURES).map(({ builder }) => builder);
+  for (const [collection, collectionSpec] of Object.entries(COLLECTIONS)) {
+    const rows = catalog[collection];
+    if (!collectionSpec.pull || !Array.isArray(rows))
+      continue;
+    for (const entry of rows) {
+      const { spec, row } = resolveBranch({ spec: collectionSpec, row: entry });
+      const id = row[spec.responseIdField];
+      if (!spec.mappings || typeof id !== "string" || row.archived === true)
+        continue;
+      const key = spec.versioned ? `${id}@${row.versionSlug ?? "v1"}` : id;
+      const located = locateFixture({
+        configPath,
+        files,
+        builder: spec.builder,
+        idField: spec.idField,
+        id,
+        internalId: typeof row.internalId === "string" ? row.internalId : undefined,
+        where: spec.versioned ? [
+          {
+            field: "versionSlug",
+            equals: typeof row.versionSlug === "string" ? row.versionSlug : "v1",
+            absentMeans: "v1"
+          }
+        ] : undefined,
+        allowDynamic: true,
+        requireUnique: true
+      });
+      if (!located) {
+        unlocated.push({
+          collection,
+          id: key,
+          action: "cannot locate the fixture to write processor mappings"
+        });
+        continue;
+      }
+      const planned = mappingAssignments({
+        projection: spec.mappings,
+        local: readFixtureValue({
+          node: located.node,
+          builders: [spec.builder, ...builders]
+        }),
+        remote: row
+      });
+      if (planned.errors.length) {
+        unlocated.push(...planned.errors.map((action) => ({ collection, id: key, action })));
+        continue;
+      }
+      if (!planned.assignments.length)
+        continue;
+      const patched = patchFixturePaths({
+        source: located.source,
+        builder: located.builder,
+        idField: located.idField,
+        id: located.id,
+        where: located.where,
+        builders,
+        assignments: planned.assignments
+      });
+      if (!patched || patched.skipped.length) {
+        unlocated.push({
+          collection,
+          id: key,
+          action: "cannot safely splice processor mappings into a computed or ambiguous value"
+        });
+        continue;
+      }
+      if (patched.source === located.source)
+        continue;
+      files.set(located.file, patched.source);
+      replaced.push(key);
+    }
+  }
+  return { replaced, unlocated };
+};
+
+// src/surgery/appendToBinding.ts
+import { Lang as Lang3, parse as parse5 } from "@ast-grep/napi";
+
 // src/surgery/appendToArray.ts
 var appendElementToArray = ({
   source,
@@ -19887,7 +20456,7 @@ var appendToBinding = ({
   name,
   text
 }) => {
-  const root = parse4(Lang2.TypeScript, source).root();
+  const root = parse5(Lang3.TypeScript, source).root();
   const array = findArrayBinding({ root, name });
   if (array === null)
     return null;
@@ -19895,13 +20464,13 @@ var appendToBinding = ({
 };
 
 // src/surgery/appendToCollection.ts
-import { Lang as Lang3, parse as parse5 } from "@ast-grep/napi";
+import { Lang as Lang4, parse as parse6 } from "@ast-grep/napi";
 var appendToCollection = ({
   source,
   collection,
   text
 }) => {
-  const root = parse5(Lang3.TypeScript, source).root();
+  const root = parse6(Lang4.TypeScript, source).root();
   const anchor = root.find(`atmn({ $$$, ${collection}: [$$$ITEMS], $$$ })`) ?? root.find(`atmn({ ${collection}: [$$$ITEMS] })`);
   if (anchor === null)
     return null;
@@ -19926,55 +20495,7 @@ var collectionArray = ({
 };
 
 // src/surgery/appendToFixtureArray.ts
-import { Lang as Lang4, parse as parse6 } from "@ast-grep/napi";
-
-// src/surgery/appendPropertyEdit.ts
-var isMember = (child) => child.kind() === "pair" || child.kind() === "spread_element";
-var appendPropertyEdit = ({
-  source,
-  object,
-  pair
-}) => {
-  const closing = object.range().end.index - 1;
-  const multiline = source.slice(object.range().start.index, closing).includes(`
-`);
-  const members = object.children().filter(isMember);
-  const last = members[members.length - 1];
-  if (last === undefined) {
-    return multiline ? {
-      startPos: lineStartOf(source, closing),
-      endPos: lineStartOf(source, closing),
-      insertedText: `${leadingIndentOfLine(source, object.range().start.index)}	${pair},
-`
-    } : {
-      startPos: object.range().start.index + 1,
-      endPos: closing,
-      insertedText: ` ${pair} `
-    };
-  }
-  const lastEnd = last.range().end.index;
-  const between = source.slice(lastEnd, closing);
-  const trailingComma = between.trimStart().startsWith(",");
-  const afterComma = trailingComma ? lastEnd + between.indexOf(",") + 1 : lastEnd;
-  if (multiline) {
-    const indent = leadingIndentOfLine(source, last.range().start.index);
-    return {
-      startPos: afterComma,
-      endPos: afterComma,
-      insertedText: trailingComma ? `
-${indent}${pair},` : `,
-${indent}${pair},`
-    };
-  }
-  return {
-    startPos: afterComma,
-    endPos: afterComma,
-    insertedText: trailingComma ? ` ${pair},` : `, ${pair}`
-  };
-};
-var holdsSpread = ({ object }) => object.children().some((child) => child.kind() === "spread_element");
-
-// src/surgery/appendToFixtureArray.ts
+import { Lang as Lang5, parse as parse7 } from "@ast-grep/napi";
 var appendToFixtureArray = ({
   source,
   builder,
@@ -19997,7 +20518,7 @@ var appendToFixtureArray = ({
   const object = fixtureObjectOf(call);
   if (object === null)
     return null;
-  const root = parse6(Lang4.TypeScript, source).root();
+  const root = parse7(Lang5.TypeScript, source).root();
   const pair = object.children().find((member) => member.kind() === "pair" && member.namedChildren()[0]?.text() === property);
   if (pair === undefined) {
     const seeded = root.commitEdits([
@@ -20085,12 +20606,12 @@ var exportRemovalEdit = ({
 };
 
 // src/surgery/deleteReference.ts
-import { Lang as Lang5, parse as parse7 } from "@ast-grep/napi";
+import { Lang as Lang6, parse as parse8 } from "@ast-grep/napi";
 var deleteReference = ({
   source,
   name
 }) => {
-  const root = parse7(Lang5.TypeScript, source).root();
+  const root = parse8(Lang6.TypeScript, source).root();
   const edits = [];
   for (const identifier of root.findAll({
     rule: { kind: "identifier", pattern: name }
@@ -20124,7 +20645,7 @@ var deleteReference = ({
 };
 
 // src/surgery/ensureBuilderImport.ts
-import { Lang as Lang6, parse as parse8 } from "@ast-grep/napi";
+import { Lang as Lang7, parse as parse9 } from "@ast-grep/napi";
 var NAMED_IMPORT = /^import\s+\{([^}]*)\}\s*from\s*["']([^"']+)["']/;
 var GENERATED_MODULE = /\/generated\/[A-Za-z]+$/;
 var ensureBuilderImport = ({
@@ -20132,7 +20653,7 @@ var ensureBuilderImport = ({
   builder,
   collection
 }) => {
-  const root = parse8(Lang6.TypeScript, source).root();
+  const root = parse9(Lang7.TypeScript, source).root();
   const statements = root.findAll({ rule: { kind: "import_statement" } });
   const parsed = statements.flatMap((statement) => {
     const match = NAMED_IMPORT.exec(statement.text());
@@ -20170,9 +20691,9 @@ var ensureBuilderImport = ({
 };
 
 // src/surgery/insertCollection.ts
-import { Lang as Lang7, parse as parse9 } from "@ast-grep/napi";
+import { Lang as Lang8, parse as parse10 } from "@ast-grep/napi";
 var rootSpreadNames = ({ source }) => {
-  const root = parse9(Lang7.TypeScript, source).root();
+  const root = parse10(Lang8.TypeScript, source).root();
   const call = root.find("atmn($ARG)");
   const object = call?.getMatch("ARG");
   if (object === null || object === undefined || object.kind() !== "object")
@@ -20183,7 +20704,7 @@ var insertCollection = ({
   source,
   collection
 }) => {
-  const root = parse9(Lang7.TypeScript, source).root();
+  const root = parse10(Lang8.TypeScript, source).root();
   const call = root.find("atmn($ARG)");
   if (call === null)
     return null;
@@ -20237,7 +20758,7 @@ ${indent}${collection}: [],`
 };
 
 // src/surgery/patchFixtureProperty.ts
-import { Lang as Lang8, parse as parse10 } from "@ast-grep/napi";
+import { Lang as Lang9, parse as parse11 } from "@ast-grep/napi";
 var pairFor = ({
   object,
   property
@@ -20328,7 +20849,7 @@ var patchFixtureProperty = ({
   const object = fixtureObjectOf(call);
   if (object === null)
     return null;
-  const root = parse10(Lang8.TypeScript, source).root();
+  const root = parse11(Lang9.TypeScript, source).root();
   const pair = pairFor({ object, property });
   if (text === null) {
     if (pair === null)
@@ -20433,7 +20954,7 @@ var changedFixtureKeys = ({
 
 // src/actions/pull/resolveCollectionTarget.ts
 import { dirname as dirname8, resolve as resolve4 } from "node:path";
-import { Lang as Lang9, parse as parse11 } from "@ast-grep/napi";
+import { Lang as Lang10, parse as parse12 } from "@ast-grep/napi";
 var NAMED_IMPORT2 = /import\s+(?:type\s+)?\{([^}]*)\}\s*from\s*["']([^"']+)["']/;
 var resolveCollectionTarget = ({
   configPath,
@@ -20444,7 +20965,7 @@ var resolveCollectionTarget = ({
   const source = files.get(configPath);
   if (source === undefined)
     return null;
-  const root = parse11(Lang9.TypeScript, source).root();
+  const root = parse12(Lang10.TypeScript, source).root();
   const value = collectionValue({ root, collection });
   if (value === null)
     return null;
@@ -20484,7 +21005,7 @@ var resolveBinding = ({
   });
   if (file === null)
     return null;
-  const module = parse11(Lang9.TypeScript, files.get(file) ?? "").root();
+  const module = parse12(Lang10.TypeScript, files.get(file) ?? "").root();
   return findLiteralBinding({
     root: module,
     name: imported.exportedName,
@@ -20956,7 +21477,7 @@ var applyPreview = ({
 };
 
 // src/surgery/patchSingletonProperty.ts
-import { Lang as Lang10, parse as parse12 } from "@ast-grep/napi";
+import { Lang as Lang11, parse as parse13 } from "@ast-grep/napi";
 var atmnObject = (root) => {
   const object = root.find("atmn($ARG)")?.getMatch("ARG") ?? null;
   return object !== null && object.kind() === "object" ? object : null;
@@ -21030,7 +21551,7 @@ var patchSingletonProperty = ({
   block,
   edit
 }) => {
-  const root = parse12(Lang10.TypeScript, source).root();
+  const root = parse13(Lang11.TypeScript, source).root();
   const object = blockObject({ root, block });
   if (object === null)
     return null;
@@ -21067,7 +21588,7 @@ var insertSingleton = ({
   source,
   singleton
 }) => {
-  const root = parse12(Lang10.TypeScript, source).root();
+  const root = parse13(Lang11.TypeScript, source).root();
   const object = atmnObject(root);
   if (object === null)
     return null;
@@ -21080,7 +21601,7 @@ var insertSingleton = ({
   const withArray = insertCollection({ source, collection: singleton });
   if (withArray === null || withArray === source)
     return withArray;
-  const seededRoot = parse12(Lang10.TypeScript, withArray).root();
+  const seededRoot = parse13(Lang11.TypeScript, withArray).root();
   const seeded = atmnObject(seededRoot);
   const pair = seeded === null ? null : pairFor2({ object: seeded, key: singleton });
   const value = pair?.namedChildren()[1];
@@ -21170,8 +21691,8 @@ var applySettingsPreview = ({
 };
 
 // src/actions/pull/rewriteConfig.ts
-import { existsSync as existsSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname9, join as join11 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname9, join as join12 } from "node:path";
 var PACKAGE_NAMES = ["atmn", "atmn-nightly"];
 var importsConfigPackage = ({
   text,
@@ -21186,17 +21707,17 @@ var rewriteConfig = ({
   const rewritten = [];
   const kept = [];
   for (const [file, collections] of Object.entries(COLLECTION_FILES)) {
-    const path = join11(configDir, file);
-    const isUsers = existsSync10(path) && !importsConfigPackage({ text: readFileSync10(path, "utf8"), imports });
+    const path = join12(configDir, file);
+    const isUsers = existsSync11(path) && !importsConfigPackage({ text: readFileSync11(path, "utf8"), imports });
     if (isUsers) {
       kept.push(path);
       continue;
     }
-    writeFileSync6(path, collectionFileSource({ collections, imports }), "utf8");
+    writeFileSync7(path, collectionFileSource({ collections, imports }), "utf8");
     importedFiles.add(file);
     rewritten.push(path);
   }
-  writeFileSync6(configPath, rootSource({ imports, importedFiles }), "utf8");
+  writeFileSync7(configPath, rootSource({ imports, importedFiles }), "utf8");
   return { rewritten: [configPath, ...rewritten], kept };
 };
 
@@ -21733,7 +22254,7 @@ var previewIsEmpty = ({
 }) => !(preview.features ?? []).some(rowHasWork) && !(preview.plans ?? []).some(rowHasWork) && !(preview.rewards ?? []).some(rowHasWork) && !(preview.referralPrograms ?? []).some(rowHasWork) && !settingsHaveWork({ settings: preview.settings });
 
 // src/actions/push/backfillInternalIds.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
 import { dirname as dirname10 } from "node:path";
 
 // src/surgery/insertFirstProperty.ts
@@ -21784,7 +22305,7 @@ ${indent}`
 };
 
 // src/surgery/setFixtureProperty.ts
-import { Lang as Lang11, parse as parse13 } from "@ast-grep/napi";
+import { Lang as Lang12, parse as parse14 } from "@ast-grep/napi";
 var setFixtureProperty = ({
   source,
   builder,
@@ -21813,7 +22334,7 @@ var setFixtureProperty = ({
     const [key, current] = member.namedChildren();
     if (key?.text() !== property || current === undefined)
       continue;
-    const root = parse13(Lang11.TypeScript, source).root();
+    const root = parse14(Lang12.TypeScript, source).root();
     return root.commitEdits([
       {
         startPos: current.range().start.index,
@@ -21863,10 +22384,10 @@ var backfillInternalIds = ({
   configPath
 }) => {
   const files = new Map;
-  files.set(configPath, readFileSync11(configPath, "utf8"));
+  files.set(configPath, readFileSync12(configPath, "utf8"));
   for (const file of listSourceFiles({ directory: dirname10(configPath) })) {
     if (!files.has(file))
-      files.set(file, readFileSync11(file, "utf8"));
+      files.set(file, readFileSync12(file, "utf8"));
   }
   const originals = new Map(files);
   const backfilled = [];
@@ -22100,7 +22621,7 @@ var backfillInternalIds = ({
   }
   for (const [file, source] of files) {
     if (source !== originals.get(file))
-      writeFileSync7(file, source, "utf8");
+      writeFileSync8(file, source, "utf8");
   }
   return { backfilled, slugged };
 };
@@ -22426,7 +22947,7 @@ var runPull = async ({
     write(`This rewrites autumn.config.ts and the features.ts, plans.ts and rewards.ts beside it from your org's catalog. Other files are left alone. Re-run with --yes to overwrite.
 `);
     return {
-      configPath: project.configPath ?? join12(project.configDir, "autumn.config.ts"),
+      configPath: project.configPath ?? join13(project.configDir, "autumn.config.ts"),
       appended: [],
       replaced: [],
       deleted: []
@@ -22439,7 +22960,7 @@ var runPull = async ({
   if (project.configPath === null) {
     const chosen = await chooseConfigDir({ cwd, prompter });
     scaffoldDir = chosen.configDir;
-    scaffoldPath = join12(scaffoldDir, "autumn.config.ts");
+    scaffoldPath = join13(scaffoldDir, "autumn.config.ts");
     if (scaffoldDir !== cwd && writeRootMarker({ repoRoot: chosen.repoRoot, configPath: scaffoldPath }))
       prompter.write(`${done("Recorded in package.json so atmn finds it from anywhere")}
 `);
@@ -22460,11 +22981,11 @@ var runPull = async ({
     client.previewUpdateOrganization(singletons.settings ?? { config: {} })
   ]);
   const files = new Map;
-  files.set(configPath, readFileSync12(configPath, "utf8"));
+  files.set(configPath, readFileSync13(configPath, "utf8"));
   for (const file of listSourceFiles({ directory: dirname11(configPath) })) {
     if (file === configPath || files.has(file))
       continue;
-    files.set(file, readFileSync12(file, "utf8"));
+    files.set(file, readFileSync13(file, "utf8"));
   }
   const originals = new Map(files);
   const appended = [];
@@ -22512,16 +23033,30 @@ var runPull = async ({
       action: `set by hand: \`${singleton}\` is not an object literal`
     })));
   }
+  if (includeMappings) {
+    const managedCatalog = Object.fromEntries(Object.entries(COLLECTIONS).filter(([, spec]) => spec.wireKey !== undefined && wire[spec.wireKey] !== undefined).map(([collection]) => [collection, catalogRows[collection]]));
+    const mapped = applyMappings({
+      catalog: managedCatalog,
+      configPath,
+      files
+    });
+    unlocated.push(...mapped.unlocated);
+    for (const id of mapped.replaced) {
+      if (!replaced.includes(id) && !appended.includes(id))
+        replaced.push(id);
+      lines.push(`↳ wrote processor mappings into ${id}`);
+    }
+  }
   if (unlocated.length > 0)
     throw new UnlocatableFixturesError({ unlocated });
   for (const [file, source] of files) {
     if (source === originals.get(file))
       continue;
     mkdirSync4(dirname11(file), { recursive: true });
-    writeFileSync8(file, source, "utf8");
+    writeFileSync9(file, source, "utf8");
     if (!originals.has(file)) {
-      const keep = join12(dirname11(file), ".gitkeep");
-      if (existsSync11(keep))
+      const keep = join13(dirname11(file), ".gitkeep");
+      if (existsSync12(keep))
         unlinkSync(keep);
     }
   }
@@ -23008,11 +23543,11 @@ ${hint(flagHint)}
 `);
     throw new NeedsInputError(flagHint);
   }
-  return join13(project.configDir, SKILLS_DIR_NAME);
+  return join14(project.configDir, SKILLS_DIR_NAME);
 };
 var writeStaleSkillsHint = ({ command }) => {
   const stale = staleSkillsHint({
-    dir: join13(projectOf({ command }).configDir, SKILLS_DIR_NAME)
+    dir: join14(projectOf({ command }).configDir, SKILLS_DIR_NAME)
   });
   if (stale !== null)
     process.stdout.write(`${stale}
@@ -23196,6 +23731,8 @@ Nothing applied. Re-run with --yes to apply these changes.
   skills.command("install").description("write the skills next to your config; --link runs npx skills add").option("--dir <dir>", "write here instead of <config folder>/skills").option("--link", "run `npx skills add <dir> --all` afterwards").action(async (options, command) => {
     const dir = skillsDirOf({ command, dir: options.dir });
     installSkills({ dir, write: (text) => process.stdout.write(text) });
+    if (options.dir === undefined)
+      ignoreBundledSkills(projectOf({ command }));
     if (options.link === true)
       await linkSkills({
         dir,
@@ -23205,6 +23742,8 @@ Nothing applied. Re-run with --yes to apply these changes.
   skills.command("update").description("rewrite installed skills older than this CLI's").option("--dir <dir>", "the install to update; <config folder>/skills by default").action((options, command) => {
     const dir = skillsDirOf({ command, dir: options.dir });
     updateSkills({ dir, write: (text) => process.stdout.write(text) });
+    if (options.dir === undefined)
+      ignoreBundledSkills(projectOf({ command }));
   });
   program.command("pull").description("write your remote catalog back into autumn.config.ts").option("--include-mappings", "keep processor mappings in pulled fixtures").option("--overwrite", "rewrite the config from your org's catalog (e.g. after switching orgs)").option("-y, --yes", "overwrite it").action(async (options, command) => {
     const target = prepareTarget({ command });