@workbench-kit/field-remap 0.0.1-prototype.0

package/README.md

@@ -0,0 +1,115 @@
+# `@workbench-kit/field-remap`
+
+Field remap **runtime**: reshape structure A into structure B with mapping edges and `convertToShape`.
+
+This package does **not** ship a mapping UI. Hosts adapt a tree or table UI into `MappingEdge[]`
+and call `convertToShape`. The workbench sample (**Field Remap → A → B**) demonstrates a nested
+tree mapper with list context; flat OSS adapters (for example `react-table-mapping`) remain useful
+for leaf-only hosts.
+
+## Install
+
+```powershell
+pnpm add @workbench-kit/field-remap@prototype
+```
+
+## Capabilities
+
+| Pattern                                   | Support                                                              |
+| ----------------------------------------- | -------------------------------------------------------------------- |
+| Leaf → leaf rename                        | Yes                                                                  |
+| Nested object paths                       | Yes (`path` + `writeObjectPath`)                                     |
+| Array whole copy                          | Yes (`identity`)                                                     |
+| Array item projection                     | Yes (`itemSourcePath`)                                               |
+| Array → scalar reduce                     | Yes (`array:first`, `array:join`)                                    |
+| String format chain                       | Yes (`string:trim` / `upper` / `lower` / `prefix` / `suffix`, max 3) |
+| Array<object> → Array<object> | Yes (`itemEdges` list context)                                       |
+| Index / wildcard paths                    | No (P2)                                                              |
+
+Middle “graph nodes” in the sample UI are just `MappingEdge.transformIds` steps
+(plus optional `transformOptionSteps`), not a separate document type. The workbench
+sample renders them with `@xyflow/react` (source out → transform → target in).
+
+## Quick start
+
+```ts
+import {
+  convertToShape,
+  createBuiltinValueTransformRegistry,
+  defineConversion,
+  defineDataShape,
+  sourceFieldsFromPlainObject,
+  targetSlotsFromPlainObject,
+} from '@workbench-kit/field-remap';
+
+const structureA = {
+  user_name: 'Ada',
+  tags: [{ name: 'math' }, { name: 'computing' }],
+};
+
+const shapes = [
+  defineDataShape({
+    id: 'a',
+    label: 'A',
+    role: 'source',
+    fields: sourceFieldsFromPlainObject(structureA, { idPrefix: 'a' }),
+  }),
+  defineDataShape({
+    id: 'b',
+    label: 'B',
+    role: 'target',
+    fields: targetSlotsFromPlainObject({ name: '', labels: [{ title: '' }] }, { idPrefix: 'b' }),
+  }),
+];
+
+const conversion = defineConversion({
+  id: 'a→b',
+  sourceShapeIds: ['a'],
+  targetShapeId: 'b',
+  edges: [
+    {
+      id: 'e-name',
+      sourceFieldId: 'a.user_name',
+      targetSlotId: 'b.name',
+    },
+    {
+      id: 'e-tags',
+      sourceFieldId: 'a.tags',
+      targetSlotId: 'b.labels',
+      itemEdges: [
+        {
+          id: 'e-title',
+          sourceFieldId: 'a.tags.item.name',
+          targetSlotId: 'b.labels.item.title',
+        },
+      ],
+    },
+  ],
+});
+
+const { output } = convertToShape({
+  conversion,
+  shapes,
+  inputs: { a: structureA },
+  transforms: createBuiltinValueTransformRegistry(),
+});
+// { name: 'Ada', labels: [{ title: 'math' }, { title: 'computing' }] }
+```
+
+Hosts may `registry.register()` additional transforms (the sample registers `expr:jsonata` via
+[jsonata](https://jsonata.org/)).
+
+## Layout
+
+```text
+src/
+  domain/document/  edges + FieldRemapDocument
+  domain/shapes/    DataShape, ConversionDefinition, convertToShape
+  domain/ingest/    plain object → fields / slots
+  domain/mapping/   path helpers, list context, conflicts
+  registry/         ValueTransform registry (identity, array:first, array:join)
+```
+
+## Stability
+
+Published on the npm `@prototype` tag. Prefer the root export; deep paths are unsupported.

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@workbench-kit/field-remap",
+  "version": "0.0.1-prototype.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/*.stories.ts",
+    "!src/**/*.stories.tsx"
+  ],
+  "description": "Field remap runtime: convert structure A into structure B via edges and convertToShape.",
+  "publishConfig": {
+    "access": "public",
+    "tag": "prototype",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NewChoBo/workbench-kit.git",
+    "directory": "packages/field-remap"
+  },
+  "scripts": {
+    "test": "pnpm exec vitest run --config ../../vitest.config.ts src",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}

package/src/domain/constants.ts

@@ -0,0 +1,14 @@
+/** Maximum ordered transforms applied on a single edge. */
+export const MAX_TRANSFORM_CHAIN = 3;
+
+/** Built-in pass-through transform id (kept here to avoid import cycles). */
+export const IDENTITY_TRANSFORM_ID = 'identity';
+
+/** Legacy id aliases → canonical ids (empty until hosts need migration). */
+export const TRANSFORM_ID_ALIASES: Readonly<Record<string, string>> = {};
+
+/** Map a legacy or canonical transform id to its canonical form. */
+export function canonicalizeTransformId(id: string): string {
+  const trimmed = id.trim();
+  return TRANSFORM_ID_ALIASES[trimmed] ?? trimmed;
+}

package/src/domain/document/fieldRemapDocument.ts

@@ -0,0 +1,129 @@
+import { normalizeMappingEdges } from './mappingEdge.js';
+import type { MappingEdge, FieldRemapDocument } from '../types.js';
+
+export const FIELD_REMAP_DOCUMENT_VERSION = 1 as const;
+
+/** Thrown when parse/deserialize sees a document `version` other than the supported constant. */
+export class UnsupportedFieldRemapDocumentVersionError extends Error {
+  readonly version: unknown;
+  readonly expectedVersion: typeof FIELD_REMAP_DOCUMENT_VERSION;
+
+  constructor(version: unknown) {
+    super(
+      `Unsupported field remap document version ${String(version)}; expected ${FIELD_REMAP_DOCUMENT_VERSION}.`,
+    );
+    this.name = 'UnsupportedFieldRemapDocumentVersionError';
+    this.version = version;
+    this.expectedVersion = FIELD_REMAP_DOCUMENT_VERSION;
+  }
+}
+
+/** Thrown when parse/deserialize receives a value that is not a mapping document. */
+export class InvalidFieldRemapDocumentError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'InvalidFieldRemapDocumentError';
+  }
+}
+
+/** Build a versioned, normalized mapping document for host persistence. */
+export function createFieldRemapDocument(edges: readonly MappingEdge[]): FieldRemapDocument {
+  return {
+    version: FIELD_REMAP_DOCUMENT_VERSION,
+    edges: normalizeMappingEdges(edges),
+  };
+}
+
+/** Normalize edges (including legacy transform id aliases) on a persisted document. */
+export function normalizeFieldRemapDocument(document: FieldRemapDocument): FieldRemapDocument {
+  if (document.version !== FIELD_REMAP_DOCUMENT_VERSION) {
+    throw new UnsupportedFieldRemapDocumentVersionError(document.version);
+  }
+  return {
+    version: FIELD_REMAP_DOCUMENT_VERSION,
+    edges: normalizeMappingEdges(document.edges),
+  };
+}
+
+/**
+ * Stable JSON serialization for persistence / clipboard.
+ * Always emits the current document version with normalized edges.
+ */
+export function serializeFieldRemapDocument(
+  document: FieldRemapDocument | readonly MappingEdge[],
+): string {
+  const doc = Array.isArray(document)
+    ? createFieldRemapDocument(document)
+    : createFieldRemapDocument((document as FieldRemapDocument).edges);
+  return JSON.stringify(doc);
+}
+
+/**
+ * Parse an unknown JSON value into a normalized `FieldRemapDocument`.
+ * Rejects unsupported versions and malformed shapes with typed errors.
+ */
+export function parseFieldRemapDocument(input: unknown): FieldRemapDocument {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new InvalidFieldRemapDocumentError(
+      'Expected a field remap document object with version and edges.',
+    );
+  }
+
+  const record = input as Record<string, unknown>;
+  if (!('version' in record)) {
+    throw new InvalidFieldRemapDocumentError('Field remap document is missing version.');
+  }
+  if (record.version !== FIELD_REMAP_DOCUMENT_VERSION) {
+    throw new UnsupportedFieldRemapDocumentVersionError(record.version);
+  }
+  if (!Array.isArray(record.edges)) {
+    throw new InvalidFieldRemapDocumentError('Field remap document edges must be an array.');
+  }
+
+  return normalizeFieldRemapDocument({
+    version: FIELD_REMAP_DOCUMENT_VERSION,
+    edges: record.edges as MappingEdge[],
+  });
+}
+
+/** JSON.parse + {@link parseFieldRemapDocument}. */
+export function deserializeFieldRemapDocument(json: string): FieldRemapDocument {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(json) as unknown;
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new InvalidFieldRemapDocumentError(`Field remap document JSON is invalid: ${detail}`);
+  }
+  return parseFieldRemapDocument(parsed);
+}
+
+/**
+ * Migrate an unknown persisted value to the current {@link FieldRemapDocument}.
+ *
+ * Hosts should call this (or `parseFieldRemapDocument`) at load time so future
+ * document versions can be rewritten here without changing call sites.
+ *
+ * **v1:** passthrough normalize (legacy transform id aliases rewritten).
+ * Future versions: add `case` branches that rewrite into v1 shape, then normalize.
+ */
+export function migrateFieldRemapDocument(input: unknown): FieldRemapDocument {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new InvalidFieldRemapDocumentError(
+      'Expected a field remap document object with version and edges.',
+    );
+  }
+
+  const record = input as Record<string, unknown>;
+  if (!('version' in record)) {
+    throw new InvalidFieldRemapDocumentError('Field remap document is missing version.');
+  }
+
+  switch (record.version) {
+    case FIELD_REMAP_DOCUMENT_VERSION:
+      return parseFieldRemapDocument(input);
+    // Future: case 2: return parseFieldRemapDocument(migrateV2ToV1(record));
+    default:
+      throw new UnsupportedFieldRemapDocumentVersionError(record.version);
+  }
+}

