@pipefy/pipefy-process-coder 0.1.0 → 0.1.1

package/src/diff/flow.ts

@@ -1,318 +0,0 @@
-import { canonicalString } from '../util/json.ts';
-import type { FlowTree, FlowNode } from '../codec/flow.ts';
-import type { FlowsSection } from '../workspace/flows.ts';
-import { flowIdOf, isNewFlow } from '../workspace/flows.ts';
-
-/**
- * Diffing flows.
- *
- * Node-by-node for the human, because that is how a person thinks about a flow and
- * how the compiler will send it — the granular operations are per node. The
- * whole-tree replace the API also offers is not used (see `IpaasClient.operate`),
- * so there is no reason to diff whole-tree either.
- *
- * Coverage is respected exactly as it is for pipe entities: a workspace whose
- * `flows` group is `unknown` is not diffed at all. Comparing against a group the
- * read path could not see would propose deleting every flow in it.
- */
-
-export type FlowChangeOp =
-  | 'flow.create'
-  | 'flow.delete'
-  | 'flow.rename'
-  | 'flow.status'
-  | 'node.create'
-  | 'node.update'
-  | 'node.delete'
-  | 'trigger.update';
-
-export type FlowChange = {
-  op: FlowChangeOp;
-  /** Stable key: the flow, plus the node when the change is a node's. */
-  key: string;
-  label: string;
-  flowId: string | null;
-  /** The flow's display name, for the label when there is no id yet. */
-  flowName: string;
-  nodeName?: string;
-  before?: FlowNode | null;
-  after?: FlowNode | null;
-  /** For flow-level changes. */
-  beforeFlow?: FlowTree | null;
-  afterFlow?: FlowTree | null;
-  deltas: Array<{ key: string; before: unknown; after: unknown }>;
-  flags: string[];
-};
-
-export type FlowChangeSet = {
-  changes: FlowChange[];
-  skipped: Array<{ reason: string }>;
-};
-
-/**
- * Keys that never carry intent and must not produce a change.
- *
- * `sampleData` is generated by testing a step, `lastUpdatedDate` moves on every
- * write, and the server-minted ids move whenever a version is created. Comparing
- * them would make every flow permanently dirty.
- */
-const VOLATILE_NODE_KEYS = new Set(['sampleData', 'lastUpdatedDate']);
-const VOLATILE_FLOW_KEYS = new Set([
-  'created',
-  'updated',
-  'publishedVersionId',
-  'operationStatus',
-  'timeSavedPerRun',
-  'createdBy',
-  'updatedBy',
-  'ownerId',
-  'externalId',
-  'id',
-  'flowId',
-  'projectId',
-  'templateId',
-  'backupFiles',
-  /**
-   * Derived by the API from the inline `{{connections[...]}}` references rather
-   * than supplied, so it is an echo of the nodes and never an intent of its own.
-   */
-  'connectionIds',
-  'state',
-]);
-
-const comparableNode = (n: FlowNode): Record<string, unknown> => {
-  const out: Record<string, unknown> = {};
-  for (const [k, v] of Object.entries(n)) {
-    if (VOLATILE_NODE_KEYS.has(k)) continue;
-    if (k.startsWith('_')) continue; // link metadata is compared separately, as structure
-    if (k === 'settings' && v && typeof v === 'object') {
-      const s: Record<string, unknown> = {};
-      for (const [sk, sv] of Object.entries(v as Record<string, unknown>)) {
-        if (VOLATILE_NODE_KEYS.has(sk)) continue;
-        s[sk] = sv;
-      }
-      out[k] = s;
-      continue;
-    }
-    out[k] = v;
-  }
-  return out;
-};
-
-const nodeDeltas = (before: FlowNode, after: FlowNode) => {
-  const a = comparableNode(before);
-  const b = comparableNode(after);
-  const keys = [...new Set([...Object.keys(a), ...Object.keys(b)])].sort();
-  const out: Array<{ key: string; before: unknown; after: unknown }> = [];
-  for (const k of keys) {
-    if (canonicalString(a[k]) !== canonicalString(b[k])) out.push({ key: k, before: a[k], after: b[k] });
-  }
-  // Structure: a node whose place in the chain moved is a change even when its
-  // settings are identical.
-  for (const link of ['_nextAction', '_firstLoopAction', '_children'] as const) {
-    if (canonicalString(before[link]) !== canonicalString(after[link])) {
-      out.push({ key: link, before: before[link], after: after[link] });
-    }
-  }
-  return out;
-};
-
-const flowLabel = (tree: FlowTree) => String(tree.version['displayName'] ?? flowIdOf(tree) ?? 'flow');
-
-/** Match flows by id, then by display name for one the workspace is creating. */
-const matchFlows = (before: FlowTree[], after: FlowTree[]) => {
-  const pairs: Array<[FlowTree, FlowTree]> = [];
-  const added: FlowTree[] = [];
-  const removed: FlowTree[] = [...before];
-
-  for (const a of after) {
-    const id = flowIdOf(a);
-    let hitAt = id ? removed.findIndex((b) => flowIdOf(b) === id) : -1;
-    if (hitAt < 0 && isNewFlow(a)) {
-      hitAt = removed.findIndex((b) => flowLabel(b) === flowLabel(a));
-    }
-    if (hitAt >= 0) {
-      pairs.push([removed[hitAt] as FlowTree, a]);
-      removed.splice(hitAt, 1);
-    } else {
-      added.push(a);
-    }
-  }
-  return { pairs, added, removed };
-};
-
-export const diffFlows = (before: FlowsSection | null, after: FlowsSection | null): FlowChangeSet => {
-  const changes: FlowChange[] = [];
-  const skipped: Array<{ reason: string }> = [];
-
-  if (!before || !after) {
-    return { changes, skipped: [{ reason: 'one side has no flows section, so flows are not diffed' }] };
-  }
-  if (before.meta.coverage !== 'complete' || after.meta.coverage !== 'complete') {
-    /**
-     * The whole reason coverage exists. A pipe whose iPaaS could not be reached
-     * reports zero flows, and diffing that against a workspace that has some would
-     * propose deleting every one of them.
-     */
-    return {
-      changes,
-      skipped: [
-        {
-          reason:
-            `flows coverage is ${before.meta.coverage}/${after.meta.coverage}, not complete — ` +
-            'not diffed, because absence here is not evidence of absence',
-        },
-      ],
-    };
-  }
-
-  const { pairs, added, removed } = matchFlows(before.flows, after.flows);
-
-  for (const tree of added) {
-    changes.push({
-      op: 'flow.create',
-      key: `flow:new:${flowLabel(tree)}`,
-      label: `create flow "${flowLabel(tree)}" (${tree.nodes.length} nodes)`,
-      flowId: null,
-      flowName: flowLabel(tree),
-      afterFlow: tree,
-      deltas: [],
-      flags: [],
-    });
-  }
-
-  for (const tree of removed) {
-    changes.push({
-      op: 'flow.delete',
-      key: `flow:${flowIdOf(tree)}`,
-      label: `delete flow "${flowLabel(tree)}"`,
-      flowId: flowIdOf(tree),
-      flowName: flowLabel(tree),
-      beforeFlow: tree,
-      deltas: [],
-      flags: ['destructive'],
-    });
-  }
-
-  for (const [b, a] of pairs) {
-    const flowId = flowIdOf(a) ?? flowIdOf(b);
-    const name = flowLabel(a);
-
-    if (flowLabel(b) !== flowLabel(a)) {
-      changes.push({
-        op: 'flow.rename',
-        key: `flow:${flowId}:name`,
-        label: `rename flow "${flowLabel(b)}" → "${flowLabel(a)}"`,
-        flowId,
-        flowName: name,
-        deltas: [{ key: 'displayName', before: flowLabel(b), after: flowLabel(a) }],
-        flags: [],
-      });
-    }
-
-    if (String(b.flow['status'] ?? '') !== String(a.flow['status'] ?? '')) {
-      changes.push({
-        op: 'flow.status',
-        key: `flow:${flowId}:status`,
-        label: `flow "${name}" ${b.flow['status']} → ${a.flow['status']}`,
-        flowId,
-        flowName: name,
-        deltas: [{ key: 'status', before: b.flow['status'], after: a.flow['status'] }],
-        // Enabling a flow arms it against live traffic. That is never incidental.
-        flags: String(a.flow['status']) === 'ENABLED' ? ['arms-flow'] : [],
-      });
-    }
-
-    const beforeNodes = new Map(b.nodes.map((n) => [n.name, n]));
-    const afterNodes = new Map(a.nodes.map((n) => [n.name, n]));
-
-    for (const [nodeName, node] of afterNodes) {
-      const prior = beforeNodes.get(nodeName);
-      if (!prior) {
-        changes.push({
-          op: 'node.create',
-          key: `flow:${flowId}:node:${nodeName}`,
-          label: `flow "${name}": add ${nodeName} [${node.type}] ${String(node['displayName'] ?? '')}`.trim(),
-          flowId,
-          flowName: name,
-          nodeName,
-          after: node,
-          /**
-           * The whole intended tree, not just the node: `ADD_ACTION` needs the
-           * parent this node hangs from, and that is a property of where `node`
-           * sits in the chain — found by scanning every node's `_nextAction` /
-           * `_firstLoopAction` / `_children` for `nodeName` (apply/flowops.ts
-           * `parentOf`), the same lookup a brand-new flow's build already uses.
-           */
-          afterFlow: a,
-          deltas: [],
-          flags: [],
-        });
-        continue;
-      }
-      const deltas = nodeDeltas(prior, node);
-      if (!deltas.length) continue;
-      const isTrigger = nodeName === 'trigger';
-      changes.push({
-        op: isTrigger ? 'trigger.update' : 'node.update',
-        key: `flow:${flowId}:node:${nodeName}`,
-        label: `flow "${name}": ${isTrigger ? 'trigger' : nodeName} — ${deltas.map((d) => d.key).join(', ')}`,
-        flowId,
-        flowName: name,
-        nodeName,
-        before: prior,
-        after: node,
-        deltas,
-        flags: [],
-      });
-    }
-
-    for (const [nodeName, node] of beforeNodes) {
-      if (afterNodes.has(nodeName)) continue;
-      changes.push({
-        op: 'node.delete',
-        key: `flow:${flowId}:node:${nodeName}`,
-        label: `flow "${name}": delete ${nodeName} [${node.type}]`,
-        flowId,
-        flowName: name,
-        nodeName,
-        before: node,
-        deltas: [],
-        flags: ['destructive'],
-      });
-    }
-  }
-
-  return { changes, skipped };
-};
-
-export const renderFlowChanges = (cs: FlowChangeSet): string => {
-  const lines: string[] = [];
-  for (const s of cs.skipped) lines.push(`  flows not diffed: ${s.reason}`);
-  if (!cs.changes.length) {
-    if (!cs.skipped.length) lines.push('  flows: no changes');
-    return lines.join('\n');
-  }
-
-  const byFlow = new Map<string, FlowChange[]>();
-  for (const c of cs.changes) {
-    const k = c.flowId ?? `new:${c.flowName}`;
-    byFlow.set(k, [...(byFlow.get(k) ?? []), c]);
-  }
-  for (const [, group] of byFlow) {
-    lines.push('');
-    lines.push(`  ${group[0]?.flowName ?? 'flow'}`);
-    for (const c of group) {
-      const mark = c.flags.includes('destructive') ? '-' : c.op.endsWith('create') ? '+' : '~';
-      lines.push(`    ${mark} ${c.label}`);
-      for (const d of c.deltas.slice(0, 6)) {
-        const short = (v: unknown) => {
-          const s = canonicalString(v);
-          return s.length > 90 ? `${s.slice(0, 90)}…` : s;
-        };
-        lines.push(`        ${d.key}: ${short(d.before)} -> ${short(d.after)}`);
-      }
-    }
-  }
-  return lines.join('\n');
-};

