@workbench-kit/shell-react 0.0.2-prototype.0.2.6

package/src/extension-management-model.ts

@@ -0,0 +1,313 @@
+import {
+  BUILTIN_WORKBENCH_EXTENSIONS,
+  SAMPLE_WORKBENCH_EXTENSIONS,
+  createExtensionFeatureSpec,
+  createExtensionInstallPlan,
+  resolveBundledExtensionByManifestUrl,
+  type ExtensionCatalogEntry,
+  type ExtensionFeatureInspection,
+  type ExtensionFeatureSpec,
+  type ExtensionInstallPlan,
+  type ExtensionInstallPlanInstallSource,
+  type ExtensionRegistry,
+  type InstalledExtensionRecord,
+  type WorkbenchExtensionDescription,
+} from '@workbench-kit/workbench-core';
+import type {
+  ExtensionCatalogBrowseEntry,
+  ExtensionManagementDiagnosticSummary,
+  ExtensionManagementEntry,
+  ExtensionManagementFeatureSummary,
+} from '@workbench-kit/react/workbench/management';
+
+export const BUNDLED_EXTENSIONS = [
+  ...BUILTIN_WORKBENCH_EXTENSIONS,
+  ...SAMPLE_WORKBENCH_EXTENSIONS,
+] as const;
+
+export interface CreateExtensionManagementEntriesInput {
+  readonly extensionRegistry: ExtensionRegistry;
+  readonly installedRecords: readonly InstalledExtensionRecord[];
+}
+
+export interface CreateExtensionCatalogBrowseEntriesInput extends CreateExtensionManagementEntriesInput {
+  readonly catalogEntries: readonly ExtensionCatalogEntry[];
+}
+
+export interface ExtensionInstallPlanningContext extends CreateExtensionManagementEntriesInput {
+  readonly availableExtensions: readonly WorkbenchExtensionDescription[];
+  readonly enabledExtensionIds: readonly string[];
+  readonly hostCapabilityIds: readonly string[];
+  readonly installSources: readonly ExtensionInstallPlanInstallSource[];
+}
+
+export function createExtensionManagementEntries({
+  extensionRegistry,
+  installedRecords,
+}: CreateExtensionManagementEntriesInput): readonly ExtensionManagementEntry[] {
+  const installedById = new Map(installedRecords.map((record) => [record.id, record]));
+  const extensionFeatures = createExtensionManagementFeatureMaps(extensionRegistry);
+  const bundledEntries = BUNDLED_EXTENSIONS.map((extension) => {
+    const installed = installedById.get(extension.manifest.id);
+    const isBuiltin = extension.manifest.id.startsWith('workbench-kit.builtin.');
+    const featureState = resolveExtensionManagementFeatureState(
+      extension.manifest.id,
+      extensionFeatures,
+    );
+
+    return {
+      category: installed?.category ?? (isBuiltin ? 'builtin' : 'sample'),
+      description: extension.manifest.displayName,
+      diagnostics: featureState.diagnostics,
+      displayName: extension.manifest.displayName,
+      enabled: isBuiltin ? true : (installed?.enabled ?? false),
+      features: featureState.features,
+      id: extension.manifest.id,
+      installedAt: installed?.installedAt,
+      manifestUrl: installed?.manifestUrl,
+      source: isBuiltin ? ('bundled' as const) : ('installed' as const),
+    } satisfies ExtensionManagementEntry;
+  }).filter((entry) => entry.source === 'bundled' || installedById.has(entry.id));
+
+  const activeExtensions = extensionRegistry
+    .getExtensions()
+    .filter(
+      (extension) =>
+        !BUNDLED_EXTENSIONS.some((bundled) => bundled.manifest.id === extension.manifest.id),
+    )
+    .map((extension) => {
+      const installed = installedById.get(extension.manifest.id);
+      const featureState = resolveExtensionManagementFeatureState(
+        extension.manifest.id,
+        extensionFeatures,
+      );
+
+      return {
+        category: installed?.category ?? 'installed',
+        description: extension.manifest.displayName,
+        diagnostics: featureState.diagnostics,
+        displayName: extension.manifest.displayName,
+        enabled: installed?.enabled ?? true,
+        features: featureState.features,
+        id: extension.manifest.id,
+        installedAt: installed?.installedAt,
+        manifestUrl: installed?.manifestUrl,
+        source: 'installed',
+      } satisfies ExtensionManagementEntry;
+    });
+
+  return [...bundledEntries, ...activeExtensions].sort((left, right) =>
+    left.displayName.localeCompare(right.displayName),
+  );
+}
+
+export function createExtensionCatalogBrowseEntries({
+  catalogEntries,
+  extensionRegistry,
+  installedRecords,
+}: CreateExtensionCatalogBrowseEntriesInput): readonly ExtensionCatalogBrowseEntry[] {
+  const installedIds = new Set(installedRecords.map((record) => record.id));
+  const installContext = createExtensionInstallPlanningContext({
+    catalogEntries,
+    extensionRegistry,
+    installedRecords,
+  });
+
+  return catalogEntries.map((entry) => {
+    const bundledExtension = resolveBundledExtensionByManifestUrl(
+      entry.manifestUrl,
+      installContext.availableExtensions,
+    );
+    const extensionId = bundledExtension?.manifest.id ?? entry.id;
+    const plan = createCatalogEntryInstallPlan(entry, installContext);
+
+    return {
+      category: entry.category,
+      description: entry.description,
+      displayName: entry.displayName,
+      icon: entry.icon,
+      id: extensionId,
+      installPlan: plan ? toExtensionInstallPlanSummary(plan) : undefined,
+      installed: installedIds.has(extensionId),
+      manifestUrl: entry.manifestUrl,
+    };
+  });
+}
+
+export function createExtensionInstallPlanningContext({
+  catalogEntries,
+  extensionRegistry,
+  installedRecords,
+}: CreateExtensionCatalogBrowseEntriesInput): ExtensionInstallPlanningContext {
+  const availableExtensions = mergeUniqueExtensionDescriptions([
+    ...BUNDLED_EXTENSIONS,
+    ...extensionRegistry.getExtensions(),
+  ]);
+
+  return {
+    availableExtensions,
+    enabledExtensionIds: extensionRegistry
+      .getExtensions()
+      .map((extension) => extension.manifest.id),
+    extensionRegistry,
+    hostCapabilityIds: extensionRegistry.capabilityRegistry.listProviderIds(),
+    installSources: createExtensionInstallSources(catalogEntries, availableExtensions),
+    installedRecords,
+  };
+}
+
+export function createCatalogEntryInstallPlan(
+  entry: Pick<ExtensionCatalogBrowseEntry, 'manifestUrl'>,
+  {
+    availableExtensions,
+    enabledExtensionIds,
+    hostCapabilityIds,
+    installedRecords,
+    installSources,
+  }: ExtensionInstallPlanningContext,
+): ExtensionInstallPlan | undefined {
+  const bundledExtension = resolveBundledExtensionByManifestUrl(
+    entry.manifestUrl,
+    availableExtensions,
+  );
+  if (!bundledExtension) {
+    return undefined;
+  }
+
+  return createExtensionInstallPlan({
+    availableExtensions,
+    enabledExtensionIds,
+    hostCapabilityIds,
+    installSources,
+    installedRecords,
+    targetExtensionId: bundledExtension.manifest.id,
+  });
+}
+
+function createExtensionInstallSources(
+  catalogEntries: readonly ExtensionCatalogEntry[],
+  availableExtensions: readonly WorkbenchExtensionDescription[],
+): readonly ExtensionInstallPlanInstallSource[] {
+  const byId = new Map<string, ExtensionInstallPlanInstallSource>();
+  for (const entry of catalogEntries) {
+    const bundledExtension = resolveBundledExtensionByManifestUrl(
+      entry.manifestUrl,
+      availableExtensions,
+    );
+    const extensionId = bundledExtension?.manifest.id ?? entry.id;
+    byId.set(extensionId, {
+      category: entry.category,
+      id: extensionId,
+      manifestUrl: entry.manifestUrl,
+    });
+  }
+
+  return [...byId.values()];
+}
+
+function mergeUniqueExtensionDescriptions(
+  descriptions: readonly WorkbenchExtensionDescription[],
+): readonly WorkbenchExtensionDescription[] {
+  const byId = new Map<string, WorkbenchExtensionDescription>();
+  for (const description of descriptions) {
+    byId.set(description.manifest.id, description);
+  }
+  return [...byId.values()];
+}
+
+function createExtensionManagementFeatureMaps(extensionRegistry: ExtensionRegistry) {
+  return {
+    bundledFeaturesById: new Map(
+      BUNDLED_EXTENSIONS.map((extension) => [
+        extension.manifest.id,
+        createExtensionFeatureSpec(extension),
+      ]),
+    ),
+    inspectionsById: new Map(
+      extensionRegistry
+        .getFeatureInspections()
+        .map((inspection) => [inspection.feature.id, inspection]),
+    ),
+  };
+}
+
+function resolveExtensionManagementFeatureState(
+  extensionId: string,
+  {
+    bundledFeaturesById,
+    inspectionsById,
+  }: {
+    bundledFeaturesById: ReadonlyMap<string, ExtensionFeatureSpec>;
+    inspectionsById: ReadonlyMap<string, ExtensionFeatureInspection>;
+  },
+): {
+  readonly diagnostics?: readonly ExtensionManagementDiagnosticSummary[] | undefined;
+  readonly features?: ExtensionManagementFeatureSummary | undefined;
+} {
+  const inspection = inspectionsById.get(extensionId);
+  const feature = inspection?.feature ?? bundledFeaturesById.get(extensionId);
+
+  return {
+    diagnostics: inspection?.diagnostics.map(({ message, severity }) => ({ message, severity })),
+    features: feature ? toExtensionManagementFeatureSummary(feature) : undefined,
+  };
+}
+
+function toExtensionManagementFeatureSummary(
+  feature: ExtensionFeatureSpec,
+): ExtensionManagementFeatureSummary {
+  const commandTitlesById = new Map(feature.commands.map((command) => [command.id, command.title]));
+
+  return {
+    capabilities: feature.capabilities,
+    commands: feature.commands.map((command) => ({
+      description: command.description,
+      id: command.id,
+      label: command.title,
+    })),
+    documentViews: feature.documentViews.map((view) => ({
+      id: view.id,
+      label: view.label,
+    })),
+    menus: feature.menus.map((menu) => ({
+      description: formatMenuContributionDescription(menu.group, menu.order),
+      id: `${menu.menu}:${menu.command}`,
+      label: `${menu.menu}: ${commandTitlesById.get(menu.command) ?? menu.command}`,
+    })),
+    permissions: feature.permissions,
+    settings: feature.settings.map((setting) => ({
+      description: setting.description,
+      id: setting.key,
+      label: setting.key,
+    })),
+    views: feature.views.map((view) => ({
+      id: view.id,
+      label: view.name,
+    })),
+  };
+}
+
+function toExtensionInstallPlanSummary(
+  plan: ExtensionInstallPlan,
+): ExtensionCatalogBrowseEntry['installPlan'] {
+  return {
+    blocked: plan.blocked,
+    diagnostics: plan.diagnostics.map(({ message, severity }) => ({ message, severity })),
+    enableExtensionIds: plan.enableExtensionIds,
+    installExtensionIds: plan.installExtensionIds,
+    permissions: plan.permissions,
+    requiresApproval: plan.requiresApproval,
+  };
+}
+
+function formatMenuContributionDescription(
+  group: string | undefined,
+  order: number | undefined,
+): string | undefined {
+  const parts = [
+    group ? `group: ${group}` : undefined,
+    order !== undefined ? `order: ${order}` : undefined,
+  ].filter((part): part is string => part !== undefined);
+
+  return parts.length > 0 ? parts.join(', ') : undefined;
+}