package/src/domain/document/mappingEdge.ts

@@ -0,0 +1,136 @@
+import {
+  canonicalizeTransformId,
+  IDENTITY_TRANSFORM_ID,
+  MAX_TRANSFORM_CHAIN,
+} from '../constants.js';
+import {
+  sanitizeOptionRecord,
+  sanitizeOptionSteps,
+  sharedOptionsFromSteps,
+} from '../mapping/transformOptions.js';
+import type { MappingEdge } from '../types.js';
+
+export { MAX_TRANSFORM_CHAIN } from '../constants.js';
+
+function sanitizeTransformIds(ids: readonly string[] | undefined): string[] {
+  const cleaned = ids
+    ?.map((id) => canonicalizeTransformId(id))
+    .filter((id) => id.length > 0 && id !== IDENTITY_TRANSFORM_ID);
+  if (!cleaned || cleaned.length === 0) {
+    return [];
+  }
+  return cleaned.slice(0, MAX_TRANSFORM_CHAIN);
+}
+
+/**
+ * Resolve the effective transform chain for an edge.
+ * Prefers `transformIds`; falls back to legacy `transformId`.
+ * Identity / empty / null → `[]` (pass-through).
+ */
+export function edgeTransformIds(edge: MappingEdge): string[] {
+  const fromList = sanitizeTransformIds(edge.transformIds);
+  if (fromList.length > 0) {
+    return fromList;
+  }
+
+  const legacy = edge.transformId ? canonicalizeTransformId(edge.transformId) : '';
+  if (legacy && legacy !== IDENTITY_TRANSFORM_ID) {
+    return [legacy];
+  }
+
+  return [];
+}
+
+/** Per-item transform chain applied after optional `itemSourcePath` projection. */
+export function edgeItemTransformIds(edge: MappingEdge): string[] {
+  return sanitizeTransformIds(edge.itemTransformIds);
+}
+
+/**
+ * Normalize an edge to the `transformIds` model while keeping `transformId`
+ * as the first chain step (or `null`) for older hosts.
+ *
+ * Option bags:
+ * - Prefer `transformOptionSteps` when present (aligned to chain length).
+ * - Keep `transformOptions` as the first non-empty step (or the legacy shared bag).
+ * - Same rules for `itemTransformOptionSteps` / `itemTransformOptions`.
+ */
+export function normalizeMappingEdge(edge: MappingEdge): MappingEdge {
+  const ids = edgeTransformIds(edge);
+  const itemIds = edgeItemTransformIds(edge);
+  const itemSourcePath = edge.itemSourcePath?.trim() || undefined;
+  const itemEdges =
+    edge.itemEdges && edge.itemEdges.length > 0
+      ? edge.itemEdges.map((child) => {
+          // One collection level — drop nested list contexts on children.
+          const { itemEdges: _nested, ...rest } = child;
+          return normalizeMappingEdge(rest);
+        })
+      : undefined;
+
+  const transformOptionSteps = sanitizeOptionSteps(edge.transformOptionSteps, ids.length);
+  const transformOptions =
+    sharedOptionsFromSteps(transformOptionSteps) ?? sanitizeOptionRecord(edge.transformOptions);
+
+  const itemTransformOptionSteps = sanitizeOptionSteps(
+    edge.itemTransformOptionSteps,
+    itemIds.length,
+  );
+  const itemTransformOptions =
+    sharedOptionsFromSteps(itemTransformOptionSteps) ??
+    sanitizeOptionRecord(edge.itemTransformOptions);
+
+  return {
+    id: edge.id,
+    sourceFieldId: edge.sourceFieldId,
+    targetSlotId: edge.targetSlotId,
+    transformIds: ids.length > 0 ? ids : undefined,
+    transformId: ids[0] ?? null,
+    ...(transformOptionSteps ? { transformOptionSteps } : {}),
+    ...(transformOptions ? { transformOptions } : {}),
+    ...(itemSourcePath && !itemEdges ? { itemSourcePath } : {}),
+    ...(itemIds.length > 0 && !itemEdges ? { itemTransformIds: itemIds } : {}),
+    ...(itemTransformOptionSteps && !itemEdges ? { itemTransformOptionSteps } : {}),
+    ...(itemTransformOptions && !itemEdges ? { itemTransformOptions } : {}),
+    ...(itemEdges ? { itemEdges } : {}),
+  };
+}
+
+export function normalizeMappingEdges(edges: readonly MappingEdge[]): MappingEdge[] {
+  return edges.map(normalizeMappingEdge);
+}
+
+/** Build a normalized edge from wire / assign actions. */
+export function createMappingEdge(input: {
+  readonly id: string;
+  readonly sourceFieldId: string;
+  readonly targetSlotId: string;
+  readonly transformIds?: readonly string[];
+  /** Legacy single id; ignored when `transformIds` is provided. */
+  readonly transformId?: string | null;
+  readonly transformOptionSteps?: readonly (Readonly<Record<string, unknown>> | undefined)[];
+  readonly transformOptions?: Readonly<Record<string, unknown>>;
+  /** Optional per-item projection path for array mappings. */
+  readonly itemSourcePath?: string;
+  /** Optional per-item transform chain after projection. */
+  readonly itemTransformIds?: readonly string[];
+  readonly itemTransformOptionSteps?: readonly (Readonly<Record<string, unknown>> | undefined)[];
+  readonly itemTransformOptions?: Readonly<Record<string, unknown>>;
+  /** List-context child edges for array-of-object → array-of-object. */
+  readonly itemEdges?: readonly MappingEdge[];
+}): MappingEdge {
+  return normalizeMappingEdge({
+    id: input.id,
+    sourceFieldId: input.sourceFieldId,
+    targetSlotId: input.targetSlotId,
+    transformIds: input.transformIds,
+    transformId: input.transformId,
+    transformOptionSteps: input.transformOptionSteps,
+    transformOptions: input.transformOptions,
+    itemSourcePath: input.itemSourcePath,
+    itemTransformIds: input.itemTransformIds,
+    itemTransformOptionSteps: input.itemTransformOptionSteps,
+    itemTransformOptions: input.itemTransformOptions,
+    itemEdges: input.itemEdges,
+  });
+}