package/src/diff/render.ts

@@ -1,101 +0,0 @@
-import { bold, dim, green, red, yellow, blue, magenta } from '../util/log.ts';
-import type { Change, ChangeSet, FieldDelta } from './diff.ts';
-
-/** Text rendering of a ChangeSet, for the CLI. */
-
-const OP_MARK: Record<Change['op'], string> = {
-  create: '+',
-  delete: '-',
-  update: '~',
-  reorder: '>',
-  archive: 'a',
-  unarchive: 'u',
-};
-
-const colorFor = (op: Change['op']) =>
-  op === 'create' ? green : op === 'delete' ? red : op === 'reorder' ? magenta : yellow;
-
-const short = (v: unknown, max = 90): string => {
-  if (v === null || v === undefined) return 'null';
-  if (typeof v === 'string') return v.length > max ? JSON.stringify(v.slice(0, max) + '…') : JSON.stringify(v);
-  const s = JSON.stringify(v);
-  return s.length > max ? s.slice(0, max) + '…' : s;
-};
-
-const renderDelta = (d: FieldDelta, indent: string): string =>
-  `${indent}${dim(d.key)}: ${red(short(d.before))} ${dim('->')} ${green(short(d.after))}`;
-
-export const renderChange = (c: Change, opts: { verbose?: boolean } = {}): string[] => {
-  const paint = colorFor(c.op);
-  const lines: string[] = [];
-  const flags = c.flags.length ? ' ' + dim(`[${c.flags.join(' ')}]`) : '';
-  lines.push(`  ${paint(OP_MARK[c.op])} ${bold(c.entity)} ${c.label}${flags}`);
-
-  const deltas = opts.verbose ? c.deltas : c.deltas.slice(0, 6);
-  for (const d of deltas) lines.push(renderDelta(d, '      '));
-  if (c.deltas.length > deltas.length) {
-    lines.push(`      ${dim(`…and ${c.deltas.length - deltas.length} more field${c.deltas.length - deltas.length === 1 ? '' : 's'}`)}`);
-  }
-
-  if (c.op === 'create' && c.after && !c.deltas.length) {
-    const keys = Object.keys(c.after).filter((k) => !k.startsWith('_')).slice(0, 8);
-    lines.push(`      ${dim(keys.map((k) => `${k}=${short(c.after?.[k], 30)}`).join(' '))}`);
-  }
-  return lines;
-};
-
-export const renderChangeSet = (cs: ChangeSet, opts: { verbose?: boolean } = {}): string => {
-  const lines: string[] = [];
-  const header =
-    cs.mode === 'cross-repo'
-      ? `${cs.from.name} (${cs.from.repoId}) -> ${cs.to.name} (${cs.to.repoId})`
-      : `${cs.to.name} (${cs.to.repoId})`;
-  lines.push(bold(`${cs.mode} diff — ${header}`));
-  lines.push(dim(`baseline read from ${cs.from.source}; compared tree read from ${cs.to.source}`));
-  lines.push('');
-
-  if (!cs.changes.length) {
-    lines.push(green('  no changes'));
-  } else {
-    const byEntity = new Map<string, Change[]>();
-    for (const c of cs.changes) {
-      const arr = byEntity.get(c.entity) ?? [];
-      arr.push(c);
-      byEntity.set(c.entity, arr);
-    }
-    for (const [entity, group] of byEntity) {
-      lines.push(blue(`${entity} (${group.length})`));
-      for (const c of group) lines.push(...renderChange(c, opts));
-      lines.push('');
-    }
-  }
-
-  if (cs.skipped.length) {
-    lines.push(yellow('not diffed — no read path on one side:'));
-    for (const s of cs.skipped) lines.push(`  ${s.entity}: ${dim(s.reason)}`);
-    lines.push('');
-  }
-
-  const counts = cs.changes.reduce<Record<string, number>>((acc, c) => {
-    acc[c.op] = (acc[c.op] ?? 0) + 1;
-    return acc;
-  }, {});
-  const summary = Object.entries(counts)
-    .map(([op, n]) => `${n} ${op}`)
-    .join(', ');
-  lines.push(bold(summary || 'nothing to do'));
-  return lines.join('\n');
-};
-
-/** Machine-readable form, for `--json` and for the HTML view. */
-export const toJson = (cs: ChangeSet) => ({
-  mode: cs.mode,
-  from: cs.from,
-  to: cs.to,
-  summary: cs.changes.reduce<Record<string, number>>((acc, c) => {
-    acc[c.op] = (acc[c.op] ?? 0) + 1;
-    return acc;
-  }, {}),
-  skipped: cs.skipped,
-  changes: cs.changes,
-});