package/src/extensions-view-data.ts

@@ -0,0 +1,19 @@
+export const BUILTIN_EXTENSIONS_VIEW_RENDER_KIND = 'workbench-kit.builtin.extensions.view' as const;
+export const BUILTIN_EXTENSIONS_VIEW_CONTAINER_ID = 'extensions' as const;
+export const BUILTIN_EXTENSIONS_FOCUS_COMMAND_ID =
+  'workbench-kit.builtin.extensions.focus' as const;
+
+export interface BuiltinExtensionsViewRenderData {
+  readonly kind: typeof BUILTIN_EXTENSIONS_VIEW_RENDER_KIND;
+}
+
+export function isBuiltinExtensionsViewRenderData(
+  value: unknown,
+): value is BuiltinExtensionsViewRenderData {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'kind' in value &&
+    (value as BuiltinExtensionsViewRenderData).kind === BUILTIN_EXTENSIONS_VIEW_RENDER_KIND
+  );
+}

package/src/extensions-view.tsx

@@ -0,0 +1,38 @@
+import { ExtensionManagementSidebar } from '@workbench-kit/react/workbench/management';
+
+import {
+  BUILTIN_EXTENSIONS_VIEW_RENDER_KIND,
+  isBuiltinExtensionsViewRenderData,
+  type BuiltinExtensionsViewRenderData,
+} from './extensions-view-data.js';
+import { useExtensionManagementModel } from './use-extension-management.js';
+import { useWorkbench } from './provider.js';
+
+export type { BuiltinExtensionsViewRenderData };
+export { BUILTIN_EXTENSIONS_VIEW_RENDER_KIND, isBuiltinExtensionsViewRenderData };
+
+export function BuiltinExtensionsView({ catalogUrl }: { catalogUrl?: string | undefined }) {
+  const { missingExtensionIds } = useWorkbench();
+  const {
+    browseEntries,
+    catalogError,
+    catalogLoading,
+    installCatalogEntry,
+    installedEntries,
+    pendingAction,
+    toggleInstalledEntry,
+  } = useExtensionManagementModel({ catalogUrl });
+
+  return (
+    <ExtensionManagementSidebar
+      browseEntries={browseEntries}
+      catalogError={catalogError}
+      catalogLoading={catalogLoading}
+      installedEntries={installedEntries}
+      missingExtensionIds={missingExtensionIds}
+      pendingAction={pendingAction}
+      onInstall={installCatalogEntry}
+      onToggleEnabled={toggleInstalledEntry}
+    />
+  );
+}