package/src/domain/ingest/sourceFieldsFromPlainObject.ts

@@ -0,0 +1,103 @@
+import { isPlainObject } from '../mapping/pathUtils.js';
+import type { FieldDataType, SourceField } from '../types.js';
+
+export interface SourceFieldsFromPlainObjectOptions {
+  /** Prefix for generated field ids (default `src`). */
+  readonly idPrefix?: string;
+  /** Max nesting depth for object children (default 4). */
+  readonly maxDepth?: number;
+}
+
+function inferDataType(value: unknown): FieldDataType {
+  if (value === null || value === undefined) {
+    return 'unknown';
+  }
+  if (typeof value === 'string') {
+    return 'string';
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return 'number';
+  }
+  if (typeof value === 'boolean') {
+    return 'boolean';
+  }
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return 'datetime';
+  }
+  if (Array.isArray(value)) {
+    return 'array';
+  }
+  if (isPlainObject(value)) {
+    return 'object';
+  }
+  return 'unknown';
+}
+
+function fieldFromEntry(
+  key: string,
+  value: unknown,
+  path: string,
+  idPrefix: string,
+  depth: number,
+  maxDepth: number,
+): SourceField {
+  const id = path ? `${idPrefix}.${path}` : `${idPrefix}.${key}`;
+  const dataType = inferDataType(value);
+  const base: SourceField = {
+    id,
+    label: key,
+    path,
+    dataType,
+    sampleValue: value,
+  };
+
+  if (depth >= maxDepth) {
+    return base;
+  }
+
+  if (isPlainObject(value)) {
+    const children = Object.entries(value).map(([childKey, childValue]) =>
+      fieldFromEntry(
+        childKey,
+        childValue,
+        path ? `${path}.${childKey}` : childKey,
+        idPrefix,
+        depth + 1,
+        maxDepth,
+      ),
+    );
+    return children.length > 0 ? { ...base, children } : base;
+  }
+
+  if (Array.isArray(value) && value.length > 0 && isPlainObject(value[0])) {
+    const sampleItem = value[0] as Record<string, unknown>;
+    const children = Object.entries(sampleItem).map(([childKey, childValue]) =>
+      fieldFromEntry(childKey, childValue, childKey, `${id}.item`, depth + 1, maxDepth),
+    );
+    return children.length > 0 ? { ...base, children } : base;
+  }
+
+  return base;
+}
+
+/**
+ * Infer a shallow/nested `SourceField` tree from a plain sample object.
+ * Useful for demos and hosts that have a sample payload but no formal schema.
+ *
+ * - Top-level keys become root fields.
+ * - Nested plain objects become `children` (up to `maxDepth`).
+ * - Arrays of objects expose item-key children for projection pickers.
+ */
+export function sourceFieldsFromPlainObject(
+  sample: unknown,
+  options: SourceFieldsFromPlainObjectOptions = {},
+): SourceField[] {
+  if (!isPlainObject(sample)) {
+    return [];
+  }
+  const idPrefix = options.idPrefix?.trim() || 'src';
+  const maxDepth = Math.max(0, options.maxDepth ?? 4);
+  return Object.entries(sample).map(([key, value]) =>
+    fieldFromEntry(key, value, key, idPrefix, 0, maxDepth),
+  );
+}

