@powerhousedao/vetra 4.1.0-dev.8 → 4.1.0-dev.81

package/dist/editors/vetra-package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../editors/vetra-package/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGnD,eAAO,MAAM,MAAM,EAAE,YAOpB,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/editors/vetra-package/index.js

@@ -0,0 +1,10 @@
+import { Editor } from "./editor.js";
+export const module = {
+    Component: Editor,
+    documentTypes: ["powerhouse/package"],
+    config: {
+        id: "vetra-package-editor",
+        name: "Vetra Package Editor",
+    },
+};
+export default module;

package/dist/index.d.ts

@@ -1,5 +1,11 @@
-import type { Manifest } from "document-model";
+import type { DocumentModelModule, EditorModule, Manifest } from "document-model";
+import type { AppModulePHState } from "./document-models/app-module/gen/types.js";
+import type { DocumentEditorPHState } from "./document-models/document-editor/gen/types.js";
+import type { ProcessorModulePHState } from "./document-models/processor-module/gen/types.js";
+import type { SubgraphModulePHState } from "./document-models/subgraph-module/gen/types.js";
+import type { VetraPackagePHState } from "./document-models/vetra-package/gen/types.js";
 export declare const manifest: Manifest;
-export declare const documentModels: import("document-model").DocumentModelModule<import("./document-models/vetra-package/index.js").VetraPackageDocument>[];
-export declare const editors: unknown[];
+export declare const documentModels: (DocumentModelModule<DocumentEditorPHState> | DocumentModelModule<VetraPackagePHState> | DocumentModelModule<SubgraphModulePHState> | DocumentModelModule<ProcessorModulePHState> | DocumentModelModule<AppModulePHState>)[];
+export declare const editors: EditorModule[];
+export * from "./editors/hooks/useVetraDocument.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAK/C,eAAO,MAAM,QAAQ,EAAE,QAAuB,CAAC;AAC/C,eAAO,MAAM,cAAc,yHAAuC,CAAC;AACnE,eAAO,MAAM,OAAO,WAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,YAAY,EACZ,QAAQ,EACT,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAE5F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iDAAiD,CAAC;AAC9F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAC5F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AAIxF,eAAO,MAAM,QAAQ,EAAE,QAAuB,CAAC;AAC/C,eAAO,MAAM,cAAc,EAAE,CACzB,mBAAmB,CAAC,qBAAqB,CAAC,GAC1C,mBAAmB,CAAC,mBAAmB,CAAC,GACxC,mBAAmB,CAAC,qBAAqB,CAAC,GAC1C,mBAAmB,CAAC,sBAAsB,CAAC,GAC3C,mBAAmB,CAAC,gBAAgB,CAAC,CACxC,EAAyC,CAAC;AAC3C,eAAO,MAAM,OAAO,EAAE,YAAY,EAAkC,CAAC;AAErE,cAAc,qCAAqC,CAAC"}

package/dist/index.js

@@ -1,7 +1,7 @@
-import * as documentModelsExports from './document-models/index.js';
-import * as editorsExports from './editors/index.js';
+import * as documentModelsExports from "./document-models/index.js";
+import * as editorsExports from "./editors/index.js";
 import manifestJson from "./powerhouse.manifest.json" with { type: "json" };
 export const manifest = manifestJson;
 export const documentModels = Object.values(documentModelsExports);
 export const editors = Object.values(editorsExports);
-//# sourceMappingURL=index.js.map
+export * from "./editors/hooks/useVetraDocument.js";

package/dist/powerhouse.manifest.json

