@auto-engineer/narrative 0.13.3 → 0.15.0

package/package.json

@@ -23,31 +23,24 @@
     "typescript": "^5.9.2",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.3",
-    "@auto-engineer/file-store": "0.13.3",
-    "@auto-engineer/id": "0.13.3",
-    "@auto-engineer/message-bus": "0.13.3"
+    "@auto-engineer/file-store": "0.15.0",
+    "@auto-engineer/message-bus": "0.15.0",
+    "@auto-engineer/id": "0.15.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "@typescript-eslint/eslint-plugin": "^7.18.0",
-    "eslint-plugin-sort-keys-fix": "^1.1.2",
     "fake-indexeddb": "^6.0.0",
-    "tsx": "^4.20.3",
-    "@auto-engineer/cli": "0.13.3"
+    "tsx": "^4.20.3"
   },
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.13.3",
+  "version": "0.15.0",
   "scripts": {
     "build": "tsx scripts/build.ts",
     "test": "vitest run --reporter=dot",
-    "lint": "eslint '{src,scripts}/**/*.ts' --max-warnings 0 --config ./eslint.config.ts",
     "type-check": "tsc --noEmit",
-    "format": "prettier --write \"**/*.{js,ts,json,md,yml,yaml}\" --ignore-path ../../.prettierignore --log-level warn",
     "convert-narrative": "tsx scripts/convert-narrative.ts",
-    "lint:fix": "eslint '{src,scripts}/**/*.ts' --fix --config ./eslint.config.ts",
-    "format:fix": "prettier --write \"**/*.{js,ts,json,md,yml,yaml}\" --ignore-path ../../.prettierignore --log-level warn",
     "link:dev": "pnpm build && pnpm link --global",
     "unlink:dev": "pnpm unlink --global"
   }

package/scripts/convert-flow-exec.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { getNarratives } from '../src';
+import path from 'node:path';
 import { NodeFileStore } from '@auto-engineer/file-store/node';
