@objectstack/spec 0.8.1 → 0.9.0

package/dist/system/index.d.ts

@@ -20,6 +20,7 @@ export * from './tracing.zod';
 export * from './manifest.zod';
 export * from './plugin.zod';
 export * from './plugin-capability.zod';
+export * from './plugin-loading.zod';
 export * from './plugin-validator.zod';
 export * from './plugin-lifecycle-events.zod';
 export * from './startup-orchestrator.zod';
@@ -36,5 +37,6 @@ export * from './compliance.zod';
 export * from './masking.zod';
 export * from './notification.zod';
 export * from './change-management.zod';
+export * from './migration.zod';
 export * from './http-server.zod';
 //# sourceMappingURL=index.d.ts.map

package/dist/system/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/system/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,SAAS,CAAC;AAGxB,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAG9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AAMjC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,aAAa,CAAC;AAG5B,cAAc,qBAAqB,CAAC;AAGpC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAG9B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/system/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,SAAS,CAAC;AAGxB,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAG9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AAMjC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,aAAa,CAAC;AAG5B,cAAc,qBAAqB,CAAC;AAGpC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAG9B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAGhC,cAAc,mBAAmB,CAAC"}

package/dist/system/index.js

@@ -38,6 +38,7 @@ __exportStar(require("./tracing.zod"), exports);
 __exportStar(require("./manifest.zod"), exports);
 __exportStar(require("./plugin.zod"), exports);
 __exportStar(require("./plugin-capability.zod"), exports);
+__exportStar(require("./plugin-loading.zod"), exports);
 __exportStar(require("./plugin-validator.zod"), exports);
 __exportStar(require("./plugin-lifecycle-events.zod"), exports);
 __exportStar(require("./startup-orchestrator.zod"), exports);
@@ -64,6 +65,7 @@ __exportStar(require("./masking.zod"), exports);
 __exportStar(require("./notification.zod"), exports);
 // Change Management Protocol
 __exportStar(require("./change-management.zod"), exports);
+__exportStar(require("./migration.zod"), exports);
 // HTTP Server Protocol
 __exportStar(require("./http-server.zod"), exports);
 // Note: Auth, Identity, Policy, Role, Organization moved to @objectstack/spec/auth

package/dist/system/manifest.zod.d.ts

