@semiont/core 0.3.3 → 0.3.5

package/dist/index.js

@@ -1,7 +1,6 @@
 import { Subject, Observable } from 'rxjs';
 import { randomBytes } from 'crypto';
-import Ajv from 'ajv';
-import addFormats from 'ajv-formats';
+import { parse } from 'smol-toml';
 
 // src/branded-types.ts
 function email(value) {
@@ -569,1740 +568,32 @@ function didToAgent(did) {
     // Use user ID as name since we don't have full user data
   };
 }
-
-// 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;
-  }
-  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
+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;
     }
   }
-};
-
-// src/config/config-validator.ts
-var ajv = new Ajv({
-  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
-});
-addFormats(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);
+  return result;
 }
 function resolveEnvVars(obj, env) {
   if (typeof obj === "string") {
     return obj.replace(/\$\{([^}]+)\}/g, (match, varName) => {
-      return env[varName] || match;
+      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 && typeof obj === "object") {
+  if (obj !== null && typeof obj === "object") {
     const resolved = {};
     for (const key in obj) {
       resolved[key] = resolveEnvVars(obj[key], env);
@@ -2311,94 +602,175 @@ function resolveEnvVars(obj, env) {
   }
   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
-      // Environment-specific overrides
-    );
-    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
-      }
+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
     };
-    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`
-      );
+  }
+  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);
     }
-    return configWithMetadata;
-  } catch (error) {
-    if (error instanceof ConfigurationError) {
-      throw error;
+  }
+  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
+      };
     }
-    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 topLevelWorkers = {};
+  for (const [name, w] of Object.entries(workersSection)) {
+    if (w.inference) {
+      topLevelWorkers[name] = { inference: { type: w.inference.type, model: w.inference.model } };
     }
-    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`
-    );
   }
+  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 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) {
+function createTomlConfigLoader(reader, globalConfigPath, env) {
   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);
+    return loadTomlConfig(projectRoot, environment, globalConfigPath, reader, env);
   };
 }
 
@@ -2426,6 +798,33 @@ function validateEnvironment(value, availableEnvironments) {
   return value;
 }
 
+// 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;
+  }
+  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/platform-types.ts
 function isValidPlatformType(value) {
   return ["aws", "container", "posix", "external"].includes(value);
@@ -2438,6 +837,6 @@ function getAllPlatformTypes() {
 var CORE_TYPES_VERSION = "0.1.0";
 var SDK_VERSION = "0.1.0";
 
-export { 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, isResourceEvent2 as isStoredEvent, isString, isSystemEvent, isUndefined, isValidPlatformType, jobId, listEnvironmentNames, mcpToken, parseAndMergeConfigs, parseEnvironment, refreshToken, resolveEnvVars, resourceAnnotationUri, resourceId, resourceUri, searchQuery, userDID, userId, userToAgent, userToDid, validateEnvironment, validateEnvironmentConfig, validateSemiontConfig, validateSiteConfig, validateSvgMarkup };
+export { 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, createTomlConfigLoader, didToAgent, email, entityType, findBodyItem, generateUuid, getAllPlatformTypes, getAnnotationUriFromEvent, getEventType, getFragmentSelector, getSvgSelector, getTextPositionSelector, googleCredential, isAnnotationId, isArray, isBoolean, isDefined, isEventRelatedToAnnotation, isFunction, isNull, isNullish, isNumber, isObject, isResourceEvent, isResourceId, isResourceScopedEvent, isResourceEvent2 as isStoredEvent, isString, isSystemEvent, isUndefined, isValidPlatformType, jobId, loadTomlConfig, mcpToken, parseEnvironment, refreshToken, resourceAnnotationUri, resourceId, resourceUri, searchQuery, userDID, userId, userToAgent, userToDid, validateEnvironment, validateSvgMarkup };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map