@@ -1,25 +1,67 @@
 {
-    "name": "your-model-name",
-    "description": "A brief description of your PH package.",
-    "category": "your-category",
+    "name": "@powerhousedao/vetra",
+    "description": "Vetra package",
+    "category": "",
     "publisher": {
-        "name": "your-publisher-name",
-        "url": "your-publisher-url"
+        "name": "@powerhousedao",
+        "url": "https://github.com/powerhouse-inc/powerhouse/tree/main/packages/vetra"
     },
     "documentModels": [
         {
-            "id": "your-model-id",
-            "name": "your-model-name"
+            "id": "powerhouse/package",
+            "name": "Vetra Package"
+        },
+        {
+            "id": "powerhouse/document-editor",
+            "name": "Document Editor"
+        },
+        {
+            "id": "powerhouse/subgraph-module",
+            "name": "Subgraph Module"
+        },
+        {
+            "id": "powerhouse/processor",
+            "name": "Processor Module"
+        },
+        {
+            "id": "powerhouse/app",
+            "name": "App Module"
         }
     ],
     "editors": [
         {
-            "id": "your-editor-id",
-            "name": "your-editor-name",
-            "documentTypes": ["your-model-id"]
+            "id": "vetra-package-editor",
+            "name": "Vetra Package Editor",
+            "documentTypes": ["powerhouse/package"]
+        },
+        {
+            "id": "document-editor-editor",
+            "name": "Document Editor",
+            "documentTypes": ["powerhouse/document-editor"]
+        },
+        {
+            "id": "subgraph-module-editor",
+            "name": "Subgraph Module Editor",
+            "documentTypes": ["powerhouse/subgraph-module"]
+        },
+        {
+            "id": "processor-module-editor",
+            "name": "Processor Module Editor",
+            "documentTypes": ["powerhouse/processor"]
+        },
+        {
+            "id": "app-module-editor",
+            "name": "App Module Editor",
+            "documentTypes": ["powerhouse/app"]
+        }
+    ],
+    "apps": [
+        {
+            "id": "vetra-drive-app",
+            "name": "Vetra Drive App",
+            "driveEditor": "vetra-drive-app"
         }
     ],
-    "apps": [],
     "subgraphs": [],
     "importScripts": []
 }

package/dist/processors/codegen/document-handlers/base-document-gen.d.ts

@@ -0,0 +1,34 @@
+import type { InternalTransmitterUpdate } from "document-drive";
+import type { Config } from "./types.js";
+/**
+ * Abstract base class for document generators
+ * Defines the interface that all document-type handlers must implement
+ */
+export declare abstract class BaseDocumentGen {
+    protected config: Config;
+    /**
+     * The document type(s) this generator supports
+     * Can be a single string or an array of strings for generators that handle multiple types
+     */
+    abstract readonly supportedDocumentTypes: string | string[];
+    constructor(config: Config);
+    /**
+     * Generate code for the given document
+     * Must be implemented by each specific document generator
+     */
+    abstract generate(strand: InternalTransmitterUpdate): Promise<void>;
+    /**
+     * Check if this generator supports the given document type
+     */
+    supportsDocumentType(documentType: string): boolean;
+    /**
+     * Get all supported document types as an array
+     */
+    getSupportedDocumentTypes(): string[];
+    /**
+     * Validate if this strand should be processed
+     * Override this method in specific generators to add custom validation logic
+     */
+    shouldProcess(strand: InternalTransmitterUpdate): boolean;
+}
+//# sourceMappingURL=base-document-gen.d.ts.map

package/dist/processors/codegen/document-handlers/base-document-gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-document-gen.d.ts","sourceRoot":"","sources":["../../../../processors/codegen/document-handlers/base-document-gen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,8BAAsB,eAAe;IAOvB,SAAS,CAAC,MAAM,EAAE,MAAM;IANpC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;gBAEtC,MAAM,EAAE,MAAM;IAEpC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAEnE;;OAEG;IACH,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAOnD;;OAEG;IACH,yBAAyB,IAAI,MAAM,EAAE;IAOrC;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO;CAc1D"}

package/dist/processors/codegen/document-handlers/base-document-gen.js

@@ -0,0 +1,44 @@
+/**
+ * Abstract base class for document generators
+ * Defines the interface that all document-type handlers must implement
+ */
+export class BaseDocumentGen {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Check if this generator supports the given document type
+     */
+    supportsDocumentType(documentType) {
+        if (typeof this.supportedDocumentTypes === "string") {
+            return this.supportedDocumentTypes === documentType;
+        }
+        return this.supportedDocumentTypes.includes(documentType);
+    }
+    /**
+     * Get all supported document types as an array
+     */
+    getSupportedDocumentTypes() {
+        if (typeof this.supportedDocumentTypes === "string") {
+            return [this.supportedDocumentTypes];
+        }
+        return [...this.supportedDocumentTypes];
+    }
+    /**
+     * Validate if this strand should be processed
+     * Override this method in specific generators to add custom validation logic
+     */
+    shouldProcess(strand) {
+        // Basic validation: ensure strand has required properties
+        if (!strand.documentId || !strand.documentType) {
+            return false;
+        }
+        // Basic validation: check if document type is supported
+        if (!this.supportsDocumentType(strand.documentType)) {
+            return false;
+        }
+        // Default to processing if basic validation passes
+        return true;
+    }
+}