@@ -195,6 +195,232 @@ export declare const ManifestSchema: z.ZodObject<{
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
     extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    loading: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodDefault<z.ZodEnum<{
+            lazy: "lazy";
+            parallel: "parallel";
+            eager: "eager";
+            deferred: "deferred";
+            "on-demand": "on-demand";
+        }>>;
+        preload: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            priority: z.ZodDefault<z.ZodNumber>;
+            resources: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                metadata: "metadata";
+                code: "code";
+                dependencies: "dependencies";
+                assets: "assets";
+                services: "services";
+            }>>>;
+            conditions: z.ZodOptional<z.ZodObject<{
+                routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                deviceType: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    desktop: "desktop";
+                    mobile: "mobile";
+                    tablet: "tablet";
+                }>>>;
+                minNetworkSpeed: z.ZodOptional<z.ZodEnum<{
+                    "slow-2g": "slow-2g";
+                    "2g": "2g";
+                    "3g": "3g";
+                    "4g": "4g";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        codeSplitting: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            strategy: z.ZodDefault<z.ZodEnum<{
+                custom: "custom";
+                size: "size";
+                route: "route";
+                feature: "feature";
+            }>>;
+            chunkNaming: z.ZodDefault<z.ZodEnum<{
+                hashed: "hashed";
+                named: "named";
+                sequential: "sequential";
+            }>>;
+            maxChunkSize: z.ZodOptional<z.ZodNumber>;
+            sharedDependencies: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                minChunks: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        dynamicImport: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            mode: z.ZodDefault<z.ZodEnum<{
+                lazy: "lazy";
+                async: "async";
+                eager: "eager";
+                sync: "sync";
+            }>>;
+            prefetch: z.ZodDefault<z.ZodBoolean>;
+            preload: z.ZodDefault<z.ZodBoolean>;
+            webpackChunkName: z.ZodOptional<z.ZodString>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            retry: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                maxAttempts: z.ZodDefault<z.ZodNumber>;
+                backoffMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        initialization: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                async: "async";
+                parallel: "parallel";
+                sequential: "sequential";
+                sync: "sync";
+            }>>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            priority: z.ZodDefault<z.ZodNumber>;
+            critical: z.ZodDefault<z.ZodBoolean>;
+            retry: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                maxAttempts: z.ZodDefault<z.ZodNumber>;
+                backoffMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            healthCheckInterval: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        dependencyResolution: z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodDefault<z.ZodEnum<{
+                strict: "strict";
+                compatible: "compatible";
+                latest: "latest";
+                pinned: "pinned";
+            }>>;
+            peerDependencies: z.ZodOptional<z.ZodObject<{
+                resolve: z.ZodDefault<z.ZodBoolean>;
+                onMissing: z.ZodDefault<z.ZodEnum<{
+                    error: "error";
+                    warn: "warn";
+                    ignore: "ignore";
+                }>>;
+                onMismatch: z.ZodDefault<z.ZodEnum<{
+                    error: "error";
+                    warn: "warn";
+                    ignore: "ignore";
+                }>>;
+            }, z.core.$strip>>;
+            optionalDependencies: z.ZodOptional<z.ZodObject<{
+                load: z.ZodDefault<z.ZodBoolean>;
+                onFailure: z.ZodDefault<z.ZodEnum<{
+                    warn: "warn";
+                    ignore: "ignore";
+                }>>;
+            }, z.core.$strip>>;
+            conflictResolution: z.ZodDefault<z.ZodEnum<{
+                manual: "manual";
+                latest: "latest";
+                fail: "fail";
+                oldest: "oldest";
+            }>>;
+            circularDependencies: z.ZodDefault<z.ZodEnum<{
+                error: "error";
+                warn: "warn";
+                allow: "allow";
+            }>>;
+        }, z.core.$strip>>;
+        hotReload: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            strategy: z.ZodDefault<z.ZodEnum<{
+                full: "full";
+                partial: "partial";
+                "state-preserve": "state-preserve";
+            }>>;
+            watchPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            ignorePatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            debounceMs: z.ZodDefault<z.ZodNumber>;
+            preserveState: z.ZodDefault<z.ZodBoolean>;
+            stateSerialization: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                handler: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            hooks: z.ZodOptional<z.ZodObject<{
+                beforeReload: z.ZodOptional<z.ZodString>;
+                afterReload: z.ZodOptional<z.ZodString>;
+                onError: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        caching: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            storage: z.ZodDefault<z.ZodEnum<{
+                hybrid: "hybrid";
+                memory: "memory";
+                disk: "disk";
+                indexeddb: "indexeddb";
+            }>>;
+            keyStrategy: z.ZodDefault<z.ZodEnum<{
+                hash: "hash";
+                version: "version";
+                timestamp: "timestamp";
+            }>>;
+            ttl: z.ZodOptional<z.ZodNumber>;
+            maxSize: z.ZodOptional<z.ZodNumber>;
+            invalidateOn: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                error: "error";
+                manual: "manual";
+                "version-change": "version-change";
+                "dependency-change": "dependency-change";
+            }>>>;
+            compression: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                algorithm: z.ZodDefault<z.ZodEnum<{
+                    gzip: "gzip";
+                    brotli: "brotli";
+                    deflate: "deflate";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        sandboxing: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            isolationLevel: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                process: "process";
+                vm: "vm";
+                iframe: "iframe";
+                "web-worker": "web-worker";
+            }>>;
+            allowedCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            resourceQuotas: z.ZodOptional<z.ZodObject<{
+                maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+                maxCpuTimeMs: z.ZodOptional<z.ZodNumber>;
+                maxFileDescriptors: z.ZodOptional<z.ZodNumber>;
+                maxNetworkKBps: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            permissions: z.ZodOptional<z.ZodObject<{
+                allowedAPIs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                allowedEndpoints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                allowedEnvVars: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        monitoring: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            metrics: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                "load-time": "load-time";
+                "init-time": "init-time";
+                "memory-usage": "memory-usage";
+                "cpu-usage": "cpu-usage";
+                "api-calls": "api-calls";
+                "error-rate": "error-rate";
+                "cache-hit-rate": "cache-hit-rate";
+            }>>>;
+            samplingRate: z.ZodDefault<z.ZodNumber>;
+            reportingInterval: z.ZodDefault<z.ZodNumber>;
+            budgets: z.ZodOptional<z.ZodObject<{
+                maxLoadTimeMs: z.ZodOptional<z.ZodNumber>;
+                maxInitTimeMs: z.ZodOptional<z.ZodNumber>;
+                maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            onBudgetViolation: z.ZodDefault<z.ZodEnum<{
+                error: "error";
+                warn: "warn";
+                ignore: "ignore";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * TypeScript type inferred from the ManifestSchema.

package/dist/system/manifest.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.zod.d.ts","sourceRoot":"","sources":["../../src/system/manifest.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+LzB,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}
+{"version":3,"file":"manifest.zod.d.ts","sourceRoot":"","sources":["../../src/system/manifest.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuMzB,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/system/manifest.zod.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManifestSchema = void 0;
 const zod_1 = require("zod");
 const plugin_capability_zod_1 = require("./plugin-capability.zod");
+const plugin_loading_zod_1 = require("./plugin-loading.zod");
 /**
  * Schema for the ObjectStack Manifest.
  * This defines the structure of a package configuration in the ObjectStack ecosystem.
@@ -178,4 +179,11 @@ exports.ManifestSchema = zod_1.z.object({
      * Allows packages to extend UI components, add functionality, etc.
      */
     extensions: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional().describe('Extension points and contributions'),
+    /**
+     * Plugin Loading Configuration.
+     * Configures how the plugin is loaded, initialized, and managed at runtime.
+     * Includes strategies for lazy loading, code splitting, caching, and hot reload.
+     */
+    loading: plugin_loading_zod_1.PluginLoadingConfigSchema.optional()
+        .describe('Plugin loading and runtime behavior configuration'),
 });

package/dist/system/message-queue.zod.d.ts

@@ -28,8 +28,8 @@ export type TopicConfig = z.infer<typeof TopicConfigSchema>;
 export declare const ConsumerConfigSchema: z.ZodObject<{
     groupId: z.ZodString;
     autoOffsetReset: z.ZodDefault<z.ZodEnum<{
-        earliest: "earliest";
         latest: "latest";
+        earliest: "earliest";
     }>>;
     enableAutoCommit: z.ZodDefault<z.ZodBoolean>;
     maxPollRecords: z.ZodDefault<z.ZodNumber>;
@@ -65,8 +65,8 @@ export declare const MessageQueueConfigSchema: z.ZodObject<{
     consumers: z.ZodOptional<z.ZodArray<z.ZodObject<{
         groupId: z.ZodString;
         autoOffsetReset: z.ZodDefault<z.ZodEnum<{
-            earliest: "earliest";
             latest: "latest";
+            earliest: "earliest";
         }>>;
         enableAutoCommit: z.ZodDefault<z.ZodBoolean>;
         maxPollRecords: z.ZodDefault<z.ZodNumber>;

package/dist/system/metadata-loader.zod.d.ts

@@ -87,9 +87,9 @@ export declare const MetadataExportOptionsSchema: z.ZodObject<{
 export declare const MetadataImportOptionsSchema: z.ZodObject<{
     conflictResolution: z.ZodDefault<z.ZodEnum<{
         skip: "skip";
+        fail: "fail";
         overwrite: "overwrite";
         merge: "merge";
-        fail: "fail";
     }>>;
     validate: z.ZodDefault<z.ZodBoolean>;
     dryRun: z.ZodDefault<z.ZodBoolean>;