@koda-sl/baker-cli 0.481.0-dev.2d33e194f → 0.498.0-dev.e2ca08ce6

package/dist/chunk-FSGTITIW.js

@@ -1,622 +0,0 @@
-import {
-  flowsDir,
-  walkNodes
-} from "./chunk-4TU2MWBJ.js";
-
-// src/commands/flows/value-expression.ts
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-var PREFIXES = ["field", "tracking", "global", "code"];
-function splitParts(raw) {
-  const parts = [];
-  let current = "";
-  let inQuotes = false;
-  for (let i = 0; i < raw.length; i++) {
-    const char = raw[i];
-    if (char === '"') {
-      inQuotes = !inQuotes;
-      current += char;
-    } else if (char === "+" && !inQuotes) {
-      parts.push(current);
-      current = "";
-    } else {
-      current += char;
-    }
-  }
-  parts.push(current);
-  if (inQuotes) {
-    throw new MappingError(`Unclosed quote in value \`${raw}\`.`, 'A literal is written "like this".');
-  }
-  return parts.map((part) => part.trim()).filter((part) => part.length > 0);
-}
-var TRANSFORM_REFUSAL = "A value cannot run code. Map the field as it is (firstname=full_name), or split it in the step with a codeExecution that exposes first_name and last_name and map code:first_name.";
-var METHOD_CALL = /\.\s*[A-Za-z_$][\w$]*\s*\(/;
-var TRAILING_INDEX = /\[[^\]]*\]$/;
-function mentionPart(inner) {
-  if (inner.startsWith("tracking.")) return { kind: "tracking", name: inner.slice("tracking.".length) };
-  if (inner.startsWith("global.")) return { kind: "global", name: inner.slice("global.".length) };
-  return referencePart(inner);
-}
-function referencePart(ref) {
-  return /\.codeExecution\.[^.]+$/.test(ref) ? { kind: "code", ref } : { kind: "field", ref };
-}
-function parsePart(part) {
-  if (part.startsWith('"') && part.endsWith('"') && part.length >= 2) {
-    return { kind: "text", text: part.slice(1, -1) };
-  }
-  if (METHOD_CALL.test(part) || TRAILING_INDEX.test(part)) {
-    throw new MappingError(TRANSFORM_REFUSAL);
-  }
-  if (part.startsWith("{{")) {
-    const close = part.indexOf("}}");
-    if (close < 0) {
-      throw new MappingError(
-        `Unclosed \`{{\` in value \`${part}\`.`,
-        "A mention is written {{<stepId>.customForm.<field>}}."
-      );
-    }
-    if (part.slice(close + 2).trim()) throw new MappingError(TRANSFORM_REFUSAL);
-    return mentionPart(part.slice(2, close).trim());
-  }
-  const colon = part.indexOf(":");
-  if (colon <= 0) return referencePart(part);
-  const prefix = part.slice(0, colon);
-  const rest = part.slice(colon + 1).trim();
-  if (!PREFIXES.includes(prefix)) {
-    throw new MappingError(
-      `\`${prefix}:\` is not a value kind.`,
-      `Use one of ${PREFIXES.map((candidate) => `${candidate}:`).join(" ")}, a bare form field name, or a "quoted literal".`
-    );
-  }
-  if (!rest) throw new MappingError(`\`${part}\` names no ${prefix}.`);
-  switch (prefix) {
-    case "tracking":
-      return { kind: "tracking", name: rest.replace(/^tracking\./, "") };
-    case "global":
-      return { kind: "global", name: rest };
-    case "code":
-      return { kind: "code", ref: rest };
-    default:
-      return { kind: "field", ref: rest };
-  }
-}
-function parseValueExpression(raw) {
-  const parts = splitParts(raw);
-  if (parts.length === 0) {
-    throw new MappingError("A --map needs a value on the right of the `=`.");
-  }
-  return parts.map(parsePart);
-}
-function trackingFieldIds() {
-  const path = join(flowsDir(), "..", "tracking.ts");
-  if (!existsSync(path)) return null;
-  try {
-    const source = readFileSync(path, "utf-8");
-    const block = source.match(/TRACKING_FIELD_IDS\s*=\s*\[([\s\S]*?)\]\s*as const/)?.[1];
-    if (!block) return null;
-    const ids = [...block.matchAll(/"(tracking\.[a-z0-9_]+)"/g)].map((match) => match[1]);
-    return ids.length > 0 ? new Set(ids) : null;
-  } catch {
-    return null;
-  }
-}
-function externalOf(node) {
-  const nodeData = node.nodeData ?? {};
-  return nodeData.form?.external ?? {};
-}
-function fieldOwners(tree) {
-  return walkNodes(tree).flatMap((node) => {
-    const external = externalOf(node);
-    if (!Array.isArray(external.fields)) return [];
-    return [
-      {
-        id: String(node.id ?? ""),
-        name: typeof node.name === "string" && node.name ? node.name : "Form",
-        fields: external.fields.map((field) => field?.fieldName).filter((name) => typeof name === "string")
-      }
-    ];
-  });
-}
-function splitRef(ref, segment) {
-  const marker = `.${segment}.`;
-  const at = ref.lastIndexOf(marker);
-  if (at > 0 && !ref.slice(at + marker.length).includes(".")) {
-    return { step: ref.slice(0, at), name: ref.slice(at + marker.length) };
-  }
-  const dot = ref.lastIndexOf(".");
-  if (dot <= 0) return { name: ref };
-  return { step: ref.slice(0, dot), name: ref.slice(dot + 1) };
-}
-function mention(id, label) {
-  return { type: "VariablesMention", attrs: { id, label, mentionSuggestionChar: "{{" } };
-}
-function titleize(value) {
-  return value.split(/[_-]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-}
-function resolveField(tree, ref) {
-  const { step, name } = splitRef(ref, "customForm");
-  const owners = fieldOwners(tree);
-  const inventory = owners.map((owner2) => `  ${owner2.name} (${owner2.id}): ${owner2.fields.join(", ") || "(no fields)"}`).join("\n");
-  const candidates = owners.filter(
-    (owner2) => owner2.fields.includes(name) && (!step || owner2.name === step || owner2.id === step)
-  );
-  if (candidates.length === 0) {
-    throw new MappingError(`Form field "${ref}" does not exist in this form.`, inventory);
-  }
-  if (candidates.length > 1) {
-    throw new MappingError(
-      `Form field "${name}" exists on ${candidates.length} steps \u2014 say which: field:<step>.${name}`,
-      candidates.map((owner2) => `  field:${owner2.name}.${name}`).join("\n")
-    );
-  }
-  const owner = candidates[0];
-  return mention(`${owner.id}.customForm.${name}`, `${owner.name} => ${titleize(name)}`);
-}
-function resolveTracking(name) {
-  const id = `tracking.${name}`;
-  const known = trackingFieldIds();
-  if (known && !known.has(id)) {
-    const near = [...known].filter((candidate) => candidate.includes(name.split("_")[0] ?? name)).slice(0, 8);
-    throw new MappingError(
-      `\`${id}\` is not a tracking variable.`,
-      near.length > 0 ? `Close matches: ${near.join(", ")}` : "See references/autofill-and-variables.md \xA7 Built-in Tracking Variables."
-    );
-  }
-  return mention(id, id);
-}
-function resolveGlobal(tree, name) {
-  const globals = tree.globalVariables ?? [];
-  const match = globals.find((variable) => variable?.name === name || variable?.id === name);
-  if (!match) {
-    throw new MappingError(
-      `No global variable named "${name}" on this form.`,
-      globals.length > 0 ? `Defined: ${globals.map((variable) => String(variable.name)).join(", ")}` : "This form defines none. Globals live on the first node only \u2014 see references/autofill-and-variables.md \xA7 Global Variables."
-    );
-  }
-  const id = `global.${String(match.id)}`;
-  return mention(id, id);
-}
-function resolveCode(tree, ref) {
-  const { step, name } = splitRef(ref, "codeExecution");
-  const owners = walkNodes(tree).flatMap((node) => {
-    const exposed = externalOf(node).codeExecution?.exposedValues ?? [];
-    const names = exposed.map((value) => value?.name).filter((value) => typeof value === "string");
-    return names.length > 0 ? [{ id: String(node.id ?? ""), name: String(node.name ?? "step"), names }] : [];
-  });
-  const candidates = owners.filter(
-    (owner2) => owner2.names.includes(name) && (!step || owner2.name === step || owner2.id === step)
-  );
-  if (candidates.length !== 1) {
-    throw new MappingError(
-      candidates.length === 0 ? `No codeExecution exposes "${ref}" on this form.` : `"${name}" is exposed by ${candidates.length} steps \u2014 say which: code:<step>.${name}`,
-      owners.length > 0 ? owners.map((owner2) => `  ${owner2.name} (${owner2.id}): ${owner2.names.join(", ")}`).join("\n") : "No step on this form exposes any codeExecution value."
-    );
-  }
-  const owner = candidates[0];
-  return mention(`${owner.id}.codeExecution.${name}`, `${owner.name} => ${titleize(name)}`);
-}
-function buildValueDoc(tree, expression) {
-  const parts = parseValueExpression(expression);
-  const content = parts.map((part) => {
-    switch (part.kind) {
-      case "text":
-        return { type: "text", text: part.text };
-      case "tracking":
-        return resolveTracking(part.name);
-      case "global":
-        return resolveGlobal(tree, part.name);
-      case "code":
-        return resolveCode(tree, part.ref);
-      default:
-        return resolveField(tree, part.ref);
-    }
-  });
-  const single = content.length === 1 && parts[0]?.kind !== "text";
-  return {
-    type: "doc",
-    content: [{ type: "paragraph", content: single ? [...content, { type: "text", text: " " }] : content }]
-  };
-}
-
-// src/commands/flows/mapping.ts
-var MappingError = class extends Error {
-  fix;
-  constructor(message, fix) {
-    super(message);
-    this.name = "MappingError";
-    this.fix = fix;
-  }
-};
-var PAYLOAD = (key) => ({ kind: "list", key, addressedBy: "key" });
-var META_MATCHING = ["em", "fn", "ln", "ph", "external_id", "ge", "db", "ct", "st", "zp", "country"];
-var ADS_MATCHING = [
-  "email",
-  "phone_number",
-  "first_name",
-  "last_name",
-  "street",
-  "city",
-  "region",
-  "postal_code",
-  "country"
-];
-var MAPPING_SLOTS = {
-  googleSpreadsheet: [{ kind: "list", key: "columnMapping", addressedBy: "column" }],
-  hubspotForm: [
-    {
-      kind: "list",
-      key: "fieldMapping",
-      addressedBy: "fieldName",
-      needsFieldType: true,
-      fieldTypeSource: "Pass --hubspot-form <formGuid> and this command reads every property's type off the form itself \u2014 the guid is the `formGuid` in the `destination` request_flow_input returned. `baker hubspot forms view <formGuid>` prints the same list if you want to see it."
-    }
-  ],
-  pipedrive: [
-    {
-      kind: "list",
-      key: "fieldMapping",
-      addressedBy: "fieldKey",
-      entities: ["person", "organization", "lead"],
-      needsFieldType: true,
-      needsIsCustom: true
-    }
-  ],
-  goHighlevelContact: [
-    {
-      kind: "list",
-      key: "fieldMapping",
-      addressedBy: "fieldKey",
-      entities: ["business", "contact", "opportunity"],
-      needsFieldType: true,
-      needsIsCustom: true
-    }
-  ],
-  crmble: [
-    { kind: "list", key: "fieldMapping", addressedBy: "fieldId", entities: ["contact", "lead"], needsFieldType: true }
-  ],
-  email: [{ ...PAYLOAD("fields"), under: "body" }],
-  zapier: [PAYLOAD("payloadKeys")],
-  httpWebhook: [PAYLOAD("payloadKeys")],
-  googleTagManager: [PAYLOAD("dataLayerParams")],
-  googleAnalytics: [PAYLOAD("eventParams")],
-  posthog: [PAYLOAD("eventParams")],
-  amplitude: [PAYLOAD("eventProperties")],
-  hubspot: [PAYLOAD("eventProperties")],
-  vwo: [PAYLOAD("eventProperties")],
-  code: [PAYLOAD("eventProperties")],
-  datafast: [PAYLOAD("goalParams")],
-  meta: [PAYLOAD("eventParams"), { kind: "record", key: "advancedMatching", allowed: META_MATCHING }],
-  chatgptAds: [
-    PAYLOAD("eventParams"),
-    {
-      kind: "record",
-      key: "advancedMatching",
-      allowed: ["em", "ph", "fn", "ln", "external_id", "ct", "st", "zp", "country"]
-    }
-  ],
-  tiktok: [
-    PAYLOAD("eventParams"),
-    { kind: "record", key: "identify", allowed: ["email", "phone_number", "external_id"] }
-  ],
-  pinterest: [PAYLOAD("eventParams"), { kind: "record", key: "enhancedMatching", allowed: ["em", "hashed_maids"] }],
-  googleAds: [
-    { kind: "record", key: "enhancedConversions", allowed: ADS_MATCHING },
-    { kind: "scalar", keys: ["value", "currency", "transactionId"] }
-  ],
-  linkedinInsightTag: [
-    { kind: "record", key: "userMatching", allowed: ["em", "fn", "ln", "title", "companyName", "country"] },
-    { kind: "scalar", keys: ["value", "currency"] }
-  ],
-  twitterAds: [
-    { kind: "record", key: "userMatching", allowed: ["em", "ph"] },
-    { kind: "scalar", keys: ["value", "currency"] }
-  ]
-};
-var UNMAPPABLE = {
-  hotjar: "A Hotjar event carries only its name.",
-  clarity: "A Clarity custom tag carries only its name."
-};
-function slotName(shape) {
-  if (shape.kind === "scalar") return shape.keys.join("/");
-  if (shape.kind === "list" && shape.under) return `${shape.under}.${shape.key}`;
-  return shape.key;
-}
-function shapeFor(type, into) {
-  const slots = MAPPING_SLOTS[type];
-  if (!slots) {
-    const why = UNMAPPABLE[type];
-    throw new MappingError(
-      `Side effect "${type}" has no mappable field.`,
-      why ?? `"${type}" is not a side-effect type this workspace's flow engine defines.`
-    );
-  }
-  if (!into) return slots[0];
-  const chosen = slots.find(
-    (slot) => slot.kind === "scalar" ? slot.keys.includes(into) || into === "scalar" : slot.key === into || slotName(slot) === into
-  );
-  if (!chosen) {
-    throw new MappingError(
-      `"${into}" is not a mappable slot on a ${type} side effect.`,
-      `Slots on ${type}: ${slots.map(slotName).join(", ")}`
-    );
-  }
-  return chosen;
-}
-function namesComeFromAccount(shape) {
-  return shape.kind === "list" && shape.addressedBy !== "key";
-}
-function describeSlots(type) {
-  return (MAPPING_SLOTS[type] ?? []).map((shape) => {
-    if (shape.kind === "record") {
-      return {
-        slot: shape.key,
-        addressedBy: "one of a closed set",
-        keysFrom: "closed",
-        keys: shape.allowed,
-        note: `${type} defines these names; any other is refused.`
-      };
-    }
-    if (shape.kind === "scalar") {
-      return {
-        slot: shape.keys.join("/"),
-        addressedBy: "the field's own name",
-        keysFrom: "closed",
-        keys: shape.keys,
-        note: "Each is a single value on the side effect, mapped like any other."
-      };
-    }
-    if (shape.addressedBy === "key") {
-      return {
-        slot: slotName(shape),
-        addressedBy: "key",
-        keysFrom: "yours",
-        note: "You name these \u2014 they are what the receiving system expects. Ask the user if you do not know them."
-      };
-    }
-    return {
-      slot: slotName(shape),
-      addressedBy: shape.addressedBy,
-      keysFrom: "account",
-      note: "These live in the connected account. Read them off the request_flow_input result; they cannot be guessed.",
-      ...shape.needsFieldType ? { fieldTypes: shape.fieldTypeSource ?? FIELD_TYPE_FROM_INPUT } : {}
-    };
-  });
-}
-var FIELD_TYPE_FROM_INPUT = "Each mapping stores a field type. They come back from request_flow_input with the field list \u2014 write one on the LEFT: <field>:<fieldType>=<value>.";
-function otherSlots(type, used) {
-  return (MAPPING_SLOTS[type] ?? []).filter((slot) => slot !== used).map(slotName);
-}
-function parseMapSpec(raw) {
-  const eq = raw.indexOf("=");
-  if (eq <= 0 || eq === raw.length - 1) {
-    throw new MappingError(
-      `--map "${raw}" must be <destField>[:<fieldType>]=<value>`,
-      'Value: a form field (`nombre`), `tracking:utm_source`, `global:Name`, `code:name`, a "literal", or those joined with `+`.'
-    );
-  }
-  const left = raw.slice(0, eq).trim();
-  const expression = raw.slice(eq + 1).trim();
-  const colon = left.indexOf(":");
-  const destField = (colon > 0 ? left.slice(0, colon) : left).trim();
-  const fieldType = colon > 0 ? left.slice(colon + 1).trim() : "";
-  if (!destField) throw new MappingError(`--map "${raw}" names no destination field.`);
-  return { raw, destField, fieldType: fieldType || void 0, expression };
-}
-function sheetEntry(spec, value) {
-  if (!/^[A-Z]{1,3}$/.test(spec.destField)) {
-    throw new MappingError(
-      `--map "${spec.raw}": a Google Sheet is addressed by COLUMN, so the left side must be a column letter (A, B, \u2026 AA), got "${spec.destField}".`,
-      "Read the real destination back from the configured side effect first \u2014 a column letter is a guess until a spreadsheet is picked."
-    );
-  }
-  return { column: spec.destField, value };
-}
-function destinationField(spec, options) {
-  const catalog = options.destinationFields;
-  if (!catalog) return void 0;
-  const match = catalog.get(spec.destField);
-  if (match) return match;
-  throw new MappingError(
-    `--map "${spec.raw}": the destination has no field called "${spec.destField}".`,
-    `Fields on it: ${[...catalog.keys()].join(", ") || "(none)"}`
-  );
-}
-function fieldTypeFor(type, shape, spec, known) {
-  const resolved = spec.fieldType ?? known?.fieldType;
-  if (resolved) return resolved;
-  throw new MappingError(
-    `--map "${spec.raw}": ${type} stores a field type per mapping, and "${spec.destField}" has none \u2014 write it on the left: <field>:<fieldType>=<value>.`,
-    shape.fieldTypeSource ?? FIELD_TYPE_FROM_INPUT
-  );
-}
-function assertCrmOptions(type, shape, options) {
-  const entities = shape.entities;
-  if (entities) {
-    if (!options.entity) {
-      throw new MappingError(
-        `${type} addresses a specific object, so --entity is required (one of: ${entities.join(", ")}).`,
-        "Which object a value lands on is a destination-side fact \u2014 read it back from the configured side effect, do not assume."
-      );
-    }
-    if (!entities.includes(options.entity)) {
-      throw new MappingError(
-        `--entity "${options.entity}" is not valid for ${type} \u2014 expected one of: ${entities.join(", ")}.`
-      );
-    }
-  }
-  if (shape.needsIsCustom && options.isCustomField === void 0) {
-    throw new MappingError(
-      `${type} looks a key up differently for custom and standard fields, so pass --custom or --standard.`,
-      "Mapping a custom field as standard (or the reverse) is accepted and then dropped. The field list from request_flow_input says which each one is."
-    );
-  }
-}
-function buildEntry(type, shape, spec, value, options) {
-  if (shape.key === "columnMapping") {
-    return sheetEntry(spec, value);
-  }
-  if (shape.addressedBy === "key") {
-    if (spec.fieldType) {
-      throw new MappingError(
-        `--map "${spec.raw}": a ${type} ${shape.key} entry is just a name and a value \u2014 it takes no field type.`,
-        `Write it as ${spec.destField}=${spec.expression}`
-      );
-    }
-    return { key: spec.destField, value };
-  }
-  const known = destinationField(spec, options);
-  if (type === "hubspotForm") {
-    return {
-      objectTypeId: options.objectType ?? known?.objectTypeId ?? "0-1",
-      fieldType: fieldTypeFor(type, shape, spec, known),
-      fieldName: spec.destField,
-      value
-    };
-  }
-  assertCrmOptions(type, shape, options);
-  return {
-    entityType: options.entity,
-    fieldType: fieldTypeFor(type, shape, spec, known),
-    ...shape.needsIsCustom ? { isCustomField: options.isCustomField } : {},
-    [shape.addressedBy]: spec.destField,
-    value
-  };
-}
-function listPatch(shape, sideEffect, entries) {
-  if (!shape.under) return { [shape.key]: entries };
-  const owner = sideEffect[shape.under] ?? {};
-  return { [shape.under]: { ...owner, [shape.key]: entries } };
-}
-function existingEntries(shape, sideEffect) {
-  const owner = shape.under ? sideEffect[shape.under] : sideEffect;
-  if (!owner || typeof owner !== "object") return [];
-  const list = owner[shape.key];
-  if (!Array.isArray(list)) return [];
-  return list.filter((entry) => Boolean(entry) && typeof entry === "object");
-}
-function mergeEntries(shape, existing, incoming) {
-  const address = (entry) => {
-    const value = entry[shape.addressedBy];
-    return typeof value === "string" ? value : null;
-  };
-  const entries = [...existing];
-  const overwritten = /* @__PURE__ */ new Set();
-  for (const entry of incoming) {
-    const name = address(entry);
-    const at = name === null ? -1 : entries.findIndex((candidate) => address(candidate) === name);
-    if (at === -1) {
-      entries.push(entry);
-      continue;
-    }
-    entries[at] = entry;
-    if (at < existing.length) overwritten.add(at);
-  }
-  const kept = existing.length - overwritten.size;
-  return { entries, written: entries.length - kept, kept };
-}
-function assertMappableOwner(type, shape, sideEffect) {
-  if (shape.under !== "body") return;
-  const format = (sideEffect.body ?? {}).format;
-  if (format !== void 0 && format !== "json") {
-    throw new MappingError(
-      `This ${type} side effect sends \`body.format: "${String(format)}"\`, which is one written message rather than named keys.`,
-      'Set `body` to `{ "format": "json", "fields": [] }` first if you want mapped keys, or write the message in `body.content` and map nothing.'
-    );
-  }
-}
-function buildList(tree, type, shape, sideEffect, specs, options) {
-  assertMappableOwner(type, shape, sideEffect);
-  const incoming = specs.map((raw) => {
-    const spec = parseMapSpec(raw);
-    return buildEntry(type, shape, spec, buildValueDoc(tree, spec.expression), options);
-  });
-  const present = options.replace === true ? [] : existingEntries(shape, sideEffect);
-  const { kept: existing, dropped } = pruneAbsent(shape, present, options);
-  const { entries, written, kept } = mergeEntries(shape, existing, incoming);
-  return { key: slotName(shape), count: written, kept, dropped, patch: listPatch(shape, sideEffect, entries) };
-}
-function pruneAbsent(shape, existing, options) {
-  if (options.pruneMissing !== true) return { kept: existing, dropped: [] };
-  const catalog = options.destinationFields;
-  if (!catalog) {
-    throw new MappingError(
-      "--prune-missing needs the destination's own field list, and it could not be read.",
-      "Name the destination so its fields can be read \u2014 today that is --hubspot-form <formGuid>, the only destination whose catalog this command can fetch. `baker flows show <slug>` names the side effect and returns the request_flow_input call that carries the guid."
-    );
-  }
-  const kept = [];
-  const dropped = [];
-  for (const entry of existing) {
-    const name = entry[shape.addressedBy];
-    if (typeof name !== "string" || catalog.has(name)) {
-      kept.push(entry);
-      continue;
-    }
-    dropped.push(name);
-  }
-  return { kept, dropped };
-}
-function buildRecord(tree, type, shape, sideEffect, specs, options) {
-  const existing = options.replace === true ? {} : sideEffect[shape.key] ?? {};
-  const record = Object.fromEntries(shape.allowed.map((slot) => [slot, existing[slot] ?? null]));
-  const filledBefore = shape.allowed.filter((slot) => record[slot] != null);
-  const written = /* @__PURE__ */ new Set();
-  for (const raw of specs) {
-    const spec = parseMapSpec(raw);
-    if (!shape.allowed.includes(spec.destField)) {
-      throw new MappingError(
-        `"${spec.destField}" is not a slot in ${shape.key} on a ${type} side effect.`,
-        `${shape.key} slots: ${shape.allowed.join(", ")}`
-      );
-    }
-    if (spec.fieldType) {
-      throw new MappingError(`--map "${spec.raw}": a ${shape.key} slot takes no field type.`);
-    }
-    record[spec.destField] = buildValueDoc(tree, spec.expression);
-    written.add(spec.destField);
-  }
-  return {
-    key: shape.key,
-    count: written.size,
-    kept: filledBefore.filter((slot) => !written.has(slot)).length,
-    dropped: [],
-    patch: { [shape.key]: record }
-  };
-}
-function buildScalar(tree, type, shape, sideEffect, specs, options) {
-  const patch = options.replace === true ? Object.fromEntries(shape.keys.map((key) => [key, null])) : {};
-  const written = /* @__PURE__ */ new Set();
-  for (const raw of specs) {
-    const spec = parseMapSpec(raw);
-    if (!shape.keys.includes(spec.destField)) {
-      throw new MappingError(
-        `"${spec.destField}" is not a mappable field on a ${type} side effect.`,
-        `Mappable directly: ${shape.keys.join(", ")}`
-      );
-    }
-    if (spec.fieldType) {
-      throw new MappingError(`--map "${spec.raw}": ${spec.destField} takes no field type.`);
-    }
-    patch[spec.destField] = buildValueDoc(tree, spec.expression);
-    written.add(spec.destField);
-  }
-  const kept = options.replace === true ? 0 : shape.keys.filter((key) => !written.has(key) && sideEffect[key] != null).length;
-  return { key: shape.keys.join("/"), count: written.size, kept, dropped: [], patch };
-}
-function buildFieldMapping(tree, sideEffect, specs, options = {}) {
-  const type = String(sideEffect.type ?? "");
-  const shape = shapeFor(type, options.into);
-  if (shape.kind === "record") return buildRecord(tree, type, shape, sideEffect, specs, options);
-  if (shape.kind === "scalar") return buildScalar(tree, type, shape, sideEffect, specs, options);
-  return buildList(tree, type, shape, sideEffect, specs, options);
-}
-
-export {
-  MappingError,
-  shapeFor,
-  namesComeFromAccount,
-  describeSlots,
-  otherSlots,
-  buildFieldMapping
-};
-//# sourceMappingURL=chunk-FSGTITIW.js.map