package/dist/processors/codegen/document-handlers/document-codegen-factory.d.ts

@@ -0,0 +1,29 @@
+import { DocumentCodegenManager } from "./document-codegen-manager.js";
+import { AppGenerator, DocumentEditorGenerator, DocumentModelGenerator, PackageGenerator, ProcessorGenerator, SubgraphGenerator } from "./generators/index.js";
+import type { Config } from "./types.js";
+/**
+ * Factory class for creating and configuring DocumentCodegenManager instances
+ * with all the standard generators pre-registered
+ */
+export declare class DocumentCodegenFactory {
+    /**
+     * Create a DocumentCodegenManager with all standard generators registered
+     */
+    static createManager(config: Config, interactiveMode?: boolean): DocumentCodegenManager;
+    /**
+     * Create a DocumentCodegenManager with only specific generators
+     */
+    static createManagerWithGenerators(config: Config, generators: Array<new (config: Config) => any>, interactiveMode?: boolean): DocumentCodegenManager;
+    /**
+     * Get all available generator classes
+     */
+    static getAvailableGenerators(): {
+        DocumentModelGenerator: typeof DocumentModelGenerator;
+        PackageGenerator: typeof PackageGenerator;
+        AppGenerator: typeof AppGenerator;
+        DocumentEditorGenerator: typeof DocumentEditorGenerator;
+        SubgraphGenerator: typeof SubgraphGenerator;
+        ProcessorGenerator: typeof ProcessorGenerator;
+    };
+}
+//# sourceMappingURL=document-codegen-factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"document-codegen-factory.d.ts","sourceRoot":"","sources":["../../../../processors/codegen/document-handlers/document-codegen-factory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EACL,YAAY,EACZ,uBAAuB,EACvB,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,qBAAa,sBAAsB;IACjC;;OAEG;IACH,MAAM,CAAC,aAAa,CAClB,MAAM,EAAE,MAAM,EACd,eAAe,GAAE,OAAe,GAC/B,sBAAsB;IAoBzB;;OAEG;IACH,MAAM,CAAC,2BAA2B,CAChC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,KAAK,CAAC,KAAK,MAAM,EAAE,MAAM,KAAK,GAAG,CAAC,EAC9C,eAAe,GAAE,OAAe,GAC/B,sBAAsB;IAezB;;OAEG;IACH,MAAM,CAAC,sBAAsB;;;;;;;;CAU9B"}

package/dist/processors/codegen/document-handlers/document-codegen-factory.js

@@ -0,0 +1,49 @@
+import { DocumentCodegenManager } from "./document-codegen-manager.js";
+import { AppGenerator, DocumentEditorGenerator, DocumentModelGenerator, PackageGenerator, ProcessorGenerator, SubgraphGenerator, } from "./generators/index.js";
+/**
+ * Factory class for creating and configuring DocumentCodegenManager instances
+ * with all the standard generators pre-registered
+ */
+export class DocumentCodegenFactory {
+    /**
+     * Create a DocumentCodegenManager with all standard generators registered
+     */
+    static createManager(config, interactiveMode = false) {
+        const manager = new DocumentCodegenManager(config, interactiveMode);
+        // Register all the standard generators
+        manager.registerGenerator("powerhouse/document-model", DocumentModelGenerator);
+        manager.registerGenerator("powerhouse/package", PackageGenerator);
+        manager.registerGenerator("powerhouse/app", AppGenerator);
+        manager.registerGenerator("powerhouse/document-editor", DocumentEditorGenerator);
+        manager.registerGenerator("powerhouse/subgraph", SubgraphGenerator);
+        manager.registerGenerator("powerhouse/processor", ProcessorGenerator);
+        return manager;
+    }
+    /**
+     * Create a DocumentCodegenManager with only specific generators
+     */
+    static createManagerWithGenerators(config, generators, interactiveMode = false) {
+        const manager = new DocumentCodegenManager(config, interactiveMode);
+        for (const generatorClass of generators) {
+            const generator = new generatorClass(config);
+            const supportedTypes = generator.getSupportedDocumentTypes();
+            for (const documentType of supportedTypes) {
+                manager.registerGenerator(documentType, generatorClass);
+            }
+        }
+        return manager;
+    }
+    /**
+     * Get all available generator classes
+     */
+    static getAvailableGenerators() {
+        return {
+            DocumentModelGenerator,
+            PackageGenerator,
+            AppGenerator,
+            DocumentEditorGenerator,
+            SubgraphGenerator,
+            ProcessorGenerator,
+        };
+    }
+}

