@izara_project/izara-core-generate-service-code 1.0.96 → 1.0.98

package/src/plan/domainRegistry.js

@@ -0,0 +1,307 @@
+import {
+  crudApplicationManagedPaths,
+  emitCrudApplicationArtifacts
+} from '../emit/application/crud/emitCrudApplicationArtifacts.js';
+import {
+  dynamicCrudFlowSchemaPaths,
+  emitDynamicCrudFlowSchemas
+} from '../emit/application/crud/emitDynamicCrudFlowSchemas.js';
+import {
+  customFlowApplicationManagedPaths,
+  emitCustomFlowApplicationArtifacts
+} from '../emit/application/custom/emitCustomFlowApplicationArtifacts.js';
+import {
+  emitDynamicRbacFlowSchemas,
+  rbacFlowSchemaManagedPaths
+} from '../emit/application/rbac/emitDynamicRbacFlowSchemas.js';
+import {
+  emitRbacApplicationArtifacts,
+  rbacApplicationManagedPaths
+} from '../emit/application/rbac/emitRbacApplicationArtifacts.js';
+import {
+  dynamicRelationshipFlowSchemaManagedPaths,
+  emitDynamicRelationshipFlowSchemas
+} from '../emit/application/relationship/emitDynamicRelationshipFlowSchemas.js';
+import {
+  emitRelationshipApplicationArtifacts,
+  relationshipApplicationManagedPaths
+} from '../emit/application/relationship/emitRelationshipApplicationArtifacts.js';
+import {
+  emitSystemWebSocketArtifacts,
+  systemWebSocketManagedPaths
+} from '../emit/application/system/emitSystemWebSocketArtifacts.js';
+import {
+  emitSystemFindDataArtifacts,
+  findDataManagedPaths
+} from '../emit/application/system/emitSystemFindDataArtifacts.js';
+import {
+  emitCoreFunctionArtifacts,
+  coreFunctionManagedPaths
+} from '../emit/application/coreFunction/emitCoreFunctionArtifacts.js';
+import {
+  emitResourceArtifacts,
+  resourceArtifactPaths
+} from '../emit/infrastructure/resources/emitResourceArtifacts.js';
+import {
+  emitSystemTextSchemas,
+  systemTextSchemaManagedPaths
+} from '../emit/schemas/systemText/emitSystemTextSchemas.js';
+import {
+  emitAttributeTreeObjectSchemas,
+  emitAttributeTreeRelationshipSchemas,
+  attributeTreeObjectSchemaManagedPaths,
+  attributeTreeRelationshipSchemaManagedPaths
+} from '../emit/schemas/attributeTree/emitAttributeTreeSchemas.js';
+import {
+  emitAttributeTreeTargetValueStandard,
+  attributeTreeTargetValueStandardManagedPaths
+} from '../emit/schemas/attributeTree/emitAttributeTreeTargetValueStandard.js';
+import {
+  emitLedgerObjectSchemas,
+  emitLedgerRelationshipSchemas,
+  ledgerObjectSchemaManagedPaths,
+  ledgerRelationshipSchemaManagedPaths
+} from '../emit/schemas/ledger/emitLedgerSchemas.js';
+import {
+  emitPropertyValueObjectSchemas,
+  emitPropertyValueRelationshipSchemas,
+  propertyValueObjectSchemaManagedPaths,
+  propertyValueRelationshipSchemaManagedPaths
+} from '../emit/schemas/propertyValue/emitPropertyValueSchemas.js';
+import {
+  emitErrorSchemas,
+  errorSchemaManagedPaths
+} from '../emit/schemas/error/emitErrorSchemas.js';
+
+export async function resolveEmissionGroups(context) {
+  const {
+    project,
+    objects,
+    relationships,
+    flows,
+    notifications,
+    errors,
+    directives = [],
+    objectGraphServiceTags,
+    relationshipGraphServiceTags,
+    logger
+  } = context;
+
+  const [
+    crud,
+    relationship,
+    rbac,
+    system,
+    findData,
+    resource,
+    coreFunction,
+    systemText,
+    errorSchemas,
+    ledgerObjectArtifacts,
+    ledgerRelationshipArtifacts
+  ] = await Promise.all([
+    emitCrudApplicationArtifacts({
+      objects,
+      flows,
+      serviceTag: project.serviceTag,
+      logger
+    }),
+    emitRelationshipApplicationArtifacts({
+      relationships,
+      flows,
+      serviceTag: project.serviceTag
+    }),
+    emitRbacApplicationArtifacts(objects),
+    emitSystemWebSocketArtifacts(flows, {
+      includeRelationshipOwnTopic: true,
+      objects,
+      relationships
+    }),
+    emitSystemFindDataArtifacts(objects),
+    emitResourceArtifacts({ objects, relationships, flows }),
+    emitCoreFunctionArtifacts({
+      project,
+      objects,
+      relationships,
+      flows,
+      objectGraphServiceTags,
+      relationshipGraphServiceTags
+    }),
+    emitSystemTextSchemas({
+      project,
+      objects,
+      relationships,
+      flows,
+      notifications
+    }),
+    emitErrorSchemas({
+      project,
+      errors,
+      objectGraphServiceTags
+    }),
+    emitLedgerObjectSchemas({
+      objects,
+      serviceTag: project.serviceTag
+    }),
+    emitLedgerRelationshipSchemas({
+      objects,
+      serviceTag: project.serviceTag
+    })
+  ]);
+
+  const custom = await emitCustomFlowApplicationArtifacts(flows, {
+    objects
+  });
+
+  let systemFunctions = [];
+  if (system.functions) {
+    systemFunctions = systemFunctions.concat(system.functions);
+  }
+  if (findData.functions) {
+    systemFunctions = systemFunctions.concat(findData.functions);
+  }
+
+  let findDataArtifacts = [];
+  if (findData.artifacts) {
+    findDataArtifacts = [...findData.artifacts];
+  }
+
+  if (systemFunctions.length > 0) {
+    findDataArtifacts.push({
+      path: 'app/sls_yaml/generatedCode/source/flow-system.yml',
+      content: systemFunctions.join('\n\n')
+    });
+  }
+
+  let resolvedCoreFunctionManagedPaths = coreFunctionManagedPaths;
+  if (typeof coreFunctionManagedPaths === 'function') {
+    resolvedCoreFunctionManagedPaths = coreFunctionManagedPaths({
+      project,
+      objects,
+      relationships,
+      flows,
+      objectGraphServiceTags,
+      relationshipGraphServiceTags
+    });
+  }
+
+  const rbacFlowArtifacts = await emitDynamicRbacFlowSchemas({
+    objects,
+    serviceTag: project.serviceTag
+  });
+
+  return [
+    {
+      scope: 'crud-flow-schemas',
+      managedPaths: dynamicCrudFlowSchemaPaths,
+      artifacts: emitDynamicCrudFlowSchemas({ objects, flows, logger })
+    },
+    {
+      scope: 'relationship-flow-schemas',
+      managedPaths: dynamicRelationshipFlowSchemaManagedPaths(relationships),
+      artifacts: emitDynamicRelationshipFlowSchemas({ relationships })
+    },
+    {
+      scope: 'rbac-flow-schemas',
+      managedPaths: rbacFlowSchemaManagedPaths(objects),
+      artifacts: rbacFlowArtifacts
+    },
+    {
+      scope: 'attribute-tree-target-value-standard',
+      managedPaths: attributeTreeTargetValueStandardManagedPaths(directives),
+      artifacts: emitAttributeTreeTargetValueStandard({ directives })
+    },
+    {
+      scope: 'attribute-tree-object-schemas',
+      managedPaths: attributeTreeObjectSchemaManagedPaths(objects),
+      artifacts: emitAttributeTreeObjectSchemas({
+        objects,
+        serviceTag: project.serviceTag
+      })
+    },
+    {
+      scope: 'attribute-tree-relationship-schemas',
+      managedPaths: attributeTreeRelationshipSchemaManagedPaths(objects),
+      artifacts: emitAttributeTreeRelationshipSchemas({
+        objects,
+        serviceTag: project.serviceTag
+      })
+    },
+    {
+      scope: 'ledger-object-schemas',
+      managedPaths: ledgerObjectSchemaManagedPaths(objects),
+      artifacts: ledgerObjectArtifacts
+    },
+    {
+      scope: 'ledger-relationship-schemas',
+      managedPaths: ledgerRelationshipSchemaManagedPaths(objects),
+      artifacts: ledgerRelationshipArtifacts
+    },
+    {
+      scope: 'property-value-object-schemas',
+      managedPaths: propertyValueObjectSchemaManagedPaths(objects),
+      artifacts: emitPropertyValueObjectSchemas({
+        objects,
+        serviceTag: project.serviceTag
+      })
+    },
+    {
+      scope: 'property-value-relationship-schemas',
+      managedPaths: propertyValueRelationshipSchemaManagedPaths(objects),
+      artifacts: emitPropertyValueRelationshipSchemas({
+        objects,
+        serviceTag: project.serviceTag
+      })
+    },
+    {
+      scope: 'crud-application',
+      managedPaths: crudApplicationManagedPaths(),
+      artifacts: crud
+    },
+    {
+      scope: 'relationship-application',
+      managedPaths: relationshipApplicationManagedPaths(),
+      artifacts: relationship
+    },
+    {
+      scope: 'rbac-application',
+      managedPaths: rbacApplicationManagedPaths(objects),
+      artifacts: rbac
+    },
+    {
+      scope: 'system-websocket',
+      managedPaths: systemWebSocketManagedPaths(),
+      artifacts: system.artifacts
+    },
+    {
+      scope: 'system-find-data',
+      managedPaths: findDataManagedPaths(),
+      artifacts: findDataArtifacts
+    },
+    {
+      scope: 'custom-flow-application',
+      managedPaths: customFlowApplicationManagedPaths(flows, { objects }),
+      artifacts: custom
+    },
+    {
+      scope: 'shared-resources',
+      managedPaths: resourceArtifactPaths,
+      artifacts: resource
+    },
+    {
+      scope: 'core-function',
+      managedPaths: resolvedCoreFunctionManagedPaths,
+      artifacts: coreFunction
+    },
+    {
+      scope: 'system-text-schemas',
+      managedPaths: systemTextSchemaManagedPaths(),
+      artifacts: systemText
+    },
+    {
+      scope: 'error-schemas',
+      managedPaths: errorSchemaManagedPaths(errors),
+      artifacts: errorSchemas
+    }
+  ];
+}