package/src/model/payload.ts

@@ -1,154 +0,0 @@
-/**
- * The snapshot payload: the `repos` row (snake_case DB columns) plus
- * `relations` with twenty flat entity arrays. This shape is the canonical
- * intermediate for BOTH read paths — snapshot download and GraphQL
- * reconstruction — so everything downstream (codec, diff, plan) is written
- * once. PLAN.md §1.3.
- */
-
-export type Row = Record<string, unknown>;
-
-export const ENTITY_NAMES = [
-  'phases',
-  'phase_team_memberships',
-  'phase_jumps',
-  'fields',
-  'field_conditions',
-  'field_condition_actions',
-  'automations',
-  'conditions',
-  'condition_expressions',
-  'field_maps',
-  'distribute_assignments',
-  'response_schemas',
-  'repo_preferences',
-  'labels',
-  'pipe_relations',
-  'email_inboxes',
-  'webhooks',
-  'public_forms',
-  'email_templates',
-  'visibilities',
-] as const;
-
-export type EntityName = (typeof ENTITY_NAMES)[number];
-
-export type Relations = Record<EntityName, Row[]>;
-
-export type RepoPayload = Row & { id: number; relations: Relations };
-
-export const emptyRelations = (): Relations =>
-  Object.fromEntries(ENTITY_NAMES.map((n) => [n, [] as Row[]])) as Relations;
-
-/**
- * How much of an entity array a given read actually knows about.
- *
- * This is the safety mechanism a non-snapshot read requires and that neither
- * PLAN.md nor PLAN-ROUTE-B.md has: a reconstructed payload cannot distinguish
- * "this pipe has no webhooks" from "I have no way to read webhooks". Recording
- * `unknown` keeps pack and diff from ever reading absence as deletion
- * (PLAN-ROUTE-B.md §7 — "a dropped entity means the importer deletes it").
- */
-export type Coverage = 'complete' | 'partial' | 'unknown';
-
-export type PayloadEnvelope = {
-  /** Where the structure came from. */
-  source: 'snapshot' | 'reconstructed';
-  /** Snapshot version id, when source === 'snapshot'. */
-  versionId?: string | null;
-  /** ISO time of the read. */
-  readAt: string;
-  repoKind: 'pipe' | 'table';
-  coverage: Record<EntityName, Coverage>;
-  /** Whether the repo row's own columns were all readable. */
-  repo_columns?: Coverage;
-  /** What the read path could not see, for the docs and the diff header. */
-  notes: string[];
-  payload: RepoPayload;
-};
-
-export const fullCoverage = (c: Coverage): Record<EntityName, Coverage> =>
-  Object.fromEntries(ENTITY_NAMES.map((n) => [n, c])) as Record<EntityName, Coverage>;
-
-export type Identity = 'uuid' | 'id' | 'owned';
-
-export type EntitySpec = {
-  name: EntityName;
-  /**
-   * How an entity is recognised across two reads.
-   * `uuid` is present on only 4 of 20 arrays (PLAN.md §1.3); `owned` entities
-   * have no identity of their own and are diffed as a replace-set under their
-   * owner, exactly as ROUTE-B-V2.md §4 proposes the importer treat them.
-   */
-  identity: Identity;
-  /** For `owned`: the columns naming the owner, in precedence order. */
-  ownerKeys?: string[];
-  /** Fallback natural key, used when matching across two different repos. */
-  naturalKey?: string[];
-  /** No public write path exists — PLAN.md §2. */
-  readonly?: boolean;
-  /** Written through the internal API rather than public GraphQL. */
-  internal?: boolean;
-  /** Folded into the owner's file by the codec rather than getting its own. */
-  foldedInto?: EntityName;
-};
-
-export const ENTITIES: Record<EntityName, EntitySpec> = {
-  phases: { name: 'phases', identity: 'uuid', naturalKey: ['name'] },
-  fields: { name: 'fields', identity: 'uuid', naturalKey: ['phase_id', 'label'], foldedInto: 'phases' },
-  automations: { name: 'automations', identity: 'uuid', naturalKey: ['name'] },
-  labels: { name: 'labels', identity: 'uuid', naturalKey: ['name'] },
-
-  field_conditions: { name: 'field_conditions', identity: 'id', naturalKey: ['phase_id', 'name'] },
-  webhooks: { name: 'webhooks', identity: 'id', naturalKey: ['name', 'url'] },
-  pipe_relations: { name: 'pipe_relations', identity: 'id', naturalKey: ['parent_id', 'child_id', 'name'] },
-
-  conditions: { name: 'conditions', identity: 'owned', ownerKeys: ['source_type', 'source_id'] },
-  condition_expressions: { name: 'condition_expressions', identity: 'owned', ownerKeys: ['condition_id'] },
-  field_maps: { name: 'field_maps', identity: 'owned', ownerKeys: ['owner_type', 'owner_id'] },
-  field_condition_actions: {
-    name: 'field_condition_actions',
-    identity: 'owned',
-    ownerKeys: ['field_condition_id'],
-    foldedInto: 'field_conditions',
-  },
-  phase_jumps: { name: 'phase_jumps', identity: 'owned', ownerKeys: ['source_phase_id'], internal: true },
-  phase_team_memberships: {
-    name: 'phase_team_memberships',
-    identity: 'owned',
-    ownerKeys: ['phase_id'],
-    foldedInto: 'phases',
-  },
-  distribute_assignments: {
-    name: 'distribute_assignments',
-    identity: 'owned',
-    ownerKeys: ['automation_id'],
-    foldedInto: 'automations',
-  },
-  response_schemas: {
-    name: 'response_schemas',
-    identity: 'owned',
-    ownerKeys: ['automation_id'],
-    foldedInto: 'automations',
-  },
-
-  public_forms: { name: 'public_forms', identity: 'owned', ownerKeys: ['repo_id'] },
-  repo_preferences: { name: 'repo_preferences', identity: 'owned', ownerKeys: ['repo_id'] },
-
-  visibilities: { name: 'visibilities', identity: 'owned', ownerKeys: ['resource_type', 'resource_id'], readonly: true },
-  email_templates: { name: 'email_templates', identity: 'id', readonly: true },
-  email_inboxes: { name: 'email_inboxes', identity: 'id', readonly: true },
-};
-
-export const READONLY_ENTITIES = ENTITY_NAMES.filter((n) => ENTITIES[n].readonly);
-
-export const rel = (p: RepoPayload, n: EntityName): Row[] => p.relations?.[n] ?? [];
-
-export const numId = (r: Row): number | null => {
-  const v = r['id'];
-  if (typeof v === 'number') return v;
-  if (typeof v === 'string' && /^\d+$/.test(v)) return Number(v);
-  return null;
-};
-
-export const strId = (r: Row): string => String(r['id'] ?? '');

