@powerhousedao/vetra 6.0.0-dev.8 → 6.0.0-dev.80

package/dist/processors/codegen/document-handlers/generators/document-model-generator.js

@@ -2,12 +2,24 @@ import { generateFromDocument, generateManifest, validateDocumentModelState, } f
 import { logger } from "../../logger.js";
 import { BaseDocumentGen } from "../base-document-gen.js";
 import { USE_TS_MORPH, USE_VERSIONING } from "./constants.js";
-import { backupDocument } from "./utils.js";
+import { minimalBackupDocument } from "./utils.js";
 /**
  * Generator for document model documents
  */
 export class DocumentModelGenerator extends BaseDocumentGen {
     supportedDocumentTypes = "powerhouse/document-model";
+    /**
+     * Extract the global state from the full document state
+     */
+    extractGlobalState(strand) {
+        const fullState = strand.state;
+        if (!fullState) {
+            return undefined;
+        }
+        // The state is the full document state with {auth, document, local, global, header}
+        // We need the global property which contains the DocumentModelGlobalState
+        return fullState.global;
+    }
     /**
      * Validate if this document model strand should be processed
      */
@@ -16,58 +28,68 @@ export class DocumentModelGenerator extends BaseDocumentGen {
         if (!super.shouldProcess(strand)) {
             return false;
         }
-        // Validate document model state
-        const state = strand.state;
-        if (!state) {
-            logger.debug(`>>> No state found for document model: ${strand.documentId}`);
+        // Extract the global state from the full document state
+        const globalState = this.extractGlobalState(strand);
+        if (!globalState) {
+            logger.debug(`>>> No global state found for document model: ${strand.documentId}`);
             return false;
         }
-        const validationResult = validateDocumentModelState(state);
+        const validationResult = validateDocumentModelState(globalState);
         if (!validationResult.isValid) {
             const errorList = validationResult.errors
                 .map((error) => `  - ${error}`)
                 .join("\n");
-            logger.info(`⚠️  Skipped code generation for '${state.name || strand.documentId}' due to validation errors:\n${errorList}`);
+            logger.info(`⚠️  Skipped code generation for '${globalState.name || strand.documentId}' due to validation errors:\n${errorList}`);
             return false;
         }
-        logger.info(`Document model ${state.name} is valid, proceeding with code generation`);
+        logger.info(`Document model ${globalState.name} is valid, proceeding with code generation`);
         return true;
     }
     async generate(strand) {
-        const state = strand.state;
+        const globalState = this.extractGlobalState(strand);
+        if (!globalState) {
+            logger.error(`❌ No global state found for document model: ${strand.documentId}`);
+            return;
+        }
         // Validation is already done in shouldProcess, so we can proceed directly
-        logger.debug(`🔄 Starting code generation for document model: ${state.name}`);
+        logger.debug(`🔄 Starting code generation for document model: ${globalState.name}`);
         try {
             await generateFromDocument({
-                documentModelState: state,
+                documentModelState: globalState,
                 config: this.config.PH_CONFIG,
                 useTsMorph: USE_TS_MORPH,
                 useVersioning: USE_VERSIONING,
             });
-            logger.info(`✅ Code generation completed successfully for: ${state.name}`);
+            logger.info(`✅ Code generation completed successfully for: ${globalState.name}`);
             // Update the manifest with the new document model
             try {
-                logger.debug(`🔄 Updating manifest with document model: ${state.name} (ID: ${state.id})`);
+                logger.debug(`🔄 Updating manifest with document model: ${globalState.name} (ID: ${globalState.id})`);
                 generateManifest({
                     documentModels: [
                         {
-                            id: state.id,
-                            name: state.name,
+                            id: globalState.id,
+                            name: globalState.name,
                         },
                     ],
                 }, this.config.CURRENT_WORKING_DIR);
-                logger.debug(`✅ Manifest updated successfully for document model: ${state.name}`);
+                logger.debug(`✅ Manifest updated successfully for document model: ${globalState.name}`);
             }
             catch (manifestError) {
-                logger.error(`⚠️ Failed to update manifest for document model ${state.name}:`, manifestError);
+                logger.error(`⚠️ Failed to update manifest for document model ${globalState.name}:`, manifestError);
                 // Don't throw here - code generation was successful
             }
             // Backup the document
-            const extension = state.extension?.replace(/^\.+|\.+$/g, "") || "";
-            await backupDocument(strand.document, this.config.CURRENT_WORKING_DIR, extension, state.name);
+            const extension = globalState.extension?.replace(/^\.+|\.+$/g, "") || "";
+            await minimalBackupDocument({
+                documentId: strand.documentId,
+                documentType: strand.documentType,
+                branch: strand.branch,
+                state: strand.state,
+                name: globalState.name,
+            }, this.config.CURRENT_WORKING_DIR, extension);
         }
         catch (error) {
-            logger.error(`❌ Error during code generation for ${state.name}:`, error);
+            logger.error(`❌ Error during code generation for ${globalState.name}:`, error);
             // Don't throw - let codegen continue with other documents
             return;
         }

package/dist/processors/codegen/document-handlers/generators/package-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package-generator.d.ts","sourceRoot":"","sources":["../../../../../processors/codegen/document-handlers/generators/package-generator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAGhE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAG1D;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,eAAe;IACnD,QAAQ,CAAC,sBAAsB,wBAAwB;IAEvD;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO;IAenD,QAAQ,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;CA0BjE"}
+{"version":3,"file":"package-generator.d.ts","sourceRoot":"","sources":["../../../../../processors/codegen/document-handlers/generators/package-generator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAMhE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAG1D;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,eAAe;IACnD,QAAQ,CAAC,sBAAsB,wBAAwB;IAEvD;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO;IAenD,QAAQ,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;CA8BjE"}

package/dist/processors/codegen/document-handlers/generators/package-generator.js

@@ -1,7 +1,7 @@
 import { generateManifest } from "@powerhousedao/codegen";
 import { logger } from "../../logger.js";
 import { BaseDocumentGen } from "../base-document-gen.js";
-import { backupDocument } from "./utils.js";
+import { minimalBackupDocument } from "./utils.js";
 /**
  * Generator for package documents
  */
@@ -36,6 +36,12 @@ export class PackageGenerator extends BaseDocumentGen {
         }, this.config.CURRENT_WORKING_DIR);
         logger.info("✅ Manifest generated successfully");
         // Backup the document
-        await backupDocument(strand.document, this.config.CURRENT_WORKING_DIR, undefined, "vetra-package");
+        await minimalBackupDocument({
+            documentId: strand.documentId,
+            documentType: strand.documentType,
+            branch: strand.branch,
+            state: strand.state,
+            name: "vetra-package",
+        }, this.config.CURRENT_WORKING_DIR);
     }
 }

package/dist/processors/codegen/document-handlers/generators/processor-generator.d.ts

@@ -5,6 +5,10 @@ import { BaseDocumentGen } from "../base-document-gen.js";
  */
 export declare class ProcessorGenerator extends BaseDocumentGen {
     readonly supportedDocumentTypes = "powerhouse/processor";
+    /**
+     * Extract the global state from the full document state
+     */
+    private extractGlobalState;
     /**
      * Validate if this processor strand should be processed
      */

package/dist/processors/codegen/document-handlers/generators/processor-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"processor-generator.d.ts","sourceRoot":"","sources":["../../../../../processors/codegen/document-handlers/generators/processor-generator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAGhE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAG1D;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,eAAe;IACrD,QAAQ,CAAC,sBAAsB,0BAA0B;IAEzD;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO;IAsCnD,QAAQ,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;CA8EjE"}
+{"version":3,"file":"processor-generator.d.ts","sourceRoot":"","sources":["../../../../../processors/codegen/document-handlers/generators/processor-generator.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAMhE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAI1D;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,eAAe;IACrD,QAAQ,CAAC,sBAAsB,0BAA0B;IAEzD;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO;IA2CnD,QAAQ,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;CAkGjE"}

package/dist/processors/codegen/document-handlers/generators/processor-generator.js

@@ -1,12 +1,24 @@
 import { generateProcessor } from "@powerhousedao/codegen";
+import { PROCESSOR_APPS, } from "@powerhousedao/shared/processors";
 import { logger } from "../../logger.js";
 import { BaseDocumentGen } from "../base-document-gen.js";
-import { backupDocument } from "./utils.js";
+import { USE_TS_MORPH } from "./constants.js";
+import { minimalBackupDocument } from "./utils.js";
 /**
  * Generator for processor documents
  */
 export class ProcessorGenerator extends BaseDocumentGen {
     supportedDocumentTypes = "powerhouse/processor";
+    /**
+     * Extract the global state from the full document state
+     */
+    extractGlobalState(strand) {
+        const fullState = strand.state;
+        if (!fullState) {
+            return undefined;
+        }
+        return fullState.global;
+    }
     /**
      * Validate if this processor strand should be processed
      */
@@ -15,36 +27,45 @@ export class ProcessorGenerator extends BaseDocumentGen {
         if (!super.shouldProcess(strand)) {
             return false;
         }
-        const state = strand.state;
+        const state = this.extractGlobalState(strand);
         if (!state) {
-            logger.debug(`>>> No state found for processor: ${strand.documentId}`);
+            logger.debug(`No state found for processor: ${strand.documentId}`);
             return false;
         }
         // Check if we have a valid processor name, type, document types, and it's confirmed
         if (!state.name) {
-            logger.debug(`>>> No name found for processor: ${strand.documentId}`);
+            logger.debug(`No name found for processor: ${strand.documentId}`);
             return false;
         }
         if (!state.type) {
-            logger.debug(`>>> No type found for processor: ${state.name}`);
+            logger.debug(`No type found for processor: ${state.name}`);
             return false;
         }
         if (!state.documentTypes || state.documentTypes.length === 0) {
-            logger.debug(`>>> No document types found for processor: ${state.name}`);
+            logger.debug(`No document types found for processor: ${state.name}`);
+            return false;
+        }
+        if (!state.processorApps || state.processorApps.length === 0) {
+            logger.debug(`No processor apps found for processor: ${state.name}`);
             return false;
         }
         if (state.status !== "CONFIRMED") {
-            logger.debug(`>>> Processor not confirmed: ${state.name} (status: ${state.status})`);
+            logger.debug(`Processor not confirmed: ${state.name} (status: ${state.status})`);
             return false;
         }
         return true;
     }
     async generate(strand) {
-        const state = strand.state;
+        const state = this.extractGlobalState(strand);
+        if (!state) {
+            logger.error(`No state found for processor: ${strand.documentId}`);
+            return;
+        }
         // Check if we have a valid processor name, type, document types, and it's confirmed
         if (state.name &&
             state.type &&
             state.documentTypes.length > 0 &&
+            state.processorApps.length > 0 &&
             state.status === "CONFIRMED") {
             logger.info(`🔄 Starting processor generation for: ${state.name}`);
             try {
@@ -62,11 +83,29 @@ export class ProcessorGenerator extends BaseDocumentGen {
                 }
                 // Extract document types from the state
                 const documentTypes = state.documentTypes.map((dt) => dt.documentType);
+                const processorApps = state.processorApps;
+                if (!isProcessorApps(processorApps)) {
+                    logger.error(`❌ Unsupported processor apps: ${processorApps.join(", ")}`);
+                    return;
+                }
                 // Generate the processor using the codegen function
-                await generateProcessor(state.name, processorType, documentTypes, this.config.PH_CONFIG);
+                await generateProcessor({
+                    processorName: state.name,
+                    processorType,
+                    documentTypes,
+                    skipFormat: this.config.PH_CONFIG.skipFormat,
+                    useTsMorph: USE_TS_MORPH,
+                    processorApps,
+                });
                 logger.info(`✅ Processor generation completed successfully for: ${state.name}`);
                 // Backup the document
-                await backupDocument(strand.document, this.config.CURRENT_WORKING_DIR, undefined, state.name);
+                await minimalBackupDocument({
+                    documentId: strand.documentId,
+                    documentType: strand.documentType,
+                    branch: strand.branch,
+                    state: strand.state,
+                    name: state.name,
+                }, this.config.CURRENT_WORKING_DIR);
             }
             catch (error) {
                 logger.error(`❌ Error during processor generation for ${state.name}:`, error);
@@ -95,3 +134,13 @@ export class ProcessorGenerator extends BaseDocumentGen {
         }
     }
 }
+function isProcessorApps(input) {
+    if (input.length === 0)
+        return false;
+    if (new Set(input).size !== input.length) {
+        return false;
+    }
+    if (!input.every((i) => PROCESSOR_APPS.includes(i)))
+        return false;
+    return true;
+}

package/dist/processors/codegen/document-handlers/generators/subgraph-generator.d.ts

@@ -5,6 +5,10 @@ import { BaseDocumentGen } from "../base-document-gen.js";
  */
 export declare class SubgraphGenerator extends BaseDocumentGen {
     readonly supportedDocumentTypes = "powerhouse/subgraph";
+    /**
+     * Extract the global state from the full document state
+     */
+    private extractGlobalState;
     /**
      * Validate if this subgraph strand should be processed
      */

package/dist/processors/codegen/document-handlers/generators/subgraph-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subgraph-generator.d.ts","sourceRoot":"","sources":["../../../../../processors/codegen/document-handlers/generators/subgraph-generator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAGhE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAG1D;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,eAAe;IACpD,QAAQ,CAAC,sBAAsB,yBAAyB;IAExD;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO;IA4BnD,QAAQ,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;CAwEjE"}
+{"version":3,"file":"subgraph-generator.d.ts","sourceRoot":"","sources":["../../../../../processors/codegen/document-handlers/generators/subgraph-generator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAMhE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAG1D;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,eAAe;IACpD,QAAQ,CAAC,sBAAsB,yBAAyB;IAExD;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO;IA4BnD,QAAQ,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;CAgFjE"}

package/dist/processors/codegen/document-handlers/generators/subgraph-generator.js

@@ -2,12 +2,22 @@ import { generateManifest, generateSubgraph } from "@powerhousedao/codegen";
 import { kebabCase } from "change-case";
 import { logger } from "../../logger.js";
 import { BaseDocumentGen } from "../base-document-gen.js";
-import { backupDocument } from "./utils.js";
+import { minimalBackupDocument } from "./utils.js";
 /**
  * Generator for subgraph documents
  */
 export class SubgraphGenerator extends BaseDocumentGen {
     supportedDocumentTypes = "powerhouse/subgraph";
+    /**
+     * Extract the global state from the full document state
+     */
+    extractGlobalState(strand) {
+        const fullState = strand.state;
+        if (!fullState) {
+            return undefined;
+        }
+        return fullState.global;
+    }
     /**
      * Validate if this subgraph strand should be processed
      */
@@ -16,24 +26,28 @@ export class SubgraphGenerator extends BaseDocumentGen {
         if (!super.shouldProcess(strand)) {
             return false;
         }
-        const state = strand.state;
+        const state = this.extractGlobalState(strand);
         if (!state) {
-            logger.debug(`>>> No state found for subgraph: ${strand.documentId}`);
+            logger.debug(`No state found for subgraph: ${strand.documentId}`);
             return false;
         }
         // Check if we have a valid subgraph name and it's confirmed
         if (!state.name) {
-            logger.debug(`>>> No name found for subgraph: ${strand.documentId}`);
+            logger.debug(`No name found for subgraph: ${strand.documentId}`);
             return false;
         }
         if (state.status !== "CONFIRMED") {
-            logger.debug(`>>> Subgraph not confirmed: ${state.name} (status: ${state.status})`);
+            logger.debug(`Subgraph not confirmed: ${state.name} (status: ${state.status})`);
             return false;
         }
         return true;
     }
     async generate(strand) {
-        const state = strand.state;
+        const state = this.extractGlobalState(strand);
+        if (!state) {
+            logger.error(`No state found for subgraph: ${strand.documentId}`);
+            return;
+        }
         // Check if we have a valid subgraph name and it's confirmed
         if (state.name && state.status === "CONFIRMED") {
             logger.info(`🔄 Starting subgraph generation for: ${state.name}`);
@@ -61,7 +75,13 @@ export class SubgraphGenerator extends BaseDocumentGen {
                     // Don't throw here - subgraph generation was successful
                 }
                 // Backup the document
-                await backupDocument(strand.document, this.config.CURRENT_WORKING_DIR, undefined, state.name);
+                await minimalBackupDocument({
+                    documentId: strand.documentId,
+                    documentType: strand.documentType,
+                    branch: strand.branch,
+                    state: strand.state,
+                    name: state.name,
+                }, this.config.CURRENT_WORKING_DIR);
             }
             catch (error) {
                 logger.error(`❌ Error during subgraph generation for ${state.name}:`, error);

package/dist/processors/codegen/document-handlers/generators/utils.d.ts

@@ -1,4 +1,6 @@
 import type { PHDocument } from "document-model";
+import { type MinimalBackupData } from "document-model/node";
+export type { MinimalBackupData };
 /**
  * Exports a document to the backup directory.
  * Creates the backup directory if it doesn't exist.
@@ -10,4 +12,9 @@ import type { PHDocument } from "document-model";
  * @returns Promise resolving to the backup file path, or undefined if backup failed
  */
 export declare function backupDocument(document: PHDocument, workingDir: string, extension?: string, name?: string): Promise<string | undefined>;
+/**
+ * Creates a minimal backup of a document from strand data.
+ * Used when the full document is not available (e.g., in onOperations handler).
+ */
+export declare function minimalBackupDocument(data: MinimalBackupData, workingDir: string, extension?: string): Promise<string | undefined>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/processors/codegen/document-handlers/generators/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../processors/codegen/document-handlers/generators/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAQjD;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,UAAU,EACpB,UAAU,EAAE,MAAM,EAClB,SAAS,GAAE,MAAW,EACtB,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAoB7B"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../processors/codegen/document-handlers/generators/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAK7B,YAAY,EAAE,iBAAiB,EAAE,CAAC;AAIlC;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,UAAU,EACpB,UAAU,EAAE,MAAM,EAClB,SAAS,GAAE,MAAW,EACtB,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAoB7B;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,iBAAiB,EACvB,UAAU,EAAE,MAAM,EAClB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAiB7B"}

package/dist/processors/codegen/document-handlers/generators/utils.js

@@ -1,4 +1,4 @@
-import { baseSaveToFile } from "document-model/node";
+import { baseMinimalSaveToFile, baseSaveToFile, } from "document-model/node";
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { logger } from "../../logger.js";
@@ -27,3 +27,20 @@ export async function backupDocument(document, workingDir, extension = "", name)
         return undefined;
     }
 }
+/**
+ * Creates a minimal backup of a document from strand data.
+ * Used when the full document is not available (e.g., in onOperations handler).
+ */
+export async function minimalBackupDocument(data, workingDir, extension) {
+    try {
+        const backupPath = join(workingDir, BACKUP_FOLDER);
+        await mkdir(backupPath, { recursive: true });
+        const filePath = await baseMinimalSaveToFile(data, backupPath, extension ?? "");
+        logger.debug(`Document backed up to: ${filePath}`);
+        return filePath;
+    }
+    catch (error) {
+        logger.warn(`Failed to backup document "${data.name}":`, error);
+        return undefined;
+    }
+}

package/dist/processors/codegen/factory.d.ts

@@ -1,4 +1,4 @@
-import type { IProcessorHostModule, ProcessorRecord } from "document-drive";
+import type { IProcessorHostModule, ProcessorRecord } from "@powerhousedao/reactor-browser";
 import type { PHDocumentHeader } from "document-model";
 export declare const codegenProcessorFactory: (module: IProcessorHostModule) => (driveHeader: PHDocumentHeader) => ProcessorRecord[];
 //# sourceMappingURL=factory.d.ts.map

package/dist/processors/codegen/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../processors/codegen/factory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAgCvD,eAAO,MAAM,uBAAuB,GACjC,QAAQ,oBAAoB,MAC5B,aAAa,gBAAgB,KAAG,eAAe,EAsC/C,CAAC"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../processors/codegen/factory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,oBAAoB,EACpB,eAAe,EAChB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAgCvD,eAAO,MAAM,uBAAuB,GACjC,QAAQ,oBAAoB,MAC5B,aAAa,gBAAgB,KAAG,eAAe,EAsC/C,CAAC"}

package/dist/processors/codegen/factory.legacy.d.ts

@@ -0,0 +1,4 @@
+import type { IProcessorHostModuleLegacy, ProcessorRecordLegacy } from "document-drive";
+import type { PHDocumentHeader } from "document-model";
+export declare const codegenProcessorFactoryLegacy: (module: IProcessorHostModuleLegacy) => (driveHeader: PHDocumentHeader) => ProcessorRecordLegacy[];
+//# sourceMappingURL=factory.legacy.d.ts.map

package/dist/processors/codegen/factory.legacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.legacy.d.ts","sourceRoot":"","sources":["../../../processors/codegen/factory.legacy.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,0BAA0B,EAC1B,qBAAqB,EACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAgCvD,eAAO,MAAM,6BAA6B,GACvC,QAAQ,0BAA0B,MAClC,aAAa,gBAAgB,KAAG,qBAAqB,EAsCrD,CAAC"}

package/dist/processors/codegen/factory.legacy.js

@@ -0,0 +1,53 @@
+import { VETRA_PROCESSOR_CONFIG_KEY } from "@powerhousedao/config";
+import { CodegenProcessorLegacy } from "./index.legacy.js";
+import { logger } from "./logger.js";
+/**
+ * Determines if a drive header matches the Vetra drive criteria.
+ * @param driveHeader - The drive header to check
+ * @param explicitDriveId - Optional explicit drive ID from config (if set, uses exact match)
+ * @returns true if the drive is a Vetra drive, false otherwise
+ */
+function isDriveVetra(driveHeader, driveIdFromConfig) {
+    // If explicit drive ID is configured, use exact match
+    if (driveIdFromConfig) {
+        return (driveHeader.slug === driveIdFromConfig ||
+            driveHeader.id === driveIdFromConfig);
+    }
+    // Otherwise, check if slug/id matches Vetra pattern
+    // Matches "vetra" exactly or IDs starting with "vetra-" (case-insensitive)
+    const matchesPattern = (identifier) => {
+        const lower = identifier.toLowerCase();
+        return lower === "vetra" || lower.startsWith("vetra-");
+    };
+    return matchesPattern(driveHeader.slug) || matchesPattern(driveHeader.id);
+}
+export const codegenProcessorFactoryLegacy = (module) => (driveHeader) => {
+    // Create the processor
+    const processorsConfig = module.config ?? new Map();
+    const vetraConfig = processorsConfig.get(VETRA_PROCESSOR_CONFIG_KEY);
+    // Check if this drive should use the Vetra processor
+    if (!isDriveVetra(driveHeader, vetraConfig?.driveId)) {
+        logger.info(`Drive ${driveHeader.slug} is not a Vetra drive, skipping codegen processor`);
+        return [];
+    }
+    logger.info(`Drive ${driveHeader.slug} is a Vetra drive, using codegen processor (legacy)`);
+    const processor = new CodegenProcessorLegacy(vetraConfig?.interactive);
+    return [
+        {
+            processor,
+            filter: {
+                branch: ["main"],
+                documentId: ["*"],
+                documentType: [
+                    "powerhouse/document-model",
+                    "powerhouse/package",
+                    "powerhouse/document-editor",
+                    "powerhouse/subgraph",
+                    "powerhouse/processor",
+                    "powerhouse/app",
+                ],
+                scope: ["global"],
+            },
+        },
+    ];
+};

package/dist/processors/codegen/index.d.ts

@@ -1,8 +1,8 @@
-import type { InternalTransmitterUpdate, IProcessor } from "document-drive";
+import type { IProcessor, OperationWithContext } from "@powerhousedao/reactor-browser";
 export declare class CodegenProcessor implements IProcessor {
     private manager;
     constructor(interactiveMode?: boolean);
-    onStrands(strands: InternalTransmitterUpdate[]): Promise<void>;
+    onOperations(operations: OperationWithContext[]): Promise<void>;
     onDisconnect(): Promise<void>;
     setInteractiveMode(enabled: boolean): void;
     isInteractive(): boolean;

package/dist/processors/codegen/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../processors/codegen/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAQ5E,qBAAa,gBAAiB,YAAW,UAAU;IACjD,OAAO,CAAC,OAAO,CAAyB;gBAE5B,eAAe,UAAQ;IAoB7B,SAAS,CAAC,OAAO,EAAE,yBAAyB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAqC9D,YAAY;IAGX,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAI1C,aAAa,IAAI,OAAO;IAIxB,uBAAuB,IAAI,OAAO;CAG1C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../processors/codegen/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,UAAU,EACV,oBAAoB,EACrB,MAAM,gCAAgC,CAAC;AASxC,qBAAa,gBAAiB,YAAW,UAAU;IACjD,OAAO,CAAC,OAAO,CAAyB;gBAE5B,eAAe,UAAQ;IAkB7B,YAAY,CAAC,UAAU,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiC/D,YAAY;IAGX,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAI1C,aAAa,IAAI,OAAO;IAIxB,uBAAuB,IAAI,OAAO;CAG1C"}

package/dist/processors/codegen/index.js

@@ -11,37 +11,38 @@ export class CodegenProcessor {
             CURRENT_WORKING_DIR,
         }, interactiveMode);
         if (interactiveMode) {
-            logger.info(`🔔 CodegenProcessor initialized with interactive mode enabled`);
+            logger.info(`CodegenProcessor initialized with interactive mode enabled`);
         }
         else {
             logger.debug(`CodegenProcessor initialized with interactive mode disabled`);
         }
     }
-    async onStrands(strands) {
-        logger.info(">>> onStrands()");
-        // Filter strands to only include those that should be processed
-        const validStrands = strands.filter((strand) => {
-            const generator = this.manager.getGenerator(strand.documentType);
+    async onOperations(operations) {
+        logger.info("CodegenProcessor.onOperations()");
+        for (const { operation, context } of operations) {
+            const generator = this.manager.getGenerator(context.documentType);
             if (!generator) {
-                logger.debug(`>>> No generator found for document type: ${strand.documentType}`);
-                return false;
+                logger.debug(`No generator found for document type: ${context.documentType}`);
+                continue;
             }
-            // Use the required shouldProcess method for validation
-            const shouldProcessResult = generator.shouldProcess(strand);
-            if (!shouldProcessResult) {
-                logger.debug(`>>> Generator validation failed for ${strand.documentType}:${strand.documentId}, skipping processing`);
-            }
-            return shouldProcessResult;
-        });
-        if (validStrands.length > 0) {
-            logger.debug(`>>> Processing ${validStrands.length} valid strands (out of ${strands.length} total)`);
-            for (const strand of validStrands) {
+            // Create strand-like object for generator (using existing generator interface)
+            // Cast to InternalTransmitterUpdate since generators only use a subset of fields
+            const strand = {
+                documentId: context.documentId,
+                documentType: context.documentType,
+                scope: context.scope,
+                branch: context.branch,
+                driveId: "", // Not available in new format
+                operations: [operation],
+                state: context.resultingState
+                    ? JSON.parse(context.resultingState)
+                    : undefined,
+            };
+            const shouldProcess = generator.shouldProcess(strand);
+            if (shouldProcess) {
                 await this.manager.routeAndGenerate(strand);
             }
         }
-        else {
-            logger.debug(`>>> No valid strands to process (${strands.length} strands received)`);
-        }
     }
     async onDisconnect() { }
     // Utility methods for external configuration and monitoring

package/dist/processors/codegen/index.legacy.d.ts

@@ -0,0 +1,11 @@
+import type { InternalTransmitterUpdate, IProcessorLegacy } from "document-drive";
+export declare class CodegenProcessorLegacy implements IProcessorLegacy {
+    private manager;
+    constructor(interactiveMode?: boolean);
+    onStrands(strands: InternalTransmitterUpdate[]): Promise<void>;
+    onDisconnect(): Promise<void>;
+    setInteractiveMode(enabled: boolean): void;
+    isInteractive(): boolean;
+    isProcessingInteractive(): boolean;
+}
+//# sourceMappingURL=index.legacy.d.ts.map

package/dist/processors/codegen/index.legacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.legacy.d.ts","sourceRoot":"","sources":["../../../processors/codegen/index.legacy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,yBAAyB,EACzB,gBAAgB,EACjB,MAAM,gBAAgB,CAAC;AAQxB,qBAAa,sBAAuB,YAAW,gBAAgB;IAC7D,OAAO,CAAC,OAAO,CAAyB;gBAE5B,eAAe,UAAQ;IAoB7B,SAAS,CAAC,OAAO,EAAE,yBAAyB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAqC9D,YAAY;IAGX,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAI1C,aAAa,IAAI,OAAO;IAIxB,uBAAuB,IAAI,OAAO;CAG1C"}