package/task.md

@@ -0,0 +1,132 @@
+# Task Checklist: Attribute Tree Per-Repo Code Generation Refactoring
+
+> **Canonical Architecture Plan**: [[10.Systems/GenerateServiceCode/30-Generation/Task Roadmap - Attribute Tree Per-Repo Generation Refactoring|Task Roadmap in Obsidian]]  
+> **Selected Design**: **Option C (`GenerateDirectives/`)** + **Style 1 (`generatedCode/<domain>/`)**  
+> **Repository**: `IzaraCore-SupportServices-GenerateServiceCode-Seagame`
+
+---
+
+## 🎯 Target Architecture: Style 1 (`generatedCode/<domain>/`)
+
+### Target Service (e.g. `SellOfferTermValueStandard`)
+```text
+app/src/schemas/
+├── GenerateDirectives/
+│   └── sellOfferTermValueStandard.js                       <-- [Directive] Developer creates this
+│
+├── ObjectSchemas/
+│   └── generatedCode/
+│       ├── attributeTree/
+│       │   └── sellOfferTermValueStandard.js               <-- [Emitted by TASK-02]
+│       └── propertyValue/
+│           ├── sellOfferTermValueStandardPropertyLabel.js   <-- [Emitted by PropertyValue addOn]
+│           └── sellOfferTermValueStandardPropertyValue.js   <-- [Emitted by PropertyValue addOn]
+│
+└── RelationshipSchemas/
+    └── generatedCode/
+        └── propertyValue/
+            ├── hasSellOfferTermValueStandardPropertyValue.js
+            ├── disabledSellOfferTermValueStandardPropertyValue.js
+            └── isSellOfferTermValueStandardPropertyLabel.js
+```
+
+### Source Service (Self-Repo)
+```text
+app/src/schemas/
+├── ObjectSchemas/
+│   ├── sellOffer.js                                        <-- Source ObjectSchema
+│   └── generatedCode/
+│       └── attributeTree/
+│           ├── sellOfferTermLink.js
+│           ├── sellOfferTermValue.js
+│           └── sellOfferTermLabel.js
+│
+└── RelationshipSchemas/
+    └── generatedCode/
+        └── attributeTree/
+            ├── hasSellOfferTermLink.js
+            ├── disabledSellOfferTermLink.js
+            ├── isSellOfferTerm.js
+            └── isSellOfferTermLabel.js
+```
+
+---
+
+## 📋 Implementation Checklist
+
+- [x] **TASK-01: Recursive Schema Loading & Directives Loader**
+  - **File**: `src/compile/loadSchemas.js`
+  - **Action**:
+    1. Update `loadLocalSchemaDirectory(project, directoryName, options)` to recursively find all `.js` files within subdirectories (supporting `ObjectSchemas/generatedCode/**` and `RelationshipSchemas/generatedCode/**`).
+    2. Export `loadGenerateDirectives(project, options)` calling `loadLocalSchemaDirectory(project, 'GenerateDirectives', options)`.
+  - **Acceptance Criteria**: `loadLocalSchemaDirectory(project, 'ObjectSchemas')` discovers and validates schemas nested inside `generatedCode/attributeTree/` and `generatedCode/propertyValue/`. Returns `[]` when `GenerateDirectives` folder is missing.
+
+- [x] **TASK-02: Target ValueStandard Schema Emitter**
+  - **File**: `src/emit/schemas/attributeTree/emitAttributeTreeTargetValueStandard.js` (NEW)
+  - **Action**:
+    1. Filter `directives` for `directive.type === 'attributeTreeTarget'`.
+    2. Emit `{tag}ValueStandard.js` to `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/${tag}ValueStandard.js`.
+    3. Include preservation hook `//(<addOnDataStructure${tag}ValueStandard>)` with commented `propertyValue` addOn template.
+    4. Export `attributeTreeTargetValueStandardManagedPaths(directives)`.
+  - **Acceptance Criteria**: Emitted file adheres strictly to Izara backend syntax rules and matches Style 1 output path.
+
+- [x] **TASK-03: Align AttributeTree Self-Repo Emitter to Style 1**
+  - **File**: `src/emit/schemas/attributeTree/emitAttributeTreeSchemas.js`
+  - **Action**:
+    1. Update ObjectSchema emission paths from `generatedAttributeTree/` to `generatedCode/attributeTree/`.
+    2. Update RelationshipSchema emission paths from `generatedAttributeTree/` to `generatedCode/attributeTree/`.
+    3. Update `attributeTreeObjectSchemaManagedPaths` and `attributeTreeRelationshipSchemaManagedPaths`.
+  - **Acceptance Criteria**: Self-repo attributeTree schemas output cleanly into `generatedCode/attributeTree/`.
+
+- [x] **TASK-04: Align PropertyValue Emitter to Style 1**
+  - **File**: `src/emit/schemas/propertyValue/emitPropertyValueSchemas.js`
+  - **Action**:
+    1. Update ObjectSchema emission paths from `generatedPropertyValue/` to `generatedCode/propertyValue/`.
+    2. Update RelationshipSchema emission paths from `generatedPropertyValue/` to `generatedCode/propertyValue/`.
+    3. Update `propertyValueObjectSchemaManagedPaths` and `propertyValueRelationshipSchemaManagedPaths`.
+  - **Acceptance Criteria**: PropertyValue schemas output cleanly into `generatedCode/propertyValue/`.
+
+- [x] **TASK-05: Register Managed Scopes in Domain Registry**
+  - **File**: `src/plan/domainRegistry.js`
+  - **Action**:
+    1. Import `emitAttributeTreeTargetValueStandard` and `attributeTreeTargetValueStandardManagedPaths`.
+    2. Register new scope `attribute-tree-target-value-standard`.
+    3. Pass `directives` into `resolveEmissionGroups(context)`.
+  - **Acceptance Criteria**: All 5 dynamic schema scopes registered and tracked in `.generate-service-code-v2-managed.json`.
+
+- [x] **TASK-06: Decouple Generation Pipeline in `src/generate.js`**
+  - **File**: `src/generate.js`
+  - **Action**:
+    1. Load directives: `const directives = await loadGenerateDirectives(project, schemaLoadOptions);`.
+    2. Pass `directives` to `resolveEmissionGroups`.
+    3. Delete lines 104-111 (`targetFiles = await _emitTargetServiceAttributeTreeSchemas(...)`).
+    4. Delete lines 129-186 (`_emitTargetServiceAttributeTreeSchemas` function definition).
+  - **Acceptance Criteria**: Zero cross-repo filesystem writes. Generator operates strictly within `workspaceOutputRoot`.
+
+- [x] **TASK-07: Delete Legacy Cross-Repo Files**
+  - **Files to Delete**:
+    - `src/emit/schemas/attributeTree/resolveTargetServicePath.js`
+    - `src/emit/schemas/attributeTree/emitAttributeTreeTargetSchemas.js`
+  - **Action**: Remove dead files and any unused imports.
+  - **Acceptance Criteria**: `git status` shows clean file deletions.
+
+- [x] **TASK-08: Unit & Integration Test Verification**
+  - **Files**:
+    - `test/unit/schemas/attributeTreeDirectives.test.js` (NEW)
+    - `test/unit/schemas/attributeTreeSchemas.test.js` (Update paths)
+    - `test/unit/schemas/propertyValueSchemas.test.js` (Update paths)
+  - **Verification Command**: `npm test`
+  - **Acceptance Criteria**: All 198+ tests pass with zero regression.
+
+- [x] **TASK-09: End-to-End Cascading Verification**
+  - **Action**: Verify two-phase generation locally:
+    1. Target service with directive -> generates `sellOfferTermValueStandard.js`.
+    2. Target service uncomments `propertyValue` -> generates PropertyLabel, PropertyValue, and 3 Relationship schemas.
+  - **Acceptance Criteria**: Zero cross-repo dependency required.
+
+- [x] **TASK-10: Synchronize Vault & Taiga Documentation**
+  - **Vault Files**:
+    - `10.Systems/GenerateServiceCode/20-Schema/Dynamic Schema.md`
+    - `40.Vault/Operations/timeline-log.md`
+    - `40.Vault/Memory/active-context.md`
+  - **Taiga Wiki**: Update `generatecode` wiki page.

