@semiont/frontend 0.3.4 → 0.3.5

package/standalone/apps/frontend/.next/server/chunks/3144.js

@@ -21,12 +21,10 @@ exports.modules = {
 /* harmony export */   q$: () => (/* binding */ getFragmentSelector),
 /* harmony export */   zI: () => (/* binding */ cloneToken)
 /* harmony export */ });
-/* unused harmony exports APIError, CORE_TYPES_VERSION, CREATION_METHODS, ConfigurationError, ConflictError, NotFoundError, SDK_VERSION, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, annotationUri, applyBodyOperations, assembleAnnotation, authCode, burstBuffer, createConfigLoader, deepMerge, didToAgent, displayConfiguration, email, findBodyItem, formatErrors, generateUuid, getAllPlatformTypes, getEventType, getNodeEnvForEnvironment, googleCredential, hasAWSConfig, isAnnotationId, isArray, isBoolean, isDefined, isEventRelatedToAnnotation, isFunction, isNull, isNullish, isNumber, isObject, isResourceEvent, isResourceId, isResourceScopedEvent, isStoredEvent, isString, isSystemEvent, isUndefined, isValidPlatformType, jobId, listEnvironmentNames, mcpToken, parseAndMergeConfigs, parseEnvironment, refreshToken, resolveEnvVars, resourceAnnotationUri, resourceUri, userId, userToAgent, userToDid, validateEnvironment, validateEnvironmentConfig, validateSemiontConfig, validateSiteConfig, validateSvgMarkup */
+/* unused harmony exports APIError, CORE_TYPES_VERSION, CREATION_METHODS, ConfigurationError, ConflictError, NotFoundError, SDK_VERSION, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, annotationUri, applyBodyOperations, assembleAnnotation, authCode, burstBuffer, createTomlConfigLoader, didToAgent, email, findBodyItem, generateUuid, getAllPlatformTypes, getEventType, googleCredential, isAnnotationId, isArray, isBoolean, isDefined, isEventRelatedToAnnotation, isFunction, isNull, isNullish, isNumber, isObject, isResourceEvent, isResourceId, isResourceScopedEvent, isStoredEvent, isString, isSystemEvent, isUndefined, isValidPlatformType, jobId, loadTomlConfig, mcpToken, parseEnvironment, refreshToken, resourceAnnotationUri, resourceUri, userId, userToAgent, userToDid, validateEnvironment, validateSvgMarkup */
 /* harmony import */ var _barrel_optimize_names_Observable_Subject_rxjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6476);
 /* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(55511);
-/* harmony import */ var ajv__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(27102);
-/* harmony import */ var ajv_formats__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7642);
-
+/* harmony import */ var smol_toml__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(45419);
 
 
 
@@ -594,6 +592,276 @@ function didToAgent(did) {
         name: userId2
     };
 }