package/src/model/tree.ts

@@ -1,99 +0,0 @@
-import type { Coverage, EntityName, Row } from './payload.ts';
-
-/**
- * The workspace tree — what Claude and the FDE actually edit. PLAN.md §4.
- *
- * Folding is *movement only*: a folded row is the payload row, unchanged, moved
- * under its owner. Nothing is renamed or reshaped, which is what makes
- * `pack(unpack(P))` equal to `P` by construction rather than by care.
- */
-
-export type ConditionNode = Row & {
-  /** condition_expressions rows belonging to this condition. */
-  expressions: Row[];
-};
-
-export type PhaseNode = Row & {
-  /** fields rows whose phase_id is this phase, ordered by index. */
-  fields: Row[];
-  /**
-   * phase_jumps targets for this phase, as a set. The internal settings
-   * endpoint is set-replacing (PLAN.md §2.1), so a set is the honest shape and
-   * there is no add/remove diffing to get wrong.
-   */
-  jump_target_ids: Array<number | string>;
-  /** phase_team_memberships, flattened to the user ids phaseSettings takes. */
-  team_member_ids: Array<number | string>;
-};
-
-export type AutomationNode = Row & {
-  condition?: ConditionNode | null;
-  field_maps: Row[];
-  distribute_assignments: Row[];
-  response_schemas: Row[];
-};
-
-export type FieldConditionNode = Row & {
-  actions: Row[];
-  condition?: ConditionNode | null;
-};
-
-export type TreeMeta = {
-  source: 'snapshot' | 'reconstructed';
-  versionId?: string | null;
-  readAt: string;
-  repoKind: 'pipe' | 'table';
-  coverage: Record<EntityName, Coverage>;
-  /**
-   * Whether the repo row itself was read in full. The public API has no
-   * `color_uuid`, `authorization` or `draft`, so a reconstructed root is
-   * partial — and the diff must not read those absences as "set to null".
-   */
-  repo_columns: Coverage;
-  notes: string[];
-};
-
-export type Tree = {
-  meta: TreeMeta;
-  /** The `repos` row, volatile columns stripped. */
-  repo: Row;
-  phases: PhaseNode[];
-  automations: AutomationNode[];
-  field_conditions: FieldConditionNode[];
-  labels: Row[];
-  webhooks: Row[];
-  pipe_relations: Row[];
-  public_form: Row | null;
-  preferences: Row | null;
-  /** PLAN.md §4: first-class, so the planner can reject edits by path alone. */
-  readonly: {
-    email_templates: Row[];
-    email_inboxes: Row[];
-    visibilities: Row[];
-    /**
-     * `field_maps` owned by a **field**, not an automation — a connector
-     * field's own "copy this value from the connected card" configuration.
-     * `unpack`/`pack` only ever modelled the automation-owned half of this
-     * entity (PLAN.md, ROUTE-B-V2.md both describe it that way), so these rows
-     * were silently dropped on every pull until the round-trip check caught it.
-     * `owner_type`/`owner_id` are kept, unlike the automation-nested form,
-     * because this is a flat bucket spanning however many fields own one.
-     */
-    field_maps: Row[];
-  };
-};
-
-export const repoId = (t: Tree): number => Number(t.repo['id']);
-export const repoName = (t: Tree): string => String(t.repo['name'] ?? `repo ${repoId(t)}`);
-
-/** The start form is a phase (id/index 0). PLAN.md §4 — deleting it is catastrophic. */
-export const startFormPhase = (t: Tree): PhaseNode | undefined =>
-  t.phases.find((p) => Number(p['index']) === 0) ?? t.phases[0];
-
-export const allFields = (t: Tree): Row[] => t.phases.flatMap((p) => p.fields);
-
-export const fieldById = (t: Tree, id: string | number): Row | undefined =>
-  allFields(t).find((f) => String(f['id']) === String(id));
-
-export const phaseById = (t: Tree, id: string | number): PhaseNode | undefined =>
-  t.phases.find((p) => String(p['id']) === String(id));