package/src/field-remap-demo.tsx

@@ -0,0 +1,18 @@
+import type { JSX } from 'react';
+
+import { FieldRemapPanel } from './field-remap-panel.js';
+import { getFieldRemapSample, type FieldRemapSampleId } from './field-remap-samples.js';
+
+export interface SampleFieldRemapDemoProps {
+  readonly sampleId?: FieldRemapSampleId | string | undefined;
+}
+
+/**
+ * Sample host wrapper around {@link FieldRemapPanel}.
+ */
+export function SampleFieldRemapDemo({
+  sampleId = 'nested-ab',
+}: SampleFieldRemapDemoProps = {}): JSX.Element {
+  const sample = getFieldRemapSample(sampleId);
+  return <FieldRemapPanel key={sample.id} sample={sample} />;
+}

package/src/field-remap-editor-surface.tsx

@@ -0,0 +1,36 @@
+import type { JSX } from 'react';
+import { ScrollArea } from '@workbench-kit/react/primitives';
+
+import { SampleFieldRemapDemo } from './field-remap-demo.js';
+import { resolveFieldRemapSampleId } from './field-remap-samples.js';
+import './field-remap-view.css';
+
+export type FieldRemapEditorSurfaceId = string;
+
+export interface FieldRemapEditorSurfaceProps {
+  readonly resourceUri: string;
+  readonly surfaceId: FieldRemapEditorSurfaceId;
+  readonly tabId: string;
+}
+
+export function FieldRemapEditorSurface({
+  resourceUri,
+  surfaceId,
+  tabId,
+}: FieldRemapEditorSurfaceProps): JSX.Element {
+  const sampleId = resolveFieldRemapSampleId(surfaceId);
+
+  return (
+    <ScrollArea
+      aria-label={`${sampleId} field remap`}
+      className="workbench-field-remap-editor-surface"
+      data-editor-host-id={tabId}
+      data-resource-uri={resourceUri}
+      data-sample-id={sampleId}
+      data-testid="field-remap-editor-surface"
+      orientation="vertical"
+    >
+      <SampleFieldRemapDemo sampleId={sampleId} />
+    </ScrollArea>
+  );
+}