+function deepMerge(base, override) {
+    const result = {
+        ...base
+    };
+    for (const key of Object.keys(override)){
+        const b = base[key];
+        const o = override[key];
+        if (o !== void 0 && o !== null && typeof o === "object" && !Array.isArray(o) && b !== void 0 && b !== null && typeof b === "object" && !Array.isArray(b)) {
+            result[key] = deepMerge(b, o);
+        } else if (o !== void 0) {
+            result[key] = o;
+        }
+    }
+    return result;
+}
+function resolveEnvVars(obj, env) {
+    if (typeof obj === "string") {
+        return obj.replace(/\$\{([^}]+)\}/g, (match, varName)=>{
+            if (env[varName] === void 0) {
+                throw new Error(`Environment variable ${varName} is not set (referenced in config as ${match})`);
+            }
+            return env[varName];
+        });
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item)=>resolveEnvVars(item, env));
+    }
+    if (obj !== null && typeof obj === "object") {
+        const resolved = {};
+        for(const key in obj){
+            resolved[key] = resolveEnvVars(obj[key], env);
+        }
+        return resolved;
+    }
+    return obj;
+}
+function requirePlatform(value, serviceName) {
+    if (!value) {
+        throw new Error(`platform is required for service '${serviceName}' \u2014 add 'platform = "posix"|"container"|"external"' to its config section`);
+    }
+    return value;
+}
+function loadTomlConfig(projectRoot, environment, globalConfigPath, reader, env) {
+    const projectConfigContent = reader.readIfExists(`${projectRoot}/.semiont/config`);
+    let projectName = "semiont-project";
+    let projectSite;
+    let projectEnvSection = {};
+    if (projectConfigContent) {
+        const projectConfig = parse(projectConfigContent);
+        projectName = projectConfig.project?.name ?? projectName;
+        projectSite = projectConfig.site;
+        projectEnvSection = projectConfig.environments?.[environment] ?? {};
+    }
+    const globalContent = reader.readIfExists(globalConfigPath);
+    const raw = globalContent ? parse(globalContent) : {};
+    const userEnvSection = raw.environments?.[environment] ?? {};
+    const envSection = deepMerge(projectEnvSection, userEnvSection);
+    const resolved = resolveEnvVars(envSection, env);
+    const flatInference = resolved.inference;
+    const makeMeaningSection = resolved["make-meaning"];
+    const workersSection = resolved.workers ?? {};
+    const actorsSection = resolved.actors ?? {};
+    const defaultWorkerInference = workersSection["default"]?.inference;
+    const defaultMakeMeaningInference = makeMeaningSection?.default?.inference;
+    function mergeWithFlatInference(specific) {
+        if (!flatInference) return specific;
+        return {
+            apiKey: flatInference.apiKey,
+            maxTokens: flatInference.maxTokens,
+            endpoint: flatInference.endpoint,
+            baseURL: flatInference.baseURL,
+            ...specific
+        };
+    }
+    function resolveActorInference(fromMakeMeaning, fromActors) {
+        const base = fromMakeMeaning ?? fromActors ?? defaultMakeMeaningInference;
+        if (!base) return void 0;
+        return mergeWithFlatInference(base);
+    }
+    const actors = {};
+    const gathererInference = resolveActorInference(makeMeaningSection?.actors?.gatherer?.inference, actorsSection["gatherer"]?.inference);
+    if (gathererInference) actors.gatherer = gathererInference;
+    const matcherInference = resolveActorInference(makeMeaningSection?.actors?.matcher?.inference, actorsSection["matcher"]?.inference);
+    if (matcherInference) actors.matcher = matcherInference;
+    const workers = {};
+    const workerTypes = [
+        "reference-annotation",
+        "highlight-annotation",
+        "assessment-annotation",
+        "comment-annotation",
+        "tag-annotation",
+        "generation"
+    ];
+    if (defaultWorkerInference) {
+        workers.default = mergeWithFlatInference(defaultWorkerInference);
+    }
+    for (const wt of workerTypes){
+        const specific = workersSection[wt]?.inference;
+        if (specific) {
+            workers[wt] = mergeWithFlatInference(specific);
+        }
+    }
+    const backend = resolved.backend;
+    const site = resolved.site ?? projectSite;
+    const inferenceSection = resolved.inference;
+    let inferenceProviders;
+    if (inferenceSection) {
+        inferenceProviders = {};
+        if (inferenceSection.type === "anthropic") {
+            inferenceProviders.anthropic = {
+                platform: requirePlatform(inferenceSection.platform, "inference"),
+                endpoint: inferenceSection.endpoint ?? "https://api.anthropic.com",
+                apiKey: inferenceSection.apiKey ?? ""
+            };
+        } else if (inferenceSection.type === "ollama") {
+            inferenceProviders.ollama = {
+                platform: {
+                    type: requirePlatform(inferenceSection.platform, "inference")
+                },
+                baseURL: inferenceSection.baseURL,
+                port: inferenceSection.baseURL ? void 0 : 11434
+            };
+        }
+    }
+    const topLevelWorkers = {};
+    for (const [name, w] of Object.entries(workersSection)){
+        if (w.inference) {
+            topLevelWorkers[name] = {
+                inference: {
+                    type: w.inference.type,
+                    model: w.inference.model
+                }
+            };
+        }
+    }
+    const topLevelActors = {};
+    for (const [name, a] of Object.entries(actorsSection)){
+        if (a.inference) {
+            topLevelActors[name] = {
+                inference: {
+                    type: a.inference.type,
+                    model: a.inference.model
+                }
+            };
+        }
+    }
+    if (makeMeaningSection?.actors?.gatherer?.inference) {
+        topLevelActors["gatherer"] = {
+            inference: {
+                type: makeMeaningSection.actors.gatherer.inference.type,
+                model: makeMeaningSection.actors.gatherer.inference.model
+            }
+        };
+    }
+    if (makeMeaningSection?.actors?.matcher?.inference) {
+        topLevelActors["matcher"] = {
+            inference: {
+                type: makeMeaningSection.actors.matcher.inference.type,
+                model: makeMeaningSection.actors.matcher.inference.model
+            }
+        };
+    }
+    const frontend = resolved.frontend;
+    const proxy = resolved.proxy;
+    const config = {
+        services: {
+            backend: backend ? {
+                platform: {
+                    type: requirePlatform(backend.platform, "backend")
+                },
+                port: backend.port ?? 4e3,
+                publicURL: backend.publicURL ?? `http://localhost:${backend.port ?? 4e3}`,
+                corsOrigin: backend.corsOrigin ?? backend.frontendURL ?? "http://localhost:3000"
+            } : void 0,
+            frontend: frontend ? {
+                platform: {
+                    type: requirePlatform(frontend.platform, "frontend")
+                },
+                port: frontend.port ?? 3e3,
+                siteName: site?.siteName ?? "Semiont",
+                publicURL: frontend.publicURL
+            } : void 0,
+            proxy: proxy ? {
+                platform: {
+                    type: requirePlatform(proxy.platform, "proxy")
+                },
+                type: "envoy",
+                port: proxy.port ?? 8080,
+                adminPort: proxy.adminPort ?? 9901,
+                backendPort: backend?.port ?? 4e3,
+                frontendPort: frontend?.port ?? 3e3
+            } : void 0,
+            graph: resolved.graph ? {
+                ...resolved.graph,
+                platform: {
+                    type: requirePlatform(resolved.graph.platform, "graph")
+                },
+                type: resolved.graph.type ?? "neo4j"
+            } : makeMeaningSection?.graph,
+            database: resolved.database ? {
+                platform: {
+                    type: requirePlatform(resolved.database.platform, "database")
+                },
+                type: "postgres",
+                image: resolved.database.image,
+                host: resolved.database.host ?? "localhost",
+                port: resolved.database.port ?? 5432,
+                name: resolved.database.name,
+                user: resolved.database.user,
+                password: resolved.database.password
+            } : void 0
+        },
+        ...inferenceProviders ? {
+            inference: inferenceProviders
+        } : {},
+        ...Object.keys(topLevelWorkers).length > 0 ? {
+            workers: topLevelWorkers
+        } : {},
+        ...Object.keys(topLevelActors).length > 0 ? {
+            actors: topLevelActors
+        } : {},
+        site: site ? {
+            domain: site.domain ?? "localhost",
+            siteName: site.siteName,
+            adminEmail: site.adminEmail,
+            oauthAllowedDomains: site.oauthAllowedDomains
+        } : void 0,
+        logLevel: resolved.logLevel,
+        _metadata: {
+            environment,
+            projectRoot,
+            projectName,
+            ...Object.keys(actors).length > 0 ? {
+                actors
+            } : {},
+            ...Object.keys(workers).length > 0 ? {
+                workers
+            } : {}
+        }
+    };
+    return config;
+}
+function createTomlConfigLoader(reader, globalConfigPath, env) {
+    return (projectRoot, environment)=>{
+        return loadTomlConfig(projectRoot, environment, globalConfigPath, reader, env);
+    };
+}
+// src/config/environment-validator.ts
+function isValidEnvironment(value, availableEnvironments) {
+    if (!value) return false;
+    return availableEnvironments.includes(value);
+}
+function parseEnvironment(value, availableEnvironments) {
+    if (!value) {
+        throw new Error("Environment is required");
+    }
+    if (!isValidEnvironment(value, availableEnvironments)) {
+        throw new Error(`Invalid environment: ${value}. Available environments: ${availableEnvironments.join(", ")}`);
+    }
+    return value;
+}
+function validateEnvironment(value, availableEnvironments) {
+    if (!value) {
+        throw new Error("Environment is required");
+    }
+    if (!isValidEnvironment(value, availableEnvironments)) {
+        throw new Error(`Invalid environment: ${value}. Available environments: ${availableEnvironments.join(", ")}`);
+    }
+    return value;
+}
 // src/config/configuration-error.ts
 var ConfigurationError = class extends Error {
     constructor(message, environment, suggestion, cause){
@@ -618,1832 +886,6 @@ var ConfigurationError = class extends Error {
         return output;
     }
 };
-// src/config/config.schema.json
-var config_schema_default = {
-    $schema: "http://json-schema.org/draft-07/schema#",
-    $id: "https://semiont.org/schemas/config.json",
-    definitions: {
-        PlatformType: {
-            type: "string",
-            enum: [
-                "posix",
-                "container",
-                "aws",
-                "external"
-            ]
-        },
-        ServicePlatformConfig: {
-            type: "object",
-            properties: {
-                type: {
-                    $ref: "#/definitions/PlatformType"
-                }
-            },
-            required: [
-                "type"
-            ]
-        },
-        ResourceRequirements: {
-            type: "object",
-            properties: {
-                cpu: {
-                    type: "string"
-                },
-                memory: {
-                    type: "string"
-                },
-                gpu: {
-                    type: "integer"
-                },
-                gpus: {
-                    type: "integer"
-                },
-                replicas: {
-                    type: "integer"
-                },
-                ephemeralStorage: {
-                    type: "string"
-                },
-                memoryReservation: {
-                    type: "string"
-                }
-            },
-            additionalProperties: false
-        },
-        SecurityRequirements: {
-            type: "object",
-            properties: {
-                readOnlyRootFilesystem: {
-                    type: "boolean"
-                },
-                runAsNonRoot: {
-                    type: "boolean"
-                },
-                runAsUser: {
-                    type: "integer"
-                },
-                runAsGroup: {
-                    type: "integer"
-                },
-                capabilities: {
-                    oneOf: [
-                        {
-                            type: "array",
-                            items: {
-                                type: "string"
-                            }
-                        },
-                        {
-                            type: "object",
-                            properties: {
-                                add: {
-                                    type: "array",
-                                    items: {
-                                        type: "string"
-                                    }
-                                },
-                                drop: {
-                                    type: "array",
-                                    items: {
-                                        type: "string"
-                                    }
-                                }
-                            }
-                        }
-                    ]
-                },
-                privileged: {
-                    type: "boolean"
-                },
-                allowPrivilegeEscalation: {
-                    type: "boolean"
-                }
-            },
-            additionalProperties: false
-        },
-        BuildRequirements: {
-            type: "object",
-            properties: {
-                dockerfile: {
-                    type: "string"
-                },
-                buildContext: {
-                    type: "string"
-                },
-                buildArgs: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                buildTarget: {
-                    type: "string"
-                },
-                prebuilt: {
-                    type: "boolean"
-                },
-                noCache: {
-                    type: "boolean"
-                }
-            },
-            additionalProperties: false
-        },
-        BackendServiceConfig: {
-            type: "object",
-            properties: {
-                platform: {
-                    $ref: "#/definitions/ServicePlatformConfig"
-                },
-                devMode: {
-                    type: "boolean"
-                },
-                command: {
-                    type: "string"
-                },
-                port: {
-                    type: "integer"
-                },
-                publicURL: {
-                    type: "string"
-                },
-                corsOrigin: {
-                    type: "string"
-                },
-                image: {
-                    type: "string"
-                },
-                cpu: {
-                    type: "string"
-                },
-                memory: {
-                    type: "string"
-                },
-                semiontRepo: {
-                    type: "string"
-                },
-                databaseUrl: {
-                    type: "string"
-                },
-                projectRoot: {
-                    type: "string"
-                },
-                timeout: {
-                    type: "integer"
-                },
-                wait: {
-                    type: "integer"
-                },
-                logsEndpoint: {
-                    type: "string"
-                },
-                tag: {
-                    type: "string"
-                },
-                resources: {
-                    $ref: "#/definitions/ResourceRequirements"
-                },
-                security: {
-                    $ref: "#/definitions/SecurityRequirements"
-                },
-                build: {
-                    oneOf: [
-                        {
-                            type: "boolean"
-                        },
-                        {
-                            $ref: "#/definitions/BuildRequirements"
-                        }
-                    ]
-                },
-                dockerfile: {
-                    type: "string"
-                },
-                buildContext: {
-                    type: "string"
-                },
-                buildArgs: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                buildTarget: {
-                    type: "string"
-                },
-                prebuilt: {
-                    type: "boolean"
-                },
-                noCache: {
-                    type: "boolean"
-                },
-                secrets: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                labels: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                annotations: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                dependencies: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                externalDependencies: {
-                    type: "array",
-                    items: {
-                        oneOf: [
-                            {
-                                type: "string"
-                            },
-                            {
-                                type: "object",
-                                properties: {
-                                    name: {
-                                        type: "string"
-                                    },
-                                    url: {
-                                        type: "string"
-                                    },
-                                    required: {
-                                        type: "boolean"
-                                    },
-                                    healthCheck: {
-                                        type: "string"
-                                    }
-                                }
-                            }
-                        ]
-                    }
-                },
-                redisUrl: {
-                    type: "string"
-                },
-                environment: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                env: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                }
-            },
-            required: [
-                "platform",
-                "port",
-                "publicURL",
-                "corsOrigin"
-            ],
-            additionalProperties: false
-        },
-        FrontendServiceConfig: {
-            type: "object",
-            properties: {
-                platform: {
-                    $ref: "#/definitions/ServicePlatformConfig"
-                },
-                devMode: {
-                    type: "boolean"
-                },
-                command: {
-                    type: "string"
-                },
-                port: {
-                    type: "integer"
-                },
-                siteName: {
-                    type: "string"
-                },
-                image: {
-                    type: "string"
-                },
-                semiontRepo: {
-                    type: "string"
-                },
-                projectRoot: {
-                    type: "string"
-                },
-                databaseUrl: {
-                    type: "string"
-                },
-                timeout: {
-                    type: "integer"
-                },
-                wait: {
-                    type: "integer"
-                },
-                logsEndpoint: {
-                    type: "string"
-                },
-                tag: {
-                    type: "string"
-                },
-                resources: {
-                    $ref: "#/definitions/ResourceRequirements"
-                },
-                security: {
-                    $ref: "#/definitions/SecurityRequirements"
-                },
-                build: {
-                    oneOf: [
-                        {
-                            type: "boolean"
-                        },
-                        {
-                            $ref: "#/definitions/BuildRequirements"
-                        }
-                    ]
-                },
-                dockerfile: {
-                    type: "string"
-                },
-                buildContext: {
-                    type: "string"
-                },
-                buildArgs: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                buildTarget: {
-                    type: "string"
-                },
-                prebuilt: {
-                    type: "boolean"
-                },
-                noCache: {
-                    type: "boolean"
-                },
-                secrets: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                labels: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                annotations: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                dependencies: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                externalDependencies: {
-                    type: "array",
-                    items: {
-                        oneOf: [
-                            {
-                                type: "string"
-                            },
-                            {
-                                type: "object",
-                                properties: {
-                                    name: {
-                                        type: "string"
-                                    },
-                                    url: {
-                                        type: "string"
-                                    },
-                                    required: {
-                                        type: "boolean"
-                                    },
-                                    healthCheck: {
-                                        type: "string"
-                                    }
-                                }
-                            }
-                        ]
-                    }
-                },
-                environment: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                env: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                publicURL: {
-                    type: "string"
-                },
-                allowedOrigins: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                }
-            },
-            required: [
-                "platform",
-                "port",
-                "siteName"
-            ],
-            additionalProperties: false
-        },
-        ProxyServiceConfig: {
-            type: "object",
-            properties: {
-                platform: {
-                    $ref: "#/definitions/ServicePlatformConfig"
-                },
-                type: {
-                    type: "string",
-                    enum: [
-                        "envoy",
-                        "nginx",
-                        "haproxy"
-                    ],
-                    default: "envoy"
-                },
-                port: {
-                    type: "integer",
-                    default: 8080
-                },
-                adminPort: {
-                    type: "integer",
-                    default: 9901
-                },
-                backendPort: {
-                    type: "integer",
-                    default: 4e3
-                },
-                frontendPort: {
-                    type: "integer",
-                    default: 3e3
-                },
-                image: {
-                    type: "string",
-                    default: "envoyproxy/envoy:v1.28-latest"
-                },
-                configPath: {
-                    type: "string"
-                },
-                timeout: {
-                    type: "integer"
-                },
-                wait: {
-                    type: "integer"
-                },
-                logsEndpoint: {
-                    type: "string"
-                },
-                tag: {
-                    type: "string"
-                },
-                resources: {
-                    $ref: "#/definitions/ResourceRequirements"
-                },
-                security: {
-                    $ref: "#/definitions/SecurityRequirements"
-                },
-                environment: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                env: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                }
-            },
-            required: [
-                "platform",
-                "type",
-                "port"
-            ],
-            additionalProperties: false
-        },
-        DatabaseServiceConfig: {
-            type: "object",
-            properties: {
-                platform: {
-                    $ref: "#/definitions/ServicePlatformConfig"
-                },
-                type: {
-                    type: "string"
-                },
-                name: {
-                    type: "string"
-                },
-                host: {
-                    type: "string"
-                },
-                port: {
-                    type: "integer"
-                },
-                environment: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                env: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                description: {
-                    type: "string"
-                },
-                command: {
-                    type: "string"
-                },
-                image: {
-                    type: "string"
-                },
-                user: {
-                    type: "string"
-                },
-                username: {
-                    type: "string"
-                },
-                password: {
-                    type: "string"
-                },
-                database: {
-                    type: "string"
-                },
-                storageSize: {
-                    type: "string"
-                },
-                timeout: {
-                    type: "integer"
-                },
-                wait: {
-                    type: "integer"
-                },
-                logsEndpoint: {
-                    type: "string"
-                },
-                tag: {
-                    type: "string"
-                },
-                resources: {
-                    $ref: "#/definitions/ResourceRequirements"
-                },
-                security: {
-                    $ref: "#/definitions/SecurityRequirements"
-                },
-                build: {
-                    oneOf: [
-                        {
-                            type: "boolean"
-                        },
-                        {
-                            $ref: "#/definitions/BuildRequirements"
-                        }
-                    ]
-                },
-                dockerfile: {
-                    type: "string"
-                },
-                buildContext: {
-                    type: "string"
-                },
-                buildArgs: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                buildTarget: {
-                    type: "string"
-                },
-                prebuilt: {
-                    type: "boolean"
-                },
-                noCache: {
-                    type: "boolean"
-                },
-                secrets: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                labels: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                annotations: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                dependencies: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                externalDependencies: {
-                    type: "array",
-                    items: {
-                        oneOf: [
-                            {
-                                type: "string"
-                            },
-                            {
-                                type: "object",
-                                properties: {
-                                    name: {
-                                        type: "string"
-                                    },
-                                    url: {
-                                        type: "string"
-                                    },
-                                    required: {
-                                        type: "boolean"
-                                    },
-                                    healthCheck: {
-                                        type: "string"
-                                    }
-                                }
-                            }
-                        ]
-                    }
-                }
-            },
-            required: [
-                "platform",
-                "type",
-                "host",
-                "port"
-            ],
-            additionalProperties: false
-        },
-        GraphDatabaseType: {
-            type: "string",
-            enum: [
-                "neo4j",
-                "janusgraph",
-                "neptune",
-                "memory"
-            ]
-        },
-        GraphServiceConfig: {
-            type: "object",
-            properties: {
-                platform: {
-                    $ref: "#/definitions/ServicePlatformConfig"
-                },
-                type: {
-                    $ref: "#/definitions/GraphDatabaseType"
-                },
-                name: {
-                    type: "string"
-                },
-                uri: {
-                    type: "string"
-                },
-                url: {
-                    type: "string"
-                },
-                username: {
-                    type: "string"
-                },
-                password: {
-                    type: "string"
-                },
-                database: {
-                    type: "string"
-                },
-                host: {
-                    type: "string"
-                },
-                port: {
-                    type: "integer"
-                },
-                storage: {
-                    type: "string"
-                },
-                index: {
-                    type: "string"
-                },
-                endpoint: {
-                    type: "string"
-                },
-                region: {
-                    type: "string"
-                },
-                command: {
-                    type: "string"
-                },
-                image: {
-                    type: "string"
-                },
-                janusgraphVersion: {
-                    type: "string"
-                },
-                javaOptions: {
-                    type: "string"
-                },
-                heapSize: {
-                    type: "string"
-                },
-                pageCacheSize: {
-                    type: "string"
-                },
-                noAuth: {
-                    type: "boolean"
-                },
-                dataPath: {
-                    type: "string"
-                },
-                timeout: {
-                    type: "integer"
-                },
-                wait: {
-                    type: "integer"
-                },
-                logsEndpoint: {
-                    type: "string"
-                },
-                tag: {
-                    type: "string"
-                },
-                resources: {
-                    $ref: "#/definitions/ResourceRequirements"
-                },
-                security: {
-                    $ref: "#/definitions/SecurityRequirements"
-                },
-                build: {
-                    oneOf: [
-                        {
-                            type: "boolean"
-                        },
-                        {
-                            $ref: "#/definitions/BuildRequirements"
-                        }
-                    ]
-                },
-                dockerfile: {
-                    type: "string"
-                },
-                buildContext: {
-                    type: "string"
-                },
-                buildArgs: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                buildTarget: {
-                    type: "string"
-                },
-                prebuilt: {
-                    type: "boolean"
-                },
-                noCache: {
-                    type: "boolean"
-                },
-                secrets: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                labels: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                annotations: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                dependencies: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                externalDependencies: {
-                    type: "array",
-                    items: {
-                        oneOf: [
-                            {
-                                type: "string"
-                            },
-                            {
-                                type: "object",
-                                properties: {
-                                    name: {
-                                        type: "string"
-                                    },
-                                    url: {
-                                        type: "string"
-                                    },
-                                    required: {
-                                        type: "boolean"
-                                    },
-                                    healthCheck: {
-                                        type: "string"
-                                    }
-                                }
-                            }
-                        ]
-                    }
-                },
-                environment: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                env: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                }
-            },
-            required: [
-                "platform",
-                "type"
-            ],
-            allOf: [
-                {
-                    if: {
-                        properties: {
-                            type: {
-                                const: "neo4j"
-                            }
-                        }
-                    },
-                    then: {
-                        required: [
-                            "uri",
-                            "username",
-                            "password",
-                            "database"
-                        ]
-                    }
-                }
-            ],
-            additionalProperties: false
-        },
-        FilesystemServiceConfig: {
-            type: "object",
-            properties: {
-                platform: {
-                    $ref: "#/definitions/ServicePlatformConfig"
-                },
-                path: {
-                    type: "string"
-                },
-                description: {
-                    type: "string"
-                },
-                command: {
-                    type: "string"
-                },
-                image: {
-                    type: "string"
-                },
-                port: {
-                    type: "integer"
-                },
-                timeout: {
-                    type: "integer"
-                },
-                wait: {
-                    type: "integer"
-                },
-                logsEndpoint: {
-                    type: "string"
-                },
-                tag: {
-                    type: "string"
-                },
-                resources: {
-                    $ref: "#/definitions/ResourceRequirements"
-                },
-                security: {
-                    $ref: "#/definitions/SecurityRequirements"
-                },
-                build: {
-                    oneOf: [
-                        {
-                            type: "boolean"
-                        },
-                        {
-                            $ref: "#/definitions/BuildRequirements"
-                        }
-                    ]
-                },
-                dockerfile: {
-                    type: "string"
-                },
-                buildContext: {
-                    type: "string"
-                },
-                buildArgs: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                buildTarget: {
-                    type: "string"
-                },
-                prebuilt: {
-                    type: "boolean"
-                },
-                noCache: {
-                    type: "boolean"
-                },
-                secrets: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                labels: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                annotations: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                dependencies: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                externalDependencies: {
-                    type: "array",
-                    items: {
-                        oneOf: [
-                            {
-                                type: "string"
-                            },
-                            {
-                                type: "object",
-                                properties: {
-                                    name: {
-                                        type: "string"
-                                    },
-                                    url: {
-                                        type: "string"
-                                    },
-                                    required: {
-                                        type: "boolean"
-                                    },
-                                    healthCheck: {
-                                        type: "string"
-                                    }
-                                }
-                            }
-                        ]
-                    }
-                },
-                environment: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                env: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                }
-            },
-            required: [
-                "platform",
-                "path"
-            ],
-            additionalProperties: false
-        },
-        InferenceServiceConfig: {
-            type: "object",
-            properties: {
-                platform: {
-                    $ref: "#/definitions/ServicePlatformConfig"
-                },
-                type: {
-                    type: "string"
-                },
-                model: {
-                    type: "string"
-                },
-                maxTokens: {
-                    type: "integer"
-                },
-                endpoint: {
-                    type: "string"
-                },
-                baseURL: {
-                    type: "string"
-                },
-                apiKey: {
-                    type: "string"
-                },
-                command: {
-                    type: "string"
-                },
-                image: {
-                    type: "string"
-                },
-                port: {
-                    type: "integer"
-                },
-                organization: {
-                    type: "string"
-                },
-                timeout: {
-                    type: "integer"
-                },
-                wait: {
-                    type: "integer"
-                },
-                logsEndpoint: {
-                    type: "string"
-                },
-                tag: {
-                    type: "string"
-                },
-                resources: {
-                    $ref: "#/definitions/ResourceRequirements"
-                },
-                security: {
-                    $ref: "#/definitions/SecurityRequirements"
-                },
-                build: {
-                    oneOf: [
-                        {
-                            type: "boolean"
-                        },
-                        {
-                            $ref: "#/definitions/BuildRequirements"
-                        }
-                    ]
-                },
-                dockerfile: {
-                    type: "string"
-                },
-                buildContext: {
-                    type: "string"
-                },
-                buildArgs: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                buildTarget: {
-                    type: "string"
-                },
-                prebuilt: {
-                    type: "boolean"
-                },
-                noCache: {
-                    type: "boolean"
-                },
-                secrets: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                labels: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                annotations: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                dependencies: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                externalDependencies: {
-                    type: "array",
-                    items: {
-                        oneOf: [
-                            {
-                                type: "string"
-                            },
-                            {
-                                type: "object",
-                                properties: {
-                                    name: {
-                                        type: "string"
-                                    },
-                                    url: {
-                                        type: "string"
-                                    },
-                                    required: {
-                                        type: "boolean"
-                                    },
-                                    healthCheck: {
-                                        type: "string"
-                                    }
-                                }
-                            }
-                        ]
-                    }
-                },
-                environment: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                env: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                }
-            },
-            required: [
-                "platform",
-                "type",
-                "apiKey"
-            ],
-            additionalProperties: false
-        },
-        McpServiceConfig: {
-            type: "object",
-            properties: {
-                platform: {
-                    $ref: "#/definitions/ServicePlatformConfig"
-                },
-                command: {
-                    type: "string"
-                },
-                image: {
-                    type: "string"
-                },
-                port: {
-                    type: "integer"
-                },
-                dependsOn: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                timeout: {
-                    type: "integer"
-                },
-                wait: {
-                    type: "integer"
-                },
-                logsEndpoint: {
-                    type: "string"
-                },
-                tag: {
-                    type: "string"
-                },
-                resources: {
-                    $ref: "#/definitions/ResourceRequirements"
-                },
-                security: {
-                    $ref: "#/definitions/SecurityRequirements"
-                },
-                build: {
-                    oneOf: [
-                        {
-                            type: "boolean"
-                        },
-                        {
-                            $ref: "#/definitions/BuildRequirements"
-                        }
-                    ]
-                },
-                dockerfile: {
-                    type: "string"
-                },
-                buildContext: {
-                    type: "string"
-                },
-                buildArgs: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                buildTarget: {
-                    type: "string"
-                },
-                prebuilt: {
-                    type: "boolean"
-                },
-                noCache: {
-                    type: "boolean"
-                },
-                secrets: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                labels: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                annotations: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                dependencies: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    }
-                },
-                externalDependencies: {
-                    type: "array",
-                    items: {
-                        oneOf: [
-                            {
-                                type: "string"
-                            },
-                            {
-                                type: "object",
-                                properties: {
-                                    name: {
-                                        type: "string"
-                                    },
-                                    url: {
-                                        type: "string"
-                                    },
-                                    required: {
-                                        type: "boolean"
-                                    },
-                                    healthCheck: {
-                                        type: "string"
-                                    }
-                                }
-                            }
-                        ]
-                    }
-                },
-                environment: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                },
-                env: {
-                    type: "object",
-                    additionalProperties: {
-                        type: "string"
-                    }
-                }
-            },
-            required: [
-                "platform"
-            ],
-            additionalProperties: false
-        },
-        ServicesConfig: {
-            type: "object",
-            properties: {
-                backend: {
-                    $ref: "#/definitions/BackendServiceConfig"
-                },
-                frontend: {
-                    $ref: "#/definitions/FrontendServiceConfig"
-                },
-                database: {
-                    $ref: "#/definitions/DatabaseServiceConfig"
-                },
-                graph: {
-                    $ref: "#/definitions/GraphServiceConfig"
-                },
-                filesystem: {
-                    $ref: "#/definitions/FilesystemServiceConfig"
-                },
-                inference: {
-                    $ref: "#/definitions/InferenceServiceConfig"
-                },
-                mcp: {
-                    $ref: "#/definitions/McpServiceConfig"
-                },
-                proxy: {
-                    $ref: "#/definitions/ProxyServiceConfig"
-                }
-            },
-            additionalProperties: true
-        },
-        SiteConfig: {
-            type: "object",
-            properties: {
-                siteName: {
-                    type: "string",
-                    minLength: 1,
-                    description: "Display name for the site"
-                },
-                domain: {
-                    type: "string",
-                    minLength: 1,
-                    description: "Primary domain for the site"
-                },
-                adminEmail: {
-                    type: "string",
-                    format: "email",
-                    description: "Administrator email address"
-                },
-                supportEmail: {
-                    type: "string",
-                    format: "email",
-                    description: "Support email address (optional)"
-                },
-                oauthAllowedDomains: {
-                    type: "array",
-                    items: {
-                        type: "string"
-                    },
-                    minItems: 1,
-                    description: "Email domains allowed for OAuth authentication"
-                }
-            },
-            required: [
-                "domain"
-            ],
-            additionalProperties: false
-        },
-        AppConfig: {
-            type: "object",
-            properties: {
-                features: {
-                    type: "object",
-                    properties: {
-                        enableAnalytics: {
-                            type: "boolean"
-                        },
-                        enableMaintenanceMode: {
-                            type: "boolean"
-                        },
-                        enableDebugLogging: {
-                            type: "boolean"
-                        }
-                    },
-                    additionalProperties: false
-                },
-                security: {
-                    type: "object",
-                    properties: {
-                        sessionTimeout: {
-                            type: "integer",
-                            minimum: 60,
-                            description: "Session timeout in seconds"
-                        },
-                        maxLoginAttempts: {
-                            type: "integer",
-                            minimum: 1,
-                            description: "Maximum failed login attempts before lockout"
-                        },
-                        corsAllowedOrigins: {
-                            type: "array",
-                            items: {
-                                type: "string"
-                            }
-                        },
-                        enableLocalAuth: {
-                            type: "boolean",
-                            description: "Enable local username/password authentication"
-                        },
-                        jwtSecret: {
-                            type: "string",
-                            minLength: 32,
-                            description: "JWT signing secret (base64 encoded, 32+ bytes)"
-                        }
-                    },
-                    additionalProperties: false
-                },
-                performance: {
-                    type: "object",
-                    properties: {
-                        enableCaching: {
-                            type: "boolean"
-                        },
-                        cacheTimeout: {
-                            type: "integer",
-                            minimum: 0,
-                            description: "Cache timeout in seconds"
-                        },
-                        maxRequestSize: {
-                            type: "string",
-                            pattern: "^[0-9]+(kb|mb|gb)$",
-                            description: "Maximum request size (e.g., '10mb')"
-                        }
-                    },
-                    additionalProperties: false
-                }
-            },
-            additionalProperties: false
-        },
-        EnvironmentConfig: {
-            type: "object",
-            properties: {
-                _comment: {
-                    type: "string",
-                    description: "Optional comment for documentation"
-                },
-                _metadata: {
-                    type: "object",
-                    properties: {
-                        environment: {
-                            type: "string"
-                        },
-                        projectRoot: {
-                            type: "string"
-                        }
-                    },
-                    required: [
-                        "environment",
-                        "projectRoot"
-                    ]
-                },
-                name: {
-                    type: "string",
-                    description: "Environment name"
-                },
-                platform: {
-                    type: "object",
-                    properties: {
-                        default: {
-                            $ref: "#/definitions/PlatformType"
-                        }
-                    }
-                },
-                services: {
-                    $ref: "#/definitions/ServicesConfig"
-                },
-                site: {
-                    $ref: "#/definitions/SiteConfig"
-                },
-                app: {
-                    $ref: "#/definitions/AppConfig"
-                },
-                env: {
-                    type: "object",
-                    properties: {
-                        NODE_ENV: {
-                            type: "string",
-                            enum: [
-                                "development",
-                                "production",
-                                "test"
-                            ]
-                        }
-                    },
-                    additionalProperties: true
-                },
-                logLevel: {
-                    type: "string",
-                    enum: [
-                        "error",
-                        "warn",
-                        "info",
-                        "http",
-                        "debug"
-                    ],
-                    description: "Logging verbosity level"
-                },
-                deployment: {
-                    type: "object",
-                    properties: {
-                        imageTagStrategy: {
-                            type: "string",
-                            enum: [
-                                "mutable",
-                                "immutable",
-                                "git-hash"
-                            ]
-                        }
-                    }
-                }
-            },
-            required: [
-                "services"
-            ],
-            additionalProperties: false
-        },
-        SemiontConfig: {
-            type: "object",
-            properties: {
-                version: {
-                    type: "string",
-                    pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+$",
-                    description: "Config file version (semver)"
-                },
-                project: {
-                    type: "string",
-                    minLength: 1,
-                    description: "Project name"
-                },
-                site: {
-                    $ref: "#/definitions/SiteConfig"
-                },
-                app: {
-                    $ref: "#/definitions/AppConfig"
-                },
-                services: {
-                    $ref: "#/definitions/ServicesConfig"
-                }
-            },
-            required: [
-                "version",
-                "project",
-                "site"
-            ],
-            additionalProperties: false
-        }
-    }
-};
-// src/config/config-validator.ts
-var ajv = new ajv__WEBPACK_IMPORTED_MODULE_3__({
-    allErrors: true,
-    // Return all errors, not just the first one
-    coerceTypes: true,
-    // Coerce types (e.g., "123" -> 123)
-    removeAdditional: false,
-    // Don't remove additional properties
-    useDefaults: true,
-    // Apply default values from schema
-    strict: false
-});
-ajv_formats__WEBPACK_IMPORTED_MODULE_1__(ajv);
-ajv.addSchema(config_schema_default, "config");
-function validateSemiontConfig(data) {
-    const validate = ajv.getSchema("config#/definitions/SemiontConfig");
-    if (!validate) {
-        throw new Error("SemiontConfig schema not found");
-    }
-    const valid = validate(data);
-    if (!valid) {
-        return {
-            valid: false,
-            errors: validate.errors || null,
-            errorMessage: formatErrors(validate.errors || [])
-        };
-    }
-    return {
-        valid: true,
-        errors: null
-    };
-}
-function validateEnvironmentConfig(data) {
-    const validate = ajv.getSchema("config#/definitions/EnvironmentConfig");
-    if (!validate) {
-        throw new Error("EnvironmentConfig schema not found");
-    }
-    const valid = validate(data);
-    if (!valid) {
-        return {
-            valid: false,
-            errors: validate.errors || null,
-            errorMessage: formatErrors(validate.errors || [])
-        };
-    }
-    return {
-        valid: true,
-        errors: null
-    };
-}
-function validateSiteConfig(data) {
-    const validate = ajv.getSchema("config#/definitions/SiteConfig");
-    if (!validate) {
-        throw new Error("SiteConfig schema not found");
-    }
-    const valid = validate(data);
-    if (!valid) {
-        return {
-            valid: false,
-            errors: validate.errors || null,
-            errorMessage: formatErrors(validate.errors || [])
-        };
-    }
-    return {
-        valid: true,
-        errors: null
-    };
-}
-function formatErrors(errors) {
-    if (errors.length === 0) return "Validation failed";
-    const messages = errors.map((err)=>{
-        const path = err.instancePath || "root";
-        const message = err.message || "validation error";
-        if (err.keyword === "required" && "missingProperty" in err.params) {
-            return `Missing required property: ${err.params.missingProperty}`;
-        }
-        if (err.keyword === "type" && "type" in err.params) {
-            return `${path}: ${message} (expected ${err.params.type})`;
-        }
-        if (err.keyword === "enum" && "allowedValues" in err.params) {
-            return `${path}: must be one of [${err.params.allowedValues.join(", ")}]`;
-        }
-        if (err.keyword === "format") {
-            return `${path}: invalid format (${message})`;
-        }
-        if (err.keyword === "minLength" || err.keyword === "minItems") {
-            return `${path}: ${message}`;
-        }
-        return `${path}: ${message}`;
-    });
-    return messages.join("; ");
-}
-// src/config/environment-loader.ts
-function deepMerge(target, ...sources) {
-    if (!sources.length) return target;
-    const source = sources.shift();
-    if (isObject(target) && isObject(source)) {
-        for(const key in source){
-            if (isObject(source[key])) {
-                if (!target[key]) Object.assign(target, {
-                    [key]: {}
-                });
-                deepMerge(target[key], source[key]);
-            } else {
-                Object.assign(target, {
-                    [key]: source[key]
-                });
-            }
-        }
-    }
-    return deepMerge(target, ...sources);
-}
-function resolveEnvVars(obj, env) {
-    if (typeof obj === "string") {
-        return obj.replace(/\$\{([^}]+)\}/g, (match, varName)=>{
-            return env[varName] || match;
-        });
-    }
-    if (Array.isArray(obj)) {
-        return obj.map((item)=>resolveEnvVars(item, env));
-    }
-    if (obj && typeof obj === "object") {
-        const resolved = {};
-        for(const key in obj){
-            resolved[key] = resolveEnvVars(obj[key], env);
-        }
-        return resolved;
-    }
-    return obj;
-}
-function parseAndMergeConfigs(baseContent, envContent, env, environment, projectRoot) {
-    try {
-        let baseConfig = {};
-        if (baseContent) {
-            baseConfig = JSON.parse(baseContent);
-        }
-        const envConfig = JSON.parse(envContent);
-        const merged = deepMerge({}, {
-            site: baseConfig.site
-        }, // Site config from semiont.json
-        baseConfig.defaults || {}, // Default config from semiont.json
-        envConfig);
-        const resolved = resolveEnvVars(merged, env);
-        if (!resolved.services) {
-            resolved.services = {};
-        }
-        if (resolved.env?.NODE_ENV) {
-            const validNodeEnv = [
-                "development",
-                "production",
-                "test"
-            ];
-            if (!validNodeEnv.includes(resolved.env.NODE_ENV)) {
-                throw new ConfigurationError(`Invalid NODE_ENV value: ${resolved.env.NODE_ENV}`, environment, `NODE_ENV must be one of: ${validNodeEnv.join(", ")}`);
-            }
-        }
-        const configWithMetadata = {
-            ...resolved,
-            _metadata: {
-                environment,
-                projectRoot
-            }
-        };
-        const validationResult = validateEnvironmentConfig(configWithMetadata);
-        if (!validationResult.valid) {
-            throw new ConfigurationError(`Invalid environment configuration: ${validationResult.errorMessage}`, environment, `Fix the validation errors in your environments/${environment}.json file`);
-        }
-        return configWithMetadata;
-    } catch (error) {
-        if (error instanceof ConfigurationError) {
-            throw error;
-        }
-        if (error instanceof SyntaxError && error.message.includes("JSON")) {
-            throw new ConfigurationError(`Invalid JSON syntax in configuration file`, environment, `Check for missing commas, quotes, or brackets. Use a JSON validator to verify syntax.`);
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        throw new ConfigurationError(`Failed to parse environment configuration: ${message}`, environment, `Check the configuration files are valid JSON`);
-    }
-}
-function getNodeEnvForEnvironment(config) {
-    const nodeEnv = config.env?.NODE_ENV;
-    return nodeEnv || "development";
-}
-function listEnvironmentNames(files) {
-    return files.filter((file)=>file.endsWith(".json")).map((file)=>{
-        const lastSlash = Math.max(file.lastIndexOf("/"), file.lastIndexOf("\\"));
-        const filename = lastSlash >= 0 ? file.substring(lastSlash + 1) : file;
-        return filename.slice(0, -5);
-    }).sort();
-}
-function hasAWSConfig(config) {
-    return !!config.aws && !!config.aws.region;
-}
-function displayConfiguration(config) {
-    console.log("Environment Configuration:");
-    console.log(JSON.stringify(config, null, 2));
-}
-function createConfigLoader(reader) {
-    return (projectRoot, environment)=>{
-        const baseContent = reader.readIfExists(`${projectRoot}/semiont.json`);
-        const envContent = reader.readRequired(`${projectRoot}/environments/${environment}.json`);
-        return parseAndMergeConfigs(baseContent, envContent, process.env, environment, projectRoot);
-    };
-}
-// src/config/environment-validator.ts
-function isValidEnvironment(value, availableEnvironments) {
-    if (!value) return false;
-    return availableEnvironments.includes(value);
-}
-function parseEnvironment(value, availableEnvironments) {
-    if (!value) {
-        throw new Error("Environment is required");
-    }
-    if (!isValidEnvironment(value, availableEnvironments)) {
-        throw new Error(`Invalid environment: ${value}. Available environments: ${availableEnvironments.join(", ")}`);
-    }
-    return value;
-}
-function validateEnvironment(value, availableEnvironments) {
-    if (!value) {
-        throw new Error("Environment is required");
-    }
-    if (!isValidEnvironment(value, availableEnvironments)) {
-        throw new Error(`Invalid environment: ${value}. Available environments: ${availableEnvironments.join(", ")}`);
-    }
-    return value;
-}
 // src/config/platform-types.ts
 function isValidPlatformType(value) {
     return [
@@ -4130,22 +2572,22 @@ function getAllowedDomains() {
 /* harmony export */   iX: () => (/* binding */ useEventBus)
 /* harmony export */ });
 /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(71277);
-/* harmony import */ var _semiont_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4698);
-/* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(92692);
+/* harmony import */ var _semiont_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4698);
+/* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(92692);
 /* __next_internal_client_entry_do_not_use__ resetEventBusForTesting,EventBusProvider,useEventBus auto */ // src/contexts/EventBusContext.tsx
 
 
 
 var EventBusContext = /*#__PURE__*/ (0,react__WEBPACK_IMPORTED_MODULE_0__.createContext)(null);
-var globalEventBus = new _semiont_core__WEBPACK_IMPORTED_MODULE_1__/* .EventBus */ .l7();
+var globalEventBus = new _semiont_core__WEBPACK_IMPORTED_MODULE_2__/* .EventBus */ .l7();
 function resetEventBusForTesting() {
     globalEventBus.destroy();
-    globalEventBus = new _semiont_core__WEBPACK_IMPORTED_MODULE_1__/* .EventBus */ .l7();
+    globalEventBus = new _semiont_core__WEBPACK_IMPORTED_MODULE_2__/* .EventBus */ .l7();
     return globalEventBus;
 }
 function EventBusProvider({ children }) {
     const eventBus = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(()=>globalEventBus, []);
-    return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(EventBusContext.Provider, {
+    return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsx)(EventBusContext.Provider, {
         value: eventBus,
         children
     });