package/dist/processors/codegen/document-handlers/document-codegen-manager.d.ts

@@ -0,0 +1,73 @@
+import type { InternalTransmitterUpdate } from "document-drive";
+import type { BaseDocumentGen } from "./base-document-gen.js";
+import type { Config } from "./types.js";
+/**
+ * Manager class responsible for routing documents to the correct generator
+ * and managing generator registration and instantiation
+ */
+export declare class DocumentCodegenManager {
+    private config;
+    private generators;
+    private debounceTimers;
+    private processingQueue;
+    private interactiveManager;
+    constructor(config: Config, interactiveMode?: boolean);
+    /**
+     * Register a generator class for a specific document type
+     */
+    registerGenerator(documentType: string, generatorClass: new (config: Config) => BaseDocumentGen): void;
+    /**
+     * Register a generator class that supports multiple document types
+     */
+    registerMultiTypeGenerator(generatorClass: new (config: Config) => BaseDocumentGen): void;
+    /**
+     * Get a generator instance for the given document type
+     * Public method to allow external access for validation
+     */
+    getGenerator(documentType: string): BaseDocumentGen | undefined;
+    /**
+     * Get all registered document types
+     */
+    getRegisteredDocumentTypes(): string[];
+    /**
+     * Check if a document type is supported
+     */
+    isDocumentTypeSupported(documentType: string): boolean;
+    /**
+     * Route a document to the appropriate generator and handle the generation
+     * Handles both interactive and non-interactive modes with queue-based processing
+     */
+    routeAndGenerate(strand: InternalTransmitterUpdate): Promise<void>;
+    /**
+     * Process multiple strands in priority order (document-model types first)
+     */
+    private processQueuedStrands;
+    /**
+     * Process a single strand (used internally by processQueuedStrands)
+     */
+    private processStrand;
+    /**
+     * Clear all registered generators
+     */
+    clearGenerators(): void;
+    /**
+     * Get statistics about registered generators
+     */
+    getStats(): {
+        totalGenerators: number;
+        supportedTypes: string[];
+    };
+    /**
+     * Set interactive mode for code generation
+     */
+    setInteractiveMode(enabled: boolean): void;
+    /**
+     * Check if interactive mode is enabled
+     */
+    isInteractiveMode(): boolean;
+    /**
+     * Check if the manager is currently processing an interactive confirmation
+     */
+    isProcessingInteractive(): boolean;
+}
+//# sourceMappingURL=document-codegen-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"document-codegen-manager.d.ts","sourceRoot":"","sources":["../../../../processors/codegen/document-handlers/document-codegen-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAIhE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAIzC;;;GAGG;AACH,qBAAa,sBAAsB;IAO/B,OAAO,CAAC,MAAM;IANhB,OAAO,CAAC,UAAU,CAAsC;IACxD,OAAO,CAAC,cAAc,CAAqC;IAC3D,OAAO,CAAC,eAAe,CAAoC;IAC3D,OAAO,CAAC,kBAAkB,CAAqB;gBAGrC,MAAM,EAAE,MAAM,EACtB,eAAe,UAAQ;IAKzB;;OAEG;IACH,iBAAiB,CACf,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,KAAK,eAAe,GACtD,IAAI;IAWP;;OAEG;IACH,0BAA0B,CACxB,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,KAAK,eAAe,GACtD,IAAI;IAkBP;;;OAGG;IACI,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAItE;;OAEG;IACH,0BAA0B,IAAI,MAAM,EAAE;IAItC;;OAEG;IACH,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAItD;;;OAGG;IACG,gBAAgB,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAoGxE;;OAEG;YACW,oBAAoB;IA8BlC;;OAEG;YACW,aAAa;IA0B3B;;OAEG;IACH,eAAe,IAAI,IAAI;IAKvB;;OAEG;IACH,QAAQ,IAAI;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,EAAE,CAAA;KAAE;IAOjE;;OAEG;IACH,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAI1C;;OAEG;IACH,iBAAiB,IAAI,OAAO;IAI5B;;OAEG;IACH,uBAAuB,IAAI,OAAO;CAGnC"}

package/dist/processors/codegen/document-handlers/document-codegen-manager.js