package/src/domain/ingest/targetSlotsFromPlainObject.ts

@@ -0,0 +1,41 @@
+import { sourceFieldsFromPlainObject } from './sourceFieldsFromPlainObject.js';
+import type { SourceField, TargetSlot } from '../types.js';
+
+export interface TargetSlotsFromPlainObjectOptions {
+  /** Prefix for generated slot ids (default `tgt`). */
+  readonly idPrefix?: string;
+  /** Max nesting depth for object children (default 4). */
+  readonly maxDepth?: number;
+}
+
+function sourceFieldToTargetSlot(field: SourceField): TargetSlot {
+  const slot: TargetSlot = {
+    id: field.id,
+    label: field.label,
+    ...(field.path ? { path: field.path } : {}),
+    ...(field.dataType ? { dataType: field.dataType } : {}),
+  };
+  if (field.children && field.children.length > 0) {
+    return {
+      ...slot,
+      children: field.children.map(sourceFieldToTargetSlot),
+    };
+  }
+  return slot;
+}
+
+/**
+ * Infer a nested `TargetSlot` tree from a plain sample object (or target shape).
+ * Mirrors {@link sourceFieldsFromPlainObject}: same nesting / array-of-object rules,
+ * keeping `path` for `convertToShape` output assembly (no `sampleValue`).
+ */
+export function targetSlotsFromPlainObject(
+  sample: unknown,
+  options: TargetSlotsFromPlainObjectOptions = {},
+): TargetSlot[] {
+  const idPrefix = options.idPrefix?.trim() || 'tgt';
+  return sourceFieldsFromPlainObject(sample, {
+    idPrefix,
+    maxDepth: options.maxDepth,
+  }).map(sourceFieldToTargetSlot);
+}