package/src/field-remap-flow-adapter.ts

@@ -0,0 +1,240 @@
+import type { Edge, Node } from '@xyflow/react';
+import {
+  flattenSourceFields,
+  flattenTargetSlots,
+  type MappingEdge,
+  type SourceField,
+  type TargetSlot,
+  type ValueTransformRegistry,
+} from '@workbench-kit/field-remap';
+
+export type FieldRemapFlowNodeKind = 'source-object' | 'target-object' | 'transform';
+
+export type FieldRemapPort = {
+  fieldId: string;
+  label: string;
+  dataType?: string;
+};
+
+/** XYFlow requires node/edge `data` to extend `Record<string, unknown>`. */
+export type FieldRemapSourceObjectNodeData = {
+  kind: 'source-object';
+  title: string;
+  ports: FieldRemapPort[];
+} & Record<string, unknown>;
+
+export type FieldRemapTargetObjectNodeData = {
+  kind: 'target-object';
+  title: string;
+  ports: FieldRemapPort[];
+} & Record<string, unknown>;
+
+export type FieldRemapTransformNodeData = {
+  kind: 'transform';
+  mappingEdgeId: string;
+  stepIndex: number;
+  transformId: string;
+  label: string;
+} & Record<string, unknown>;
+
+export type FieldRemapFlowNodeData =
+  FieldRemapSourceObjectNodeData | FieldRemapTargetObjectNodeData | FieldRemapTransformNodeData;
+
+export type FieldRemapFlowEdgeData = {
+  mappingEdgeId: string;
+  segment: 'in' | 'mid' | 'out' | 'direct';
+} & Record<string, unknown>;
+
+export const SOURCE_OBJECT_NODE_ID = 'obj:source' as const;
+export const TARGET_OBJECT_NODE_ID = 'obj:target' as const;
+
+const SOURCE_X = 24;
+const TRANSFORM_X = 320;
+const TARGET_X = 620;
+const TRANSFORM_ROW_GAP = 72;
+
+export function sourceObjectNodeId(): string {
+  return SOURCE_OBJECT_NODE_ID;
+}
+
+export function targetObjectNodeId(): string {
+  return TARGET_OBJECT_NODE_ID;
+}
+
+/** Handle id for a field/slot port on an object node. */
+export function portHandleId(fieldOrSlotId: string): string {
+  return fieldOrSlotId;
+}
+
+export function transformNodeId(mappingEdgeId: string, stepIndex: number): string {
+  return `xf:${mappingEdgeId}:${stepIndex}`;
+}
+
+function fieldLabel(field: SourceField | TargetSlot): string {
+  return field.path ?? field.label;
+}
+
+function toPorts(fields: readonly (SourceField | TargetSlot)[]): FieldRemapPort[] {
+  return fields.map((field) => ({
+    fieldId: field.id,
+    label: fieldLabel(field),
+    dataType: field.dataType,
+  }));
+}
+
+/**
+ * Build React Flow nodes/edges from kit shapes + MappingEdge[].
+ * Layout: one multi-port source object, transform chain, one multi-port target object.
+ */
+export function mappingToFlowGraph(input: {
+  readonly sources: readonly SourceField[];
+  readonly targets: readonly TargetSlot[];
+  readonly edges: readonly MappingEdge[];
+  readonly transforms: ValueTransformRegistry;
+  readonly sourceTitle?: string;
+  readonly targetTitle?: string;
+}): { nodes: Node<FieldRemapFlowNodeData>[]; edges: Edge<FieldRemapFlowEdgeData>[] } {
+  const sourcePorts = toPorts(flattenSourceFields(input.sources));
+  const targetPorts = toPorts(flattenTargetSlots(input.targets));
+
+  const nodes: Node<FieldRemapFlowNodeData>[] = [
+    {
+      id: SOURCE_OBJECT_NODE_ID,
+      type: 'fieldRemapSourceObject',
+      position: { x: SOURCE_X, y: 24 },
+      data: {
+        kind: 'source-object',
+        title: input.sourceTitle?.trim() || 'Source',
+        ports: sourcePorts,
+      },
+      draggable: true,
+    },
+    {
+      id: TARGET_OBJECT_NODE_ID,
+      type: 'fieldRemapTargetObject',
+      position: { x: TARGET_X, y: 24 },
+      data: {
+        kind: 'target-object',
+        title: input.targetTitle?.trim() || 'Target',
+        ports: targetPorts,
+      },
+      draggable: true,
+    },
+  ];
+
+  const flowEdges: Edge<FieldRemapFlowEdgeData>[] = [];
+
+  input.edges.forEach((edge, edgeIndex) => {
+    const chain = edge.transformIds ?? [];
+    const baseY = 40 + edgeIndex * TRANSFORM_ROW_GAP;
+
+    if (chain.length === 0) {
+      flowEdges.push({
+        id: `fe:${edge.id}:direct`,
+        source: SOURCE_OBJECT_NODE_ID,
+        sourceHandle: portHandleId(edge.sourceFieldId),
+        target: TARGET_OBJECT_NODE_ID,
+        targetHandle: portHandleId(edge.targetSlotId),
+        type: 'smoothstep',
+        data: { mappingEdgeId: edge.id, segment: 'direct' },
+      });
+      return;
+    }
+
+    chain.forEach((transformId, stepIndex) => {
+      const definition = input.transforms.get(transformId);
+      nodes.push({
+        id: transformNodeId(edge.id, stepIndex),
+        type: 'fieldRemapTransform',
+        position: {
+          x: TRANSFORM_X + stepIndex * 36,
+          y: baseY + stepIndex * 48,
+        },
+        data: {
+          kind: 'transform',
+          mappingEdgeId: edge.id,
+          stepIndex,
+          transformId,
+          label: definition?.label ?? transformId,
+        },
+        draggable: true,
+      });
+    });
+
+    flowEdges.push({
+      id: `fe:${edge.id}:in`,
+      source: SOURCE_OBJECT_NODE_ID,
+      sourceHandle: portHandleId(edge.sourceFieldId),
+      target: transformNodeId(edge.id, 0),
+      targetHandle: 'in',
+      type: 'smoothstep',
+      data: { mappingEdgeId: edge.id, segment: 'in' },
+    });
+
+    for (let stepIndex = 0; stepIndex < chain.length - 1; stepIndex += 1) {
+      flowEdges.push({
+        id: `fe:${edge.id}:mid:${stepIndex}`,
+        source: transformNodeId(edge.id, stepIndex),
+        sourceHandle: 'out',
+        target: transformNodeId(edge.id, stepIndex + 1),
+        targetHandle: 'in',
+        type: 'smoothstep',
+        data: { mappingEdgeId: edge.id, segment: 'mid' },
+      });
+    }
+
+    flowEdges.push({
+      id: `fe:${edge.id}:out`,
+      source: transformNodeId(edge.id, chain.length - 1),
+      sourceHandle: 'out',
+      target: TARGET_OBJECT_NODE_ID,
+      targetHandle: portHandleId(edge.targetSlotId),
+      type: 'smoothstep',
+      data: { mappingEdgeId: edge.id, segment: 'out' },
+    });
+  });
+
+  return { nodes, edges: flowEdges };
+}
+
+/** Parse React Flow connection (object ports or legacy) into a kit MappingEdge. */
+export function connectionToMappingEdge(input: {
+  readonly sourceNodeId: string;
+  readonly targetNodeId: string;
+  readonly sourceHandle?: string | null;
+  readonly targetHandle?: string | null;
+  readonly existing: readonly MappingEdge[];
+}): MappingEdge | null {
+  let sourceFieldId: string | undefined;
+  let targetSlotId: string | undefined;
+
+  if (input.sourceNodeId === SOURCE_OBJECT_NODE_ID && input.sourceHandle) {
+    sourceFieldId = input.sourceHandle;
+  } else if (input.sourceNodeId.startsWith('src:')) {
+    // Legacy single-field node ids (older graphs / tests).
+    sourceFieldId = input.sourceNodeId.slice('src:'.length);
+  }
+
+  if (input.targetNodeId === TARGET_OBJECT_NODE_ID && input.targetHandle) {
+    targetSlotId = input.targetHandle;
+  } else if (input.targetNodeId.startsWith('tgt:')) {
+    targetSlotId = input.targetNodeId.slice('tgt:'.length);
+  }
+
+  if (!sourceFieldId || !targetSlotId) {
+    return null;
+  }
+
+  const existing = input.existing.find((edge) => edge.targetSlotId === targetSlotId);
+  return {
+    id: existing?.id ?? `e-${sourceFieldId}-${targetSlotId}-${Date.now()}`,
+    sourceFieldId,
+    targetSlotId,
+    ...(existing?.transformIds ? { transformIds: existing.transformIds } : {}),
+    ...(existing?.transformOptionSteps
+      ? { transformOptionSteps: existing.transformOptionSteps }
+      : {}),
+    ...(existing?.itemSourcePath ? { itemSourcePath: existing.itemSourcePath } : {}),
+    ...(existing?.itemEdges ? { itemEdges: existing.itemEdges } : {}),
+  };
+}