package/test/helpers/testProject.js

@@ -0,0 +1,127 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+const trackedRoots = new Set();
+
+/**
+ * Creates a temporary project directory with standard Izara service structure.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.rootPath] - Existing root path to re-use
+ * @param {string} [options.prefix] - Temp folder prefix (default: 'izara-test-')
+ * @param {string} [options.serviceName] - Service name in config
+ * @param {string} [options.serviceTag] - Custom serviceTag in config
+ * @param {string} [options.serverlessConfig] - Custom serverless.config.yml content
+ * @param {Object} [options.schemas] - Schemas map e.g. { ObjectSchemas: { 'Order.js': '...' } }
+ * @returns {Promise<string>} The project root path
+ */
+export async function createTestProject({
+  rootPath: existingRoot,
+  prefix = 'izara-test-',
+  serviceName = 'TestService',
+  serviceTag = 'TestService',
+  serverlessConfig,
+  schemas = {}
+} = {}) {
+  let rootPath = existingRoot;
+  if (!rootPath) {
+    rootPath = await mkdtemp(join(tmpdir(), prefix));
+  }
+  trackedRoots.add(rootPath);
+
+  const schemaRoot = join(rootPath, 'app/src/schemas');
+  await mkdir(join(schemaRoot, 'ObjectSchemas'), { recursive: true });
+  await mkdir(join(schemaRoot, 'RelationshipSchemas'), { recursive: true });
+  await mkdir(join(schemaRoot, 'FlowSchemas'), { recursive: true });
+  await mkdir(join(schemaRoot, 'ErrorSchemas'), { recursive: true });
+  await mkdir(join(rootPath, 'config'), { recursive: true });
+
+  let configContent = serverlessConfig;
+  if (!configContent) {
+    configContent =
+      `service: ${serviceName}\n` +
+      `custom:\n` +
+      `  serviceTag: ${serviceTag}\n`;
+  }
+  await writeFile(
+    join(rootPath, 'config/serverless.config.yml'),
+    configContent,
+    'utf8'
+  );
+
+  const schemaCategories = [
+    'ObjectSchemas',
+    'RelationshipSchemas',
+    'FlowSchemas',
+    'ErrorSchemas'
+  ];
+
+  for (const category of schemaCategories) {
+    const files = schemas[category];
+    if (files && typeof files === 'object') {
+      for (const [filename, content] of Object.entries(files)) {
+        await writeProjectFile(
+          rootPath,
+          join('app/src/schemas', category, filename),
+          content
+        );
+      }
+    }
+  }
+
+  for (const [key, content] of Object.entries(schemas)) {
+    if (!schemaCategories.includes(key) && typeof content === 'string') {
+      await writeProjectFile(
+        rootPath,
+        join('app/src/schemas', key),
+        content
+      );
+    }
+  }
+
+  return rootPath;
+}
+
+/**
+ * Tracks an external directory path for cleanupTestProjects.
+ *
+ * @param {string} rootPath - Directory path to track
+ * @returns {string} The tracked path
+ */
+export function trackTestProject(rootPath) {
+  trackedRoots.add(rootPath);
+  return rootPath;
+}
+
+/**
+ * Writes a file relative to the project root.
+ */
+export async function writeProjectFile(rootPath, relativePath, content) {
+  const targetPath = join(rootPath, relativePath);
+  await mkdir(dirname(targetPath), { recursive: true });
+  await writeFile(targetPath, content, 'utf8');
+  return targetPath;
+}
+
+/**
+ * Reads a file relative to the project root.
+ */
+export async function readProjectFile(rootPath, relativePath) {
+  return await readFile(join(rootPath, relativePath), 'utf8');
+}
+
+/**
+ * Cleans up all tracked temporary project directories.
+ */
+export async function cleanupTestProjects() {
+  const roots = Array.from(trackedRoots);
+  trackedRoots.clear();
+  for (const root of roots) {
+    try {
+      await rm(root, { recursive: true, force: true });
+    } catch (err) {
+      // Ignore cleanup errors
+    }
+  }
+}