@@ -0,0 +1,213 @@
+import { InteractiveManager } from "../interactive-manager.js";
+import { logger } from "../logger.js";
+const DEFAULT_DEBOUNCE_TIME = 1000; // 1 second
+/**
+ * Manager class responsible for routing documents to the correct generator
+ * and managing generator registration and instantiation
+ */
+export class DocumentCodegenManager {
+    config;
+    generators = new Map();
+    debounceTimers = new Map();
+    processingQueue = Promise.resolve();
+    interactiveManager;
+    constructor(config, interactiveMode = false) {
+        this.config = config;
+        this.interactiveManager = new InteractiveManager(interactiveMode);
+    }
+    /**
+     * Register a generator class for a specific document type
+     */
+    registerGenerator(documentType, generatorClass) {
+        if (this.generators.has(documentType)) {
+            logger.warn(`⚠️ Generator for document type "${documentType}" is already registered. Overwriting.`);
+        }
+        this.generators.set(documentType, new generatorClass(this.config));
+        logger.debug(`✅ Registered generator for document type: ${documentType}`);
+    }
+    /**
+     * Register a generator class that supports multiple document types
+     */
+    registerMultiTypeGenerator(generatorClass) {
+        const generator = new generatorClass(this.config);
+        const supportedTypes = generator.getSupportedDocumentTypes();
+        for (const documentType of supportedTypes) {
+            if (this.generators.has(documentType)) {
+                logger.warn(`⚠️ Generator for document type "${documentType}" is already registered. Overwriting.`);
+            }
+            this.generators.set(documentType, generator);
+        }
+        logger.info(`✅ Registered multi-type generator for document types: ${supportedTypes.join(", ")}`);
+    }
+    /**
+     * Get a generator instance for the given document type
+     * Public method to allow external access for validation
+     */
+    getGenerator(documentType) {
+        return this.generators.get(documentType);
+    }
+    /**
+     * Get all registered document types
+     */
+    getRegisteredDocumentTypes() {
+        return Array.from(this.generators.keys());
+    }
+    /**
+     * Check if a document type is supported
+     */
+    isDocumentTypeSupported(documentType) {
+        return this.generators.has(documentType);
+    }
+    /**
+     * Route a document to the appropriate generator and handle the generation
+     * Handles both interactive and non-interactive modes with queue-based processing
+     */
+    async routeAndGenerate(strand) {
+        const documentType = strand.documentType;
+        if (!documentType) {
+            logger.error("❌ Document type is missing from strand state");
+            throw new Error("Document type is missing from strand state");
+        }
+        const generator = this.getGenerator(documentType);
+        if (!generator) {
+            logger.warn(`⚠️ No generator found for document type: ${documentType}`);
+            logger.warn(`ℹ️ Supported document types: ${this.getRegisteredDocumentTypes().join(", ")}`);
+            throw new Error(`Unsupported document type: ${documentType}`);
+        }
+        // Validate if this strand should be processed
+        if (!generator.shouldProcess(strand)) {
+            logger.debug(`>>> Generator validation failed for ${documentType}:${strand.documentId}, skipping processing`);
+            return;
+        }
+        // Different flow for interactive vs non-interactive mode
+        if (this.interactiveManager.isInteractive()) {
+            // Interactive mode: queue strands and use debounce timer to trigger batch processing
+            logger.debug(`>>> Queueing strand for interactive processing: ${documentType}:${strand.documentId}`);
+            // Add strand to queue (will replace any existing strand for same document)
+            this.interactiveManager.queueStrand(strand);
+            // Clear any existing debounce timer for interactive processing
+            const existingTimer = this.debounceTimers.get("interactive");
+            if (existingTimer) {
+                clearTimeout(existingTimer);
+            }
+            // Set up debounce timer for batch interactive processing
+            const debounceTimer = setTimeout(async () => {
+                try {
+                    await this.interactiveManager.processQueueWithConfirmation(async (queuedStrands) => {
+                        await this.processQueuedStrands(queuedStrands);
+                    });
+                }
+                catch (error) {
+                    logger.error("❌ Error during interactive batch processing:", error);
+                }
+                finally {
+                    // Clean up the timer reference
+                    this.debounceTimers.delete("interactive");
+                }
+            }, DEFAULT_DEBOUNCE_TIME);
+            // Store the timer reference using 'interactive' key
+            this.debounceTimers.set("interactive", debounceTimer);
+        }
+        else {
+            // Non-interactive mode: use debouncing per document instance
+            // Create unique key for this specific document instance
+            const timerKey = `${documentType}:${strand.documentId}`;
+            // Clear any existing debounce timer for this document instance
+            const existingTimer = this.debounceTimers.get(timerKey);
+            if (existingTimer) {
+                clearTimeout(existingTimer);
+            }
+            // Set up new debounced generation (no interactive confirmation)
+            const debounceTimer = setTimeout(async () => {
+                try {
+                    logger.debug(`🔄 Routing document type "${documentType}" to generator (debounced)`);
+                    // Direct generation, no interactive confirmation
+                    await generator.generate(strand);
+                    logger.info(`✅ Successfully generated code for document type: ${documentType}`);
+                }
+                catch (error) {
+                    logger.error(`❌ Error generating code for document type "${documentType}":`, error);
+                    // Don't throw - let codegen continue with other documents
+                }
+                finally {
+                    // Clean up the timer reference
+                    this.debounceTimers.delete(documentType);
+                }
+            }, DEFAULT_DEBOUNCE_TIME);
+            // Store the timer reference
+            this.debounceTimers.set(timerKey, debounceTimer);
+        }
+    }
+    /**
+     * Process multiple strands in priority order (document-model types first)
+     */
+    async processQueuedStrands(queuedStrands) {
+        logger.debug(`🔄 Processing ${queuedStrands.length} queued strand(s)`);
+        // Sort by priority (document-model first to ensure dependencies exist)
+        const documentModelStrands = queuedStrands.filter((qs) => qs.strand.documentType === "powerhouse/document-model");
+        const otherStrands = queuedStrands.filter((qs) => qs.strand.documentType !== "powerhouse/document-model");
+        // Process document models first
+        for (const queuedStrand of documentModelStrands) {
+            await this.processStrand(queuedStrand.strand);
+        }
+        // Then process other document types
+        for (const queuedStrand of otherStrands) {
+            await this.processStrand(queuedStrand.strand);
+        }
+        logger.debug(`✅ Successfully processed all ${queuedStrands.length} queued strand(s)`);
+    }
+    /**
+     * Process a single strand (used internally by processQueuedStrands)
+     */
+    async processStrand(strand) {
+        const documentType = strand.documentType;
+        const generator = this.getGenerator(documentType);
+        if (!generator) {
+            logger.warn(`⚠️ No generator found for document type: ${documentType}`);
+            return;
+        }
+        try {
+            logger.debug(`🔄 Generating code for document type: ${documentType}`);
+            await generator.generate(strand);
+            logger.info(`✅ Successfully generated code for document type: ${documentType}`);
+        }
+        catch (error) {
+            logger.error(`❌ Error generating code for document type "${documentType}":`, error);
+            // Don't throw here to allow other strands to be processed
+        }
+    }
+    /**
+     * Clear all registered generators
+     */
+    clearGenerators() {
+        this.generators.clear();
+        logger.debug("🧹 Cleared all registered generators");
+    }
+    /**
+     * Get statistics about registered generators
+     */
+    getStats() {
+        return {
+            totalGenerators: this.generators.size,
+            supportedTypes: this.getRegisteredDocumentTypes(),
+        };
+    }
+    /**
+     * Set interactive mode for code generation
+     */
+    setInteractiveMode(enabled) {
+        this.interactiveManager.setInteractiveMode(enabled);
+    }
+    /**
+     * Check if interactive mode is enabled
+     */
+    isInteractiveMode() {
+        return this.interactiveManager.isInteractive();
+    }
+    /**
+     * Check if the manager is currently processing an interactive confirmation
+     */
+    isProcessingInteractive() {
+        return this.interactiveManager.isProcessing();
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { InternalTransmitterUpdate } from "document-drive";
+import { BaseDocumentGen } from "../base-document-gen.js";
+/**
+ * Generator for app documents
+ */
+export declare class AppGenerator extends BaseDocumentGen {
+    readonly supportedDocumentTypes = "powerhouse/app";
+    /**
+     * Validate if this app strand should be processed
+     */
+    shouldProcess(strand: InternalTransmitterUpdate): boolean;
+    generate(strand: InternalTransmitterUpdate): Promise<void>;
+}
+//# sourceMappingURL=app-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"app-generator.d.ts","sourceRoot":"","sources":["../../../../../processors/codegen/document-handlers/generators/app-generator.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAEhE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D;;GAEG;AACH,qBAAa,YAAa,SAAQ,eAAe;IAC/C,QAAQ,CAAC,sBAAsB,oBAAoB;IAEnD;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO;IA4BnD,QAAQ,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;CA0EjE"}