package/src/domain/mapping/convertItemEdges.ts

@@ -0,0 +1,93 @@
+import { edgeTransformIds } from '../document/mappingEdge.js';
+import { applyTransformChain } from '../../registry/createValueTransformRegistry.js';
+import { BUILTIN_TRANSFORM_IDS } from '../../registry/builtinTransforms.js';
+import { resolveOptionSteps } from './transformOptions.js';
+import { isPlainObject, readObjectPath, writeObjectPath } from './pathUtils.js';
+import { findTargetSlot, flattenSourceFields, flattenTargetSlots } from './treeUtils.js';
+import type {
+  MappingEdge,
+  SourceField,
+  TargetSlot,
+  TransformContext,
+  ValueTransformRegistry,
+} from '../types.js';
+
+function findSourceField(fields: readonly SourceField[], fieldId: string): SourceField | undefined {
+  return flattenSourceFields(fields).find((field) => field.id === fieldId);
+}
+
+function itemRelativePath(
+  node: { readonly path?: string; readonly label: string; readonly id: string } | undefined,
+): string {
+  if (!node) {
+    return '';
+  }
+  const path = node.path?.trim();
+  if (path) {
+    return path;
+  }
+  return node.label.trim() || node.id.split('.').pop() || '';
+}
+
+/**
+ * Convert each object in a source array through list-context `itemEdges`.
+ * Child field paths are treated as item-relative (ingest array children).
+ */
+export function convertArrayWithItemEdges(input: {
+  readonly items: unknown;
+  readonly itemEdges: readonly MappingEdge[];
+  readonly sources: readonly SourceField[];
+  readonly targets: readonly TargetSlot[];
+  readonly transforms: ValueTransformRegistry;
+  readonly context?: TransformContext;
+}): unknown[] {
+  if (!Array.isArray(input.items)) {
+    return [];
+  }
+
+  const targetLeaves = flattenTargetSlots(input.targets);
+
+  return input.items.map((rawItem) => {
+    const item = isPlainObject(rawItem) ? rawItem : {};
+    let outItem: Record<string, unknown> = {};
+
+    for (const edge of input.itemEdges) {
+      const sourceField = findSourceField(input.sources, edge.sourceFieldId);
+      const targetSlot =
+        findTargetSlot(input.targets, edge.targetSlotId) ??
+        targetLeaves.find((slot) => slot.id === edge.targetSlotId);
+      if (!sourceField || !targetSlot) {
+        continue;
+      }
+
+      const sourcePath = itemRelativePath(sourceField);
+      const sourceValue = sourcePath ? readObjectPath(item, sourcePath) : undefined;
+
+      const chain = edgeTransformIds(edge);
+      let value: unknown;
+      if (chain.length === 0) {
+        const identity = input.transforms.get(BUILTIN_TRANSFORM_IDS.identity);
+        value = identity
+          ? identity.apply(sourceValue, { ...input.context, sampleValue: sourceValue })
+          : sourceValue;
+      } else {
+        const steps = resolveOptionSteps(chain, edge.transformOptionSteps, edge.transformOptions);
+        value = applyTransformChain(
+          input.transforms,
+          chain,
+          sourceValue,
+          { ...input.context, sampleValue: sourceValue },
+          steps,
+        );
+      }
+
+      const targetPath = itemRelativePath(targetSlot);
+      if (!targetPath) {
+        continue;
+      }
+      outItem = writeObjectPath(outItem, targetPath, value);
+    }
+
+    return outItem;
+  });
+}