package/test/helpers/testProject.test.js

@@ -0,0 +1,57 @@
+import assert from 'node:assert/strict';
+import { stat } from 'node:fs/promises';
+import test, { after } from 'node:test';
+
+import {
+  createTestProject,
+  writeProjectFile,
+  readProjectFile,
+  cleanupTestProjects
+} from './testProject.js';
+
+after(async () => {
+  await cleanupTestProjects();
+});
+
+test('createTestProject creates directories and serverless config', async () => {
+  const rootPath = await createTestProject({
+    serviceName: 'DemoService',
+    serviceTag: 'DemoTag'
+  });
+
+  const config = await readProjectFile(
+    rootPath,
+    'config/serverless.config.yml'
+  );
+  assert.match(config, /service: DemoService/);
+  assert.match(config, /serviceTag: DemoTag/);
+
+  const customFile = 'app/src/schemas/ObjectSchemas/Demo.js';
+  await writeProjectFile(
+    rootPath,
+    customFile,
+    'export default [{ objectType: "demo" }];'
+  );
+
+  const readBack = await readProjectFile(rootPath, customFile);
+  assert.match(readBack, /objectType: "demo"/);
+
+  const stats = await stat(rootPath);
+  assert.equal(stats.isDirectory(), true);
+});
+
+test('createTestProject populates initial schemas map', async () => {
+  const rootPath = await createTestProject({
+    schemas: {
+      ObjectSchemas: {
+        'Item.js': 'export default [{ objectType: "item" }];'
+      }
+    }
+  });
+
+  const content = await readProjectFile(
+    rootPath,
+    'app/src/schemas/ObjectSchemas/Item.js'
+  );
+  assert.match(content, /objectType: "item"/);
+});

