@semiont/frontend 0.3.4 → 0.3.5

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

@@ -12,8 +12,7 @@ exports.modules = {
 /* harmony export */   lv: () => (/* binding */ validateData)
 /* harmony export */ });
 /* unused harmony exports APIError, EventBusClient, LOCALES, SSEClient, SSE_STREAM_CONNECTED, buildContentCache, createCircleSvg, createPolygonSvg, createRectangleSvg, decodeRepresentation, decodeWithCharset, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findTextWithContext, formatLocaleDisplay, getAllLocaleCodes, getAnnotationExactText, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getExtensionForMimeType, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getMimeCategory, getNodeEncoding, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getStorageUri, getTargetSelector, getTargetSource, getTextQuoteSelector, hasTargetSelector, isArchived, isAssessment, isBodyResolved, isComment, isDraft, isHighlight, isImageMimeType, isPdfMimeType, isReference, isResolvedReference, isStubReference, isTag, isTextMimeType, isValidEmail, normalizeCoordinates, normalizeText, parseSvgSelector, scaleSvgToNative, validateAndCorrectOffsets, verifyPosition */
-/* harmony import */ var ky__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(30766);
-/* harmony import */ var _semiont_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(74992);
+/* harmony import */ var ky__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(30766);
 
 
 
@@ -630,7 +629,7 @@ var SemiontApiClient = class {
         const { baseUrl, timeout: timeout2 = 3e4, retry = 2, logger } = config;
         this.logger = logger;
         this.baseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-        this.http = ky__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay.create({
+        this.http = ky__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Ay.create({
             timeout: timeout2,
             retry,
             hooks: {
@@ -2580,2461 +2579,6 @@ Promise.resolve(/* import() eager */).then(__webpack_require__.bind(__webpack_re
 Promise.resolve(/* import() eager */).then(__webpack_require__.bind(__webpack_require__, 54736));
 
 
-/***/ }),
-
-/***/ 74992:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   a: () => (/* binding */ resourceId)
-/* harmony export */ });
-/* unused harmony exports APIError, CORE_TYPES_VERSION, CREATION_METHODS, ConfigurationError, ConflictError, EventBus, NotFoundError, SDK_VERSION, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseUrl, burstBuffer, cloneToken, createConfigLoader, deepMerge, didToAgent, displayConfiguration, email, entityType, findBodyItem, formatErrors, generateUuid, getAllPlatformTypes, getAnnotationUriFromEvent, getEventType, getFragmentSelector, getNodeEnvForEnvironment, getSvgSelector, getTextPositionSelector, 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, searchQuery, userDID, userId, userToAgent, userToDid, validateEnvironment, validateEnvironmentConfig, validateSemiontConfig, validateSiteConfig, validateSvgMarkup */
-/* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(55511);
-/* harmony import */ var ajv__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(54780);
-/* harmony import */ var ajv_formats__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(66788);
-
-
-
-
-// src/branded-types.ts
-function email(value) {
-    return value;
-}
-function authCode(value) {
-    return value;
-}
-function googleCredential(value) {
-    return value;
-}
-function accessToken(value) {
-    return value;
-}
-function refreshToken(value) {
-    return value;
-}
-function mcpToken(value) {
-    return value;
-}
-function cloneToken(value) {
-    return value;
-}
-function jobId(value) {
-    return value;
-}
-function userDID(value) {
-    return value;
-}
-function entityType(value) {
-    return value;
-}
-function searchQuery(value) {
-    return value;
-}
-function baseUrl(value) {
-    return value;
-}
-function resourceUri(uri) {
-    if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
-        throw new TypeError(`Expected ResourceUri, got: ${uri}`);
-    }
-    return uri;
-}
-function annotationUri(uri) {
-    if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
-        throw new TypeError(`Expected AnnotationUri, got: ${uri}`);
-    }
-    return uri;
-}
-function resourceAnnotationUri(uri) {
-    if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
-        throw new TypeError(`Expected ResourceAnnotationUri, got: ${uri}`);
-    }
-    if (!uri.includes("/resources/") || !uri.includes("/annotations/")) {
-        throw new TypeError(`Expected nested ResourceAnnotationUri format, got: ${uri}`);
-    }
-    return uri;
-}
-// src/creation-methods.ts
-var CREATION_METHODS = {
-    API: "api",
-    UPLOAD: "upload",
-    UI: "ui",
-    REFERENCE: "reference",
-    CLONE: "clone",
-    GENERATED: "generated"
-};
-// src/identifiers.ts
-function isResourceId(value) {
-    return !value.includes("/");
-}
-function isAnnotationId(value) {
-    return !value.includes("/");
-}
-function resourceId(id) {
-    if (id.includes("/")) {
-        throw new TypeError(`Expected ResourceId, got URI: ${id}`);
-    }
-    return id;
-}
-function annotationId(id) {
-    if (id.includes("/")) {
-        throw new TypeError(`Expected AnnotationId, got URI: ${id}`);
-    }
-    return id;
-}
-function userId(id) {
-    return id;
-}
-// src/events.ts
-function isResourceEvent(event) {
-    return event && typeof event.id === "string" && typeof event.timestamp === "string" && (event.resourceId === void 0 || typeof event.resourceId === "string") && // resourceId now optional
-    typeof event.type === "string" && event.type.includes(".");
-}
-function isSystemEvent(event) {
-    return event.type === "entitytype.added";
-}
-function isResourceScopedEvent(event) {
-    return !isSystemEvent(event);
-}
-function getEventType(event) {
-    return event.type;
-}
-// src/event-utils.ts
-function getAnnotationUriFromEvent(event) {
-    const eventData = event.event;
-    if (eventData.type === "annotation.added") {
-        return eventData.payload.annotation.id || null;
-    }
-    if (eventData.type === "annotation.removed" || eventData.type === "annotation.body.updated") {
-        if (eventData.payload.annotationId && eventData.resourceId) {
-            try {
-                const resourceUri2 = eventData.resourceId;
-                const baseUrl2 = resourceUri2.substring(0, resourceUri2.lastIndexOf("/resources/"));
-                return `${baseUrl2}/annotations/${eventData.payload.annotationId}`;
-            } catch (e) {
-                return null;
-            }
-        }
-    }
-    return null;
-}
-function isEventRelatedToAnnotation(event, annotationUri2) {
-    const eventAnnotationUri = getAnnotationUriFromEvent(event);
-    return eventAnnotationUri === annotationUri2;
-}
-function isResourceEvent2(event) {
-    return event && typeof event.event === "object" && typeof event.event.id === "string" && typeof event.event.timestamp === "string" && typeof event.event.resourceId === "string" && typeof event.event.type === "string" && typeof event.metadata === "object" && typeof event.metadata.sequenceNumber === "number";
-}
-var EventBus = class {
-    constructor(){
-        this.subjects = /* @__PURE__ */ new Map();
-        this.isDestroyed = false;
-    }
-    /**
-   * Get the RxJS Subject for an event
-   *
-   * Returns a typed Subject that can be used with all RxJS operators.
-   * Subjects are created lazily on first access.
-   *
-   * @param eventName - The event name
-   * @returns The RxJS Subject for this event
-   *
-   * @example
-   * ```typescript
-   * // Emit
-   * eventBus.get('beckon:hover').next({ annotationId: 'ann-1' });
-   *
-   * // Subscribe
-   * const sub = eventBus.get('beckon:hover').subscribe(handleHover);
-   *
-   * // With operators
-   * eventBus.get('beckon:hover')
-   *   .pipe(debounceTime(100), distinctUntilChanged())
-   *   .subscribe(handleHover);
-   * ```
-   */ get(eventName) {
-        if (this.isDestroyed) {
-            throw new Error(`Cannot access event '${String(eventName)}' on destroyed bus`);
-        }
-        if (!this.subjects.has(eventName)) {
-            this.subjects.set(eventName, new Subject());
-        }
-        return this.subjects.get(eventName);
-    }
-    /**
-   * Destroy the event bus and complete all subjects
-   *
-   * After calling destroy(), no new events can be emitted or subscribed to.
-   * All active subscriptions will be completed.
-   */ destroy() {
-        if (this.isDestroyed) {
-            return;
-        }
-        for (const subject of this.subjects.values()){
-            subject.complete();
-        }
-        this.subjects.clear();
-        this.isDestroyed = true;
-    }
-    /**
-   * Check if the event bus has been destroyed
-   */ get destroyed() {
-        return this.isDestroyed;
-    }
-    /**
-   * Create a resource-scoped event bus
-   *
-   * Events emitted or subscribed through the scoped bus are isolated to that resource.
-   * Internally, events are namespaced but the API remains identical to the parent bus.
-   *
-   * @param resourceId - Resource identifier to scope events to
-   * @returns A scoped event bus for this resource
-   *
-   * @example
-   * ```typescript
-   * const eventBus = new EventBus();
-   * const resource1 = eventBus.scope('resource-1');
-   * const resource2 = eventBus.scope('resource-2');
-   *
-   * // These are isolated - only resource1 subscribers will fire
-   * resource1.get('detection:progress').next({ status: 'started' });
-   * ```
-   */ scope(resourceId2) {
-        return new ScopedEventBus(this, resourceId2);
-    }
-};
-var ScopedEventBus = class _ScopedEventBus {
-    constructor(parent, scopePrefix){
-        this.parent = parent;
-        this.scopePrefix = scopePrefix;
-    }
-    /**
-   * Get the RxJS Subject for a scoped event
-   *
-   * Returns the same type as the parent bus, but events are isolated to this scope.
-   * Internally uses namespaced keys but preserves type safety.
-   *
-   * @param event - The event name
-   * @returns The RxJS Subject for this scoped event
-   */ get(event) {
-        const scopedKey = `${this.scopePrefix}:${event}`;
-        const parentSubjects = this.parent.subjects;
-        if (!parentSubjects.has(scopedKey)) {
-            parentSubjects.set(scopedKey, new Subject());
-        }
-        return parentSubjects.get(scopedKey);
-    }
-    /**
-   * Create a nested scope
-   *
-   * Allows hierarchical scoping like `resource-1:subsystem-a`
-   *
-   * @param subScope - Additional scope level
-   * @returns A nested scoped event bus
-   */ scope(subScope) {
-        return new _ScopedEventBus(this.parent, `${this.scopePrefix}:${subScope}`);
-    }
-};
-function burstBuffer(options) {
-    const { burstWindowMs, maxBatchSize, idleTimeoutMs } = options;
-    return (source)=>new Observable((subscriber)=>{
-            let mode = "passthrough";
-            let buffer = [];
-            let burstTimer = null;
-            let idleTimer = null;
-            function clearBurstTimer() {
-                if (burstTimer !== null) {
-                    clearTimeout(burstTimer);
-                    burstTimer = null;
-                }
-            }
-            function clearIdleTimer() {
-                if (idleTimer !== null) {
-                    clearTimeout(idleTimer);
-                    idleTimer = null;
-                }
-            }
-            function flush() {
-                if (buffer.length === 0) return;
-                const batch = buffer;
-                buffer = [];
-                subscriber.next(batch);
-            }
-            function startIdleTimer() {
-                clearIdleTimer();
-                idleTimer = setTimeout(()=>{
-                    idleTimer = null;
-                    mode = "passthrough";
-                }, idleTimeoutMs);
-            }
-            const subscription = source.subscribe({
-                next (value) {
-                    clearIdleTimer();
-                    if (mode === "passthrough") {
-                        subscriber.next(value);
-                        mode = "accumulating";
-                        burstTimer = setTimeout(()=>{
-                            burstTimer = null;
-                            flush();
-                            startIdleTimer();
-                        }, burstWindowMs);
-                        return;
-                    }
-                    buffer.push(value);
-                    clearBurstTimer();
-                    if (buffer.length >= maxBatchSize) {
-                        flush();
-                        startIdleTimer();
-                    } else {
-                        burstTimer = setTimeout(()=>{
-                            burstTimer = null;
-                            flush();
-                            startIdleTimer();
-                        }, burstWindowMs);
-                    }
-                },
-                error (err) {
-                    clearBurstTimer();
-                    clearIdleTimer();
-                    flush();
-                    subscriber.error(err);
-                },
-                complete () {
-                    clearBurstTimer();
-                    clearIdleTimer();
-                    flush();
-                    subscriber.complete();
-                }
-            });
-            return ()=>{
-                clearBurstTimer();
-                clearIdleTimer();
-                subscription.unsubscribe();
-            };
-        });
-}
-// src/annotation-utils.ts
-function findBodyItem(body, targetItem) {
-    if (!Array.isArray(body)) {
-        return -1;
-    }
-    for(let i = 0; i < body.length; i++){
-        const item = body[i];
-        if (typeof item === "object" && item !== null && "type" in item && "purpose" in item) {
-            const itemType = item.type;
-            const itemPurpose = item.purpose;
-            if (itemType !== targetItem.type || itemPurpose !== targetItem.purpose) {
-                continue;
-            }
-            if (targetItem.type === "TextualBody" && "value" in item) {
-                const itemValue = item.value;
-                if (itemValue === targetItem.value) {
-                    return i;
-                }
-            }
-            if (targetItem.type === "SpecificResource" && "source" in item) {
-                const itemSource = item.source;
-                if (itemSource === targetItem.source) {
-                    return i;
-                }
-            }
-        }
-    }
-    return -1;
-}
-function generateUuid() {
-    return randomBytes(16).toString("hex");
-}
-// src/annotation-assembly.ts
-function getTextPositionSelector(selector) {
-    if (!selector) return null;
-    const selectors = Array.isArray(selector) ? selector : [
-        selector
-    ];
-    const found = selectors.find((s)=>s.type === "TextPositionSelector");
-    if (!found) return null;
-    return found.type === "TextPositionSelector" ? found : null;
-}
-function getSvgSelector(selector) {
-    if (!selector) return null;
-    const selectors = Array.isArray(selector) ? selector : [
-        selector
-    ];
-    const found = selectors.find((s)=>s.type === "SvgSelector");
-    if (!found) return null;
-    return found.type === "SvgSelector" ? found : null;
-}
-function getFragmentSelector(selector) {
-    if (!selector) return null;
-    const selectors = Array.isArray(selector) ? selector : [
-        selector
-    ];
-    const found = selectors.find((s)=>s.type === "FragmentSelector");
-    if (!found) return null;
-    return found.type === "FragmentSelector" ? found : null;
-}
-function validateSvgMarkup(svg) {
-    if (!svg.includes('xmlns="http://www.w3.org/2000/svg"')) {
-        return 'SVG must include xmlns="http://www.w3.org/2000/svg" attribute';
-    }
-    if (!svg.includes("<svg") || !svg.includes("</svg>")) {
-        return "SVG must have opening and closing tags";
-    }
-    const shapeElements = [
-        "rect",
-        "circle",
-        "ellipse",
-        "polygon",
-        "polyline",
-        "path",
-        "line"
-    ];
-    const hasShape = shapeElements.some((shape)=>svg.includes(`<${shape}`) || svg.includes(`<${shape} `));
-    if (!hasShape) {
-        return "SVG must contain at least one shape element (rect, circle, ellipse, polygon, polyline, path, or line)";
-    }
-    return null;
-}
-function assembleAnnotation(request, creator) {
-    const newAnnotationId = generateUuid();
-    const posSelector = getTextPositionSelector(request.target.selector);
-    const svgSelector = getSvgSelector(request.target.selector);
-    const fragmentSelector = getFragmentSelector(request.target.selector);
-    if (!posSelector && !svgSelector && !fragmentSelector) {
-        throw new Error("Either TextPositionSelector, SvgSelector, or FragmentSelector is required for creating annotations");
-    }
-    if (svgSelector) {
-        const svgError = validateSvgMarkup(svgSelector.value);
-        if (svgError) {
-            throw new Error(`Invalid SVG markup: ${svgError}`);
-        }
-    }
-    if (!request.motivation) {
-        throw new Error("motivation is required");
-    }
-    const now = /* @__PURE__ */ new Date().toISOString();
-    const annotation = {
-        "@context": "http://www.w3.org/ns/anno.jsonld",
-        "type": "Annotation",
-        id: newAnnotationId,
-        motivation: request.motivation,
-        target: request.target,
-        body: request.body,
-        creator,
-        created: now,
-        modified: now
-    };
-    const bodyArray = Array.isArray(request.body) ? request.body : request.body ? [
-        request.body
-    ] : [];
-    return {
-        annotation,
-        bodyArray
-    };
-}
-function applyBodyOperations(body, operations) {
-    const bodyArray = Array.isArray(body) ? [
-        ...body
-    ] : [];
-    for (const op of operations){
-        if (op.op === "add") {
-            const exists = bodyArray.some((item)=>JSON.stringify(item) === JSON.stringify(op.item));
-            if (!exists) {
-                bodyArray.push(op.item);
-            }
-        } else if (op.op === "remove") {
-            const index = bodyArray.findIndex((item)=>JSON.stringify(item) === JSON.stringify(op.item));
-            if (index !== -1) {
-                bodyArray.splice(index, 1);
-            }
-        } else if (op.op === "replace") {
-            const index = bodyArray.findIndex((item)=>JSON.stringify(item) === JSON.stringify(op.oldItem));
-            if (index !== -1) {
-                bodyArray[index] = op.newItem;
-            }
-        }
-    }
-    return bodyArray;
-}
-// src/type-guards.ts
-function isString(value) {
-    return typeof value === "string";
-}
-function isNumber(value) {
-    return typeof value === "number" && !isNaN(value);
-}
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isArray(value) {
-    return Array.isArray(value);
-}
-function isBoolean(value) {
-    return typeof value === "boolean";
-}
-function isFunction(value) {
-    return typeof value === "function";
-}
-function isNull(value) {
-    return value === null;
-}
-function isUndefined(value) {
-    return value === void 0;
-}
-function isNullish(value) {
-    return value === null || value === void 0;
-}
-function isDefined(value) {
-    return value !== null && value !== void 0;
-}
-// src/errors.ts
-var SemiontError = class extends Error {
-    constructor(message, code, details){
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.name = "SemiontError";
-        Error.captureStackTrace(this, this.constructor);
-    }
-};
-var ValidationError = class extends SemiontError {
-    constructor(message, details){
-        super(message, "VALIDATION_ERROR", details);
-        this.name = "ValidationError";
-    }
-};
-var ScriptError = class extends SemiontError {
-    constructor(message, code = "SCRIPT_ERROR", details){
-        super(message, code, details);
-        this.name = "ScriptError";
-    }
-};
-var NotFoundError = class extends SemiontError {
-    constructor(resource, id){
-        const message = id ? `${resource} with id '${id}' not found` : `${resource} not found`;
-        super(message, "NOT_FOUND", {
-            resource,
-            id
-        });
-        this.name = "NotFoundError";
-    }
-};
-var UnauthorizedError = class extends SemiontError {
-    constructor(message = "Unauthorized", details){
-        super(message, "UNAUTHORIZED", details);
-        this.name = "UnauthorizedError";
-    }
-};
-var ConflictError = class extends SemiontError {
-    constructor(message, details){
-        super(message, "CONFLICT", details);
-        this.name = "ConflictError";
-    }
-};
-var APIError = class extends Error {
-    constructor(status, data, message){
-        super(message || `API Error: ${status}`);
-        this.status = status;
-        this.data = data;
-        this.name = "APIError";
-        Error.captureStackTrace(this, this.constructor);
-    }
-};
-// src/did-utils.ts
-function userToDid(user) {
-    return `did:web:${user.domain}:users:${user.id}`;
-}
-function userToAgent(user) {
-    return {
-        type: "Person",
-        id: userToDid(user),
-        name: user.name || user.email
-    };
-}
-function didToAgent(did) {
-    const parts = did.split(":");
-    const userId2 = parts[parts.length - 1] || "unknown";
-    return {
-        type: "Person",
-        id: did,
-        name: userId2
-    };
-}
-// src/config/configuration-error.ts
-var ConfigurationError = class extends Error {
-    constructor(message, environment, suggestion, cause){
-        super(message);
-        this.environment = environment;
-        this.suggestion = suggestion;
-        this.name = "ConfigurationError";
-        this.cause = cause;
-    }
-    /**
-   * Format the error nicely for CLI output
-   */ toString() {
-        let output = `\u274C ${this.message}`;
-        if (this.environment) {
-            output += `
-   Environment: ${this.environment}`;
-        }
-        if (this.suggestion) {
-            output += `
-   \u{1F4A1} Suggestion: ${this.suggestion}`;
-        }
-        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_2__({
-    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 [
-        "aws",
-        "container",
-        "posix",
-        "external"
-    ].includes(value);
-}
-function getAllPlatformTypes() {
-    return [
-        "aws",
-        "container",
-        "posix",
-        "external"
-    ];
-}
-// src/index.ts
-var CORE_TYPES_VERSION = "0.1.0";
-var SDK_VERSION = "0.1.0";
- //# sourceMappingURL=index.js.map
- //# sourceMappingURL=index.js.map
-
-
 /***/ })
 
 };