-import path from 'path';
+import { getNarratives } from '../src';
 
 const main = async () => {
   try {

package/scripts/convert-flow-helper.ts

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
-import { spawn } from 'child_process';
-import { resolve, dirname } from 'path';
-import { writeFileSync, unlinkSync } from 'fs';
-import { join } from 'path';
+import { spawn } from 'node:child_process';
+import { unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 
 const main = async () => {
   const flowPath = process.argv[2];

package/scripts/convert-flow.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { resolve, dirname, relative, join } from 'path';
-import { existsSync, writeFileSync, statSync } from 'fs';
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
+import { spawn } from 'node:child_process';
+import { existsSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const runInContext = (flowPath: string, projectRoot: string): Promise<string> => {
   return new Promise((resolve, reject) => {

package/scripts/print-schema.ts

@@ -1,13 +1,13 @@
+import { zodToJsonSchema } from 'zod-to-json-schema';
 import {
   CommandSliceSchema,
-  NarrativeSchema,
   IntegrationSchema,
   MessageSchema,
+  NarrativeSchema,
   QuerySliceSchema,
   ReactSliceSchema,
 } from '../src';
 
-import { zodToJsonSchema } from 'zod-to-json-schema';
 const schemas = Object.fromEntries(
   Object.entries({
     narrative: NarrativeSchema,

package/src/commands/export-schema-helper.ts

@@ -1,6 +1,6 @@
+import { type IExtendedFileStore, NodeFileStore } from '@auto-engineer/file-store/node';
 import createDebug from 'debug';
 import { getFs } from './filestore.node';
-import { IExtendedFileStore, NodeFileStore } from '@auto-engineer/file-store/node';
 
 const debug = createDebug('auto:narrative:export-schema-helper');
 if ('color' in debug && typeof debug === 'object') {
@@ -25,7 +25,7 @@ const main = async () => {
     );
     debug('Importing getNarratives from: %s', projectNarrativePath);
 
-    const { pathToFileURL } = await import('url');
+    const { pathToFileURL } = await import('node:url');
     const narrativeModule = (await import(pathToFileURL(projectNarrativePath).href)) as {
       getNarratives: typeof import('../getNarratives').getNarratives;
     };
@@ -51,18 +51,16 @@ const main = async () => {
     await fs.writeText(outPath, json);
     debug('Schema written to: %s', outPath);
 
-    // Output success as JSON for parent process
-    console.log(
-      JSON.stringify({
-        success: true,
-        outputPath: outPath,
-      }),
-    );
+    const resultPath = fs.join(contextDir, '.export-result.json');
+    await fs.writeText(resultPath, JSON.stringify({ success: true, outputPath: outPath }));
   } catch (error) {
     debug('Error occurred: %o', error);
-
-    // Output error as JSON for parent process
-    console.log(
+    const getFileStore = getFs as () => Promise<IExtendedFileStore>;
+    const fss: IExtendedFileStore = await getFileStore();
+    const resultPath = fss.join(process.argv[2] || process.cwd(), '.context', '.export-result.json');
+    await fss.ensureDir(fss.dirname(resultPath));
+    await fss.writeText(
+      resultPath,
       JSON.stringify({
         success: false,
         error: error instanceof Error ? error.message : 'Unknown error occurred',

package/src/commands/export-schema.ts

@@ -1,4 +1,4 @@
-import { type Command, type Event, defineCommandHandler } from '@auto-engineer/message-bus';
+import { type Command, defineCommandHandler, type Event } from '@auto-engineer/message-bus';
 import createDebug from 'debug';
 
 const debug = createDebug('auto:narrative:export-schema');
@@ -33,14 +33,18 @@ export type ExportSchemaEvents = SchemaExportedEvent | SchemaExportFailedEvent;
 
 export const commandHandler = defineCommandHandler({
   name: 'ExportSchema',
+  displayName: 'Export Schema',
   alias: 'export:schema',
   description: 'Export flow schemas to context directory',
   category: 'export',
   icon: 'download',
-  events: ['SchemaExported', 'SchemaExportFailed'],
+  events: [
+    { name: 'SchemaExported', displayName: 'Schema Exported' },
+    { name: 'SchemaExportFailed', displayName: 'Schema Export Failed' },
+  ],
   fields: {
     directory: {
-      description: 'Context directory path',
+      description: 'Context directory path (defaults to current working directory)',
       required: true,
     },
   },
@@ -60,7 +64,7 @@ export const commandHandler = defineCommandHandler({
 export async function handleExportSchemaCommand(
   command: ExportSchemaCommand,
 ): Promise<SchemaExportedEvent | SchemaExportFailedEvent> {
-  const { directory } = command.data;
+  const directory = command.data.directory ?? process.cwd();
 
   try {
     // Run the helper script with tsx
@@ -68,76 +72,52 @@ export async function handleExportSchemaCommand(
     const fs = await getFs();
     const __dirname = fs.dirname(new URL(import.meta.url).href);
     const helperScript = fs.join(__dirname, 'export-schema-helper.js');
-    const { spawn } = await import('child_process');
 
-    return new Promise((resolve) => {
-      const child = spawn('npx', ['tsx', helperScript, directory], {
-        cwd: directory,
-        stdio: ['inherit', 'pipe', 'inherit'], // Let stderr go directly to parent process
-        env: {
-          ...process.env,
-          NODE_ENV: process.env.NODE_ENV ?? 'development',
-          DEBUG: process.env.DEBUG, // Explicitly pass DEBUG env var
-          DEBUG_COLORS: process.env.DEBUG_COLORS, // Pass color settings
-          DEBUG_HIDE_DATE: 'true', // Always hide timestamps in child process to match parent
-        },
-        shell: true,
-      });
+    const resultPath = fs.join(directory, '.context', '.export-result.json');
 
-      let stdout = '';
-
-      child.stdout.on('data', (data: Buffer) => {
-        stdout += data.toString();
-      });
-
-      child.on('close', (code) => {
-        try {
-          // Extract JSON from stdout - look for the last line that starts with '{'
-          const lines = stdout.trim().split('\n');
-          const jsonLine = lines.reverse().find((line) => line.trim().startsWith('{'));
+    const { spawnSync } = await import('node:child_process');
+    spawnSync('node', [helperScript, directory], {
+      cwd: directory,
+      encoding: 'utf-8',
+      stdio: 'ignore',
+      env: {
+        ...process.env,
+        NODE_ENV: process.env.NODE_ENV ?? 'development',
+        DEBUG: process.env.DEBUG,
+        DEBUG_COLORS: process.env.DEBUG_COLORS,
+        DEBUG_HIDE_DATE: 'true',
+      },
+    });
 
-          if (jsonLine == null) {
-            throw new Error('No JSON output found');
-          }
+    const resultJson = await fs.readText(resultPath);
+    if (resultJson == null) {
+      return {
+        type: 'SchemaExportFailed',
+        data: { directory, error: 'No result file found' },
+        timestamp: new Date(),
+        requestId: command.requestId,
+        correlationId: command.correlationId,
+      };
+    }
 
-          const result = JSON.parse(jsonLine) as { success?: boolean; outputPath?: string; error?: string };
-          if (result.success === true) {
-            resolve({
-              type: 'SchemaExported',
-              data: {
-                directory,
-                outputPath: result.outputPath ?? '',
-              },
-              timestamp: new Date(),
-              requestId: command.requestId,
-              correlationId: command.correlationId,
-            });
-          } else {
-            resolve({
-              type: 'SchemaExportFailed',
-              data: {
-                directory,
-                error: result.error ?? 'Unknown error',
-              },
-              timestamp: new Date(),
-              requestId: command.requestId,
-              correlationId: command.correlationId,
-            });
-          }
-        } catch {
-          resolve({
-            type: 'SchemaExportFailed',
-            data: {
-              directory,
-              error: code === 0 ? 'Failed to parse result' : `Process failed with code ${code}`,
-            },
-            timestamp: new Date(),
-            requestId: command.requestId,
-            correlationId: command.correlationId,
-          });
-        }
-      });
-    });
+    const parsed = JSON.parse(resultJson) as { success?: boolean; outputPath?: string; error?: string };
+    if (parsed.success === true) {
+      return {
+        type: 'SchemaExported',
+        data: { directory, outputPath: parsed.outputPath ?? '' },
+        timestamp: new Date(),
+        requestId: command.requestId,
+        correlationId: command.correlationId,
+      };
+    } else {
+      return {
+        type: 'SchemaExportFailed',
+        data: { directory, error: parsed.error ?? 'Unknown error' },
+        timestamp: new Date(),
+        requestId: command.requestId,
+        correlationId: command.correlationId,
+      };
+    }
   } catch (error: unknown) {
     const message = error instanceof Error ? error.message : String(error);
     return {

package/src/data-narrative-builders.ts

@@ -1,6 +1,6 @@
-import type { DataSinkItem, DataSourceItem, MessageTarget, Integration, DefaultRecord } from './types';
-import { createIntegrationOrigin } from './types';
 import { integrationExportRegistry } from './integration-export-registry';
+import type { DataSinkItem, DataSourceItem, DefaultRecord, Integration, MessageTarget } from './types';
+import { createIntegrationOrigin } from './types';
 
 // Extended interfaces that add chainable methods
 export interface ChainableSinkMethods {
@@ -19,19 +19,17 @@ export type ChainableSource = DataSourceItem & ChainableSourceMethods;
 function createChainableSink(sinkItem: DataSinkItem): ChainableSink {
   const chainable = sinkItem as ChainableSink;
 
-  (chainable as ChainableSinkMethods).additionalInstructions = function (instructions: string): ChainableSink {
-    return createChainableSink({
+  (chainable as ChainableSinkMethods).additionalInstructions = (instructions: string): ChainableSink =>
+    createChainableSink({
       ...sinkItem,
       _additionalInstructions: instructions,
     });
-  };
 
-  (chainable as ChainableSinkMethods).withState = function (source: DataSourceItem | ChainableSource): ChainableSink {
-    return createChainableSink({
+  (chainable as ChainableSinkMethods).withState = (source: DataSourceItem | ChainableSource): ChainableSink =>
+    createChainableSink({
       ...sinkItem,
       _withState: source,
     });
-  };
 
   return chainable;
 }
@@ -39,12 +37,11 @@ function createChainableSink(sinkItem: DataSinkItem): ChainableSink {
 function createChainableSource(sourceItem: DataSourceItem): ChainableSource {
   const chainable = sourceItem as ChainableSource;
 
-  (chainable as ChainableSourceMethods).additionalInstructions = function (instructions: string): ChainableSource {
-    return createChainableSource({
+  (chainable as ChainableSourceMethods).additionalInstructions = (instructions: string): ChainableSource =>
+    createChainableSource({
       ...sourceItem,
       _additionalInstructions: instructions,
     });
-  };
 
   return chainable;
 }

package/src/fluent-builder.specs.ts

@@ -1,7 +1,7 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { command, react } from './fluent-builder';
+import { clearCurrentNarrative, startNarrative } from './narrative-context';
 import { createIntegration } from './types';
-import { startNarrative, clearCurrentNarrative } from './narrative-context';
 
 // Test integrations
 const MailChimp = createIntegration('mailchimp', 'MailChimp');

package/src/fluent-builder.ts

@@ -1,15 +1,15 @@
-import type { Integration } from './types';
+import createDebug from 'debug';
+import { type ASTNode, print } from 'graphql';
+import type { CommandSlice, ExperienceSlice, QuerySlice, ReactSlice } from './index';
 import {
   addSlice,
-  startClientBlock,
   endClientBlock,
-  startServerBlock,
   endServerBlock,
   getCurrentSlice,
+  startClientBlock,
+  startServerBlock,
 } from './narrative-context';
-import { CommandSlice, QuerySlice, ReactSlice, ExperienceSlice } from './index';
-import { print, ASTNode } from 'graphql';
-import createDebug from 'debug';
+import type { Integration } from './types';
 
 const debug = createDebug('auto:narrative:fluent-builder');
 if ('color' in debug && typeof debug === 'object') {

package/src/getNarratives.cache.specs.ts

@@ -1,11 +1,11 @@
-import { describe, expect, it, beforeEach } from 'vitest';
-import { getNarratives, clearGetNarrativesCache } from './getNarratives';
-import { InMemoryFileStore, type IFileStore } from '@auto-engineer/file-store';
-import * as flowApi from './narrative';
-import * as fluent from './fluent-builder';
+import { type IFileStore, InMemoryFileStore } from '@auto-engineer/file-store';
+import gql from 'graphql-tag';
+import { beforeEach, describe, expect, it } from 'vitest';
 import * as dataBuilders from './data-narrative-builders';
+import * as fluent from './fluent-builder';
+import { clearGetNarrativesCache, getNarratives } from './getNarratives';
+import * as flowApi from './narrative';
 import * as typesApi from './types';
-import gql from 'graphql-tag';
 
 const importMap = {
   '../flow': flowApi,

package/src/getNarratives.specs.ts

@@ -1,11 +1,11 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import { modelSchema } from './schema';
-import { DataSource, Example, Narrative, Model, modelToNarrative, QuerySlice } from './index';
-import { fileURLToPath } from 'url';
-import path from 'path';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { InMemoryFileStore } from '@auto-engineer/file-store';
 import { NodeFileStore } from '@auto-engineer/file-store/node';
+import { beforeEach, describe, expect, it } from 'vitest';
 import { getNarratives } from './getNarratives';
+import { type DataSource, type Example, type Model, modelToNarrative, type Narrative, type QuerySlice } from './index';
+import { modelSchema } from './schema';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -688,7 +688,7 @@ flow('questionnaires-test', () => {
     validateQuestionnaireBugFix(model);
   });
 
-  it('should convert all given events to eventRef', async function (): Promise<void> {
+  it('should convert all given events to eventRef', async (): Promise<void> => {
     const memoryVfs = new InMemoryFileStore();
     const todoSummaryFlowContent = `
 import { flow, query, specs, rule, example, type Event, type State } from '@auto-engineer/narrative';

package/src/getNarratives.ts

@@ -1,10 +1,10 @@
+import type { IFileStore } from '@auto-engineer/file-store';
 import createDebug from 'debug';
+import { sha256 } from 'js-sha256';
+import type { Model, Narrative } from './index';
+import { executeAST } from './loader';
 import { registry } from './narrative-registry';
-import type { Narrative, Model } from './index';
 import { narrativesToModel } from './transformers/narrative-to-model';
-import type { IFileStore } from '@auto-engineer/file-store';
-import { executeAST } from './loader';
-import { sha256 } from 'js-sha256';
 
 const dirnamePosix = (p: string) => {
   const s = p.replace(/\/+$/, '');
@@ -22,7 +22,15 @@ const CACHE_VERSION = 'v1';
 
 function stableStringify(obj: Record<string, unknown>) {
   const keys = Object.keys(obj).sort();
-  return JSON.stringify(keys.reduce((a, k) => ((a[k] = obj[k]), a), {} as Record<string, unknown>));
+  return JSON.stringify(
+    keys.reduce(
+      (acc, key) => {
+        acc[key] = obj[key];
+        return acc;
+      },
+      {} as Record<string, unknown>,
+    ),
+  );
 }
 
 function toUint8(view: ArrayBuffer | Uint8Array): Uint8Array {

package/src/id/addAutoIds.specs.ts

@@ -1,6 +1,6 @@
-import { describe, it, expect } from 'vitest';
+import { describe, expect, it } from 'vitest';
+import type { Model } from '../index';
 import { addAutoIds } from './';
-import { Model } from '../index';
 
 describe('addAutoIds', () => {
   const flows: Model = {

package/src/id/addAutoIds.ts

@@ -1,5 +1,5 @@
+import type { ClientSpecNode, Example, Model, Rule, Slice, Spec, Step } from '../index';
 import { generateAutoId } from './generators';
-import { Model, Slice, Spec, Rule, Example, Step, ClientSpecNode } from '../index';
 
 function ensureId(item: { id?: string }): void {
   if (item.id === undefined || item.id === '') {

package/src/id/hasAllIds.specs.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
-import { hasAllIds, addAutoIds } from './index';
 import type { Model } from '../index';
+import { addAutoIds, hasAllIds } from './index';
 
 describe('hasAllIds', () => {
   const createModelWithoutIds = (): Model => ({

package/src/id/hasAllIds.ts

@@ -1,4 +1,4 @@
-import { Model, Slice, Spec, Rule, Example, Step, ClientSpecNode } from '../index';
+import type { ClientSpecNode, Example, Model, Rule, Slice, Spec, Step } from '../index';
 
 function hasValidId(item: { id?: string }): boolean {
   return item.id !== undefined && item.id !== '';

package/src/id/index.ts

@@ -1,2 +1,2 @@
-export { hasAllIds } from './hasAllIds';
 export { addAutoIds } from './addAutoIds';
+export { hasAllIds } from './hasAllIds';

package/src/index.ts

@@ -1,26 +1,25 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 
+// Apollo GraphQL
+export { gql } from 'graphql-tag';
+export { DataSinkSchema, DataSourceSchema, MessageTargetSchema } from './schema';
 // Core types and utilities
 export type {
-  Integration,
+  Command,
+  DataItem,
   DataSink,
-  DataSource,
   DataSinkItem,
+  DataSource,
   DataSourceItem,
-  DataItem,
-  MessageTarget,
   Destination,
+  Event,
+  Integration,
+  MessageTarget,
   Origin,
   State,
-  Command,
-  Event,
 } from './types';
-export { MessageTargetSchema, DataSinkSchema, DataSourceSchema } from './schema';
 export { createIntegration } from './types';
 
-// Apollo GraphQL
-export { gql } from 'graphql-tag';
-
 // HTTP GET template literal function
 export const get = (strings: TemplateStringsArray, ...values: unknown[]) => {
   return strings.reduce((result, str, i) => {
@@ -29,75 +28,83 @@ export const get = (strings: TemplateStringsArray, ...values: unknown[]) => {
   }, '');
 };
 
+export type { ExportSchemaEvents } from './commands/export-schema';
+export type { FieldSelector } from './data-narrative-builders';
+
+// Data narrative builders
+export { sink, source } from './data-narrative-builders';
 // Fluent API
 export type {
   FluentCommandSliceBuilder,
+  FluentExperienceSliceBuilder,
   FluentQuerySliceBuilder,
   FluentReactionSliceBuilder,
-  FluentExperienceSliceBuilder,
 } from './fluent-builder';
-export { command, query, react, experience, decide, evolve } from './fluent-builder';
-
-// Data narrative builders
-export { sink, source } from './data-narrative-builders';
-export type { FieldSelector } from './data-narrative-builders';
-
-// Narrative language functions
-export { narrative, narrative as flow } from './narrative';
-export { client, server, specs, describe, it, should, request, data, rule, example, thenError } from './narrative';
-export type { ExampleBuilder, GivenBuilder, WhenBuilder, ThenBuilder } from './narrative';
-export type { SliceTypeValueInterface } from './narrative';
-export { SliceType } from './narrative';
-
+export { command, decide, evolve, experience, query, react } from './fluent-builder';
 // Narrative conversion utilities
 export { getNarratives } from './getNarratives';
-export { modelToNarrative } from './transformers/model-to-narrative';
-
-export type { ExportSchemaEvents } from './commands/export-schema';
-
-// Testing helpers
-export { createNarrativeSpec, given as testGiven, when as testWhen } from './testing';
-
+export type { ExampleBuilder, GivenBuilder, SliceTypeValueInterface, ThenBuilder, WhenBuilder } from './narrative';
+// Narrative language functions
+export {
+  client,
+  data,
+  describe,
+  example,
+  it,
+  narrative,
+  narrative as flow,
+  request,
+  rule,
+  SliceType,
+  server,
+  should,
+  specs,
+  thenError,
+} from './narrative';
 // Schema definitions for progressive narrative creation
 export {
-  NarrativeNamesSchema as NarrativeNamesSystemSchema,
-  SliceNamesSchema as SliceNamesSystemSchema,
   ClientServerNamesSchema as ClientServerNamesSystemSchema,
-  modelSchema as SpecsSystemSchema,
-  MessageFieldSchema,
-  MessageSchema,
   CommandSchema,
+  CommandSliceSchema,
   EventSchema,
-  StateSchema,
+  ExampleSchema,
+  ExperienceSliceSchema,
   IntegrationSchema,
-  CommandSliceSchema,
+  MessageFieldSchema,
+  MessageSchema,
+  modelSchema as SpecsSystemSchema,
+  modelSchema,
+  NarrativeNamesSchema as NarrativeNamesSystemSchema,
+  NarrativeSchema,
   QuerySliceSchema,
   ReactSliceSchema,
-  ExperienceSliceSchema,
-  SliceSchema,
-  NarrativeSchema,
-  modelSchema,
-  ExampleSchema,
   RuleSchema,
+  SliceNamesSchema as SliceNamesSystemSchema,
+  SliceSchema,
   SpecSchema,
-  StepSchema,
+  StateSchema,
   StepErrorSchema,
+  StepSchema,
   StepWithDocStringSchema,
   StepWithErrorSchema,
 } from './schema';
 
-import {
-  NarrativeSchema,
-  SliceSchema,
+// Testing helpers
+export { createNarrativeSpec, given as testGiven, when as testWhen } from './testing';
+export { modelToNarrative } from './transformers/model-to-narrative';
+
+import type {
+  CommandSliceSchema,
+  ExampleSchema,
+  ExperienceSliceSchema,
+  MessageFieldSchema,
+  MessageSchema,
   modelSchema,
+  NarrativeSchema,
   QuerySliceSchema,
   ReactSliceSchema,
-  ExperienceSliceSchema,
-  MessageSchema,
-  MessageFieldSchema,
-  CommandSliceSchema,
-  ExampleSchema,
   RuleSchema,
+  SliceSchema,
   SpecSchema,
   StepSchema,
 } from './schema';
@@ -114,7 +121,7 @@ export type MessageField = z.infer<typeof MessageFieldSchema>;
 export type Rule = z.infer<typeof RuleSchema>;
 export type Spec = z.infer<typeof SpecSchema>;
 export type Step = z.infer<typeof StepSchema>;
-export type { ClientSpecNode } from './schema';
 
 // ID assignment utilities
 export { addAutoIds, hasAllIds } from './id';
+export type { ClientSpecNode } from './schema';