package/test/{core.test.js → integration/core.test.js}

@@ -11,9 +11,9 @@ import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import test from 'node:test';
 
-import { buildGenerationPlan } from '../src/plan/buildGenerationPlan.js';
-import { commitArtifacts } from '../src/output/commitArtifacts.js';
-import { compileProject } from '../src/compile/compileProject.js';
+import { buildGenerationPlan } from '../../src/plan/buildGenerationPlan.js';
+import { commitArtifacts } from '../../src/output/commitArtifacts.js';
+import { compileProject } from '../../src/compile/compileProject.js';
 
 test('compiles a request and commits only declared relative artifacts', async () => {
   const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-'));

package/test/{graphDrivenFlowSchema.test.js → integration/graphDrivenFlowSchema.test.js}

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { validateFlowSchema } from '../src/compile/flowValidator.js';
+import { validateFlowSchema } from '../../src/compile/flowValidator.js';
 
 test('validateFlowSchema passes for valid Graph-Driven FlowSchema', () => {
   const validSchema = {

package/test/{intTestApi.test.js → integration/intTestApi.test.js}

@@ -4,7 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import test from 'node:test';
 
-import { generateIntTest, generateResourceIntTest } from '../index.js';
+import { generateIntTest, generateResourceIntTest } from '../../index.js';
 
 test('exports IntTest generators and requires a service tag', async () => {
   const rootPath = await mkdtemp(