@semiont/core 0.2.2-build.11 → 0.2.2-build.12

package/dist/index.js

@@ -1,80 +1,1457 @@
-"use strict";
-/**
- * @semiont/core
- *
- * Core domain logic and utilities for the Semiont semantic knowledge platform.
- * For OpenAPI types, import directly from @semiont/api-client.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+import { createHash, randomBytes } from 'crypto';
+import { getAnnotationExactText, getEntityTypes } from '@semiont/api-client';
+import * as fs2 from 'fs';
+import * as path from 'path';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+
+// src/creation-methods.ts
+var CREATION_METHODS = {
+  API: "api",
+  UPLOAD: "upload",
+  UI: "ui",
+  REFERENCE: "reference",
+  CLONE: "clone",
+  GENERATED: "generated"
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SDK_VERSION = exports.CORE_TYPES_VERSION = exports.validateSiteConfig = exports.validateEnvironmentConfig = exports.validateSemiontConfig = exports.getAllPlatformTypes = exports.isValidPlatformType = exports.getSemiontConfigPath = exports.getEnvironmentsPath = exports.isProjectRoot = exports.findProjectRoot = exports.ConfigurationError = exports.validateEnvironment = exports.parseEnvironment = exports.isValidEnvironment = exports.getNodeEnvForEnvironment = exports.getAvailableEnvironments = exports.loadEnvironmentConfig = exports.findBodyItem = exports.bodyItemsMatch = exports.getEventType = exports.isResourceScopedEvent = exports.isSystemEvent = exports.isResourceEvent = exports.isAnnotationId = exports.isResourceId = exports.userId = exports.annotationId = exports.resourceId = exports.CREATION_METHODS = void 0;
-// NOTE: OpenAPI types are NOT re-exported from @semiont/core.
-// Import types directly from @semiont/api-client where needed:
-//   import type { components } from '@semiont/api-client';
-//   type Annotation = components['schemas']['Annotation'];
-// Creation methods
-var creation_methods_1 = require("./creation-methods");
-Object.defineProperty(exports, "CREATION_METHODS", { enumerable: true, get: function () { return creation_methods_1.CREATION_METHODS; } });
-var identifiers_1 = require("./identifiers");
-Object.defineProperty(exports, "resourceId", { enumerable: true, get: function () { return identifiers_1.resourceId; } });
-Object.defineProperty(exports, "annotationId", { enumerable: true, get: function () { return identifiers_1.annotationId; } });
-Object.defineProperty(exports, "userId", { enumerable: true, get: function () { return identifiers_1.userId; } });
-Object.defineProperty(exports, "isResourceId", { enumerable: true, get: function () { return identifiers_1.isResourceId; } });
-Object.defineProperty(exports, "isAnnotationId", { enumerable: true, get: function () { return identifiers_1.isAnnotationId; } });
-var events_1 = require("./events");
-Object.defineProperty(exports, "isResourceEvent", { enumerable: true, get: function () { return events_1.isResourceEvent; } });
-Object.defineProperty(exports, "isSystemEvent", { enumerable: true, get: function () { return events_1.isSystemEvent; } });
-Object.defineProperty(exports, "isResourceScopedEvent", { enumerable: true, get: function () { return events_1.isResourceScopedEvent; } });
-Object.defineProperty(exports, "getEventType", { enumerable: true, get: function () { return events_1.getEventType; } });
-// Backend-specific annotation utilities
-var annotation_utils_1 = require("./annotation-utils");
-Object.defineProperty(exports, "bodyItemsMatch", { enumerable: true, get: function () { return annotation_utils_1.bodyItemsMatch; } });
-Object.defineProperty(exports, "findBodyItem", { enumerable: true, get: function () { return annotation_utils_1.findBodyItem; } });
-// Utility functions
-__exportStar(require("./type-guards"), exports);
-__exportStar(require("./crypto"), exports);
-__exportStar(require("./errors"), exports);
-__exportStar(require("./http-client"), exports);
-__exportStar(require("./annotation-history-utils"), exports);
-__exportStar(require("./did-utils"), exports);
-// Configuration loading
-var environment_loader_1 = require("./config/environment-loader");
-Object.defineProperty(exports, "loadEnvironmentConfig", { enumerable: true, get: function () { return environment_loader_1.loadEnvironmentConfig; } });
-Object.defineProperty(exports, "getAvailableEnvironments", { enumerable: true, get: function () { return environment_loader_1.getAvailableEnvironments; } });
-Object.defineProperty(exports, "getNodeEnvForEnvironment", { enumerable: true, get: function () { return environment_loader_1.getNodeEnvForEnvironment; } });
-var environment_validator_1 = require("./config/environment-validator");
-Object.defineProperty(exports, "isValidEnvironment", { enumerable: true, get: function () { return environment_validator_1.isValidEnvironment; } });
-Object.defineProperty(exports, "parseEnvironment", { enumerable: true, get: function () { return environment_validator_1.parseEnvironment; } });
-Object.defineProperty(exports, "validateEnvironment", { enumerable: true, get: function () { return environment_validator_1.validateEnvironment; } });
-var configuration_error_1 = require("./config/configuration-error");
-Object.defineProperty(exports, "ConfigurationError", { enumerable: true, get: function () { return configuration_error_1.ConfigurationError; } });
-var project_discovery_1 = require("./config/project-discovery");
-Object.defineProperty(exports, "findProjectRoot", { enumerable: true, get: function () { return project_discovery_1.findProjectRoot; } });
-Object.defineProperty(exports, "isProjectRoot", { enumerable: true, get: function () { return project_discovery_1.isProjectRoot; } });
-Object.defineProperty(exports, "getEnvironmentsPath", { enumerable: true, get: function () { return project_discovery_1.getEnvironmentsPath; } });
-Object.defineProperty(exports, "getSemiontConfigPath", { enumerable: true, get: function () { return project_discovery_1.getSemiontConfigPath; } });
-var platform_types_1 = require("./config/platform-types");
-Object.defineProperty(exports, "isValidPlatformType", { enumerable: true, get: function () { return platform_types_1.isValidPlatformType; } });
-Object.defineProperty(exports, "getAllPlatformTypes", { enumerable: true, get: function () { return platform_types_1.getAllPlatformTypes; } });
-// Configuration validation
-var config_validator_1 = require("./config/config-validator");
-Object.defineProperty(exports, "validateSemiontConfig", { enumerable: true, get: function () { return config_validator_1.validateSemiontConfig; } });
-Object.defineProperty(exports, "validateEnvironmentConfig", { enumerable: true, get: function () { return config_validator_1.validateEnvironmentConfig; } });
-Object.defineProperty(exports, "validateSiteConfig", { enumerable: true, get: function () { return config_validator_1.validateSiteConfig; } });
-// Version information
-exports.CORE_TYPES_VERSION = '0.1.0';
-exports.SDK_VERSION = '0.1.0';
+
+// 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/annotation-utils.ts
+function bodyItemsMatch(item1, item2) {
+  if (item1.type !== item2.type) {
+    return false;
+  }
+  if (item1.purpose !== item2.purpose) {
+    return false;
+  }
+  if (item1.type === "TextualBody" && item2.type === "TextualBody") {
+    return item1.value === item2.value;
+  }
+  if (item1.type === "SpecificResource" && item2.type === "SpecificResource") {
+    return item1.source === item2.source;
+  }
+  return false;
+}
+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;
+}
+
+// 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;
+}
+function calculateChecksum(content) {
+  const hash = createHash("sha256");
+  hash.update(content);
+  return hash.digest("hex");
+}
+function verifyChecksum(content, checksum) {
+  return calculateChecksum(content) === checksum;
+}
+function generateId() {
+  return randomBytes(6).toString("hex");
+}
+function generateUuid() {
+  return randomBytes(16).toString("hex");
+}
+function generateToken(bytes = 32) {
+  return randomBytes(bytes).toString("base64url");
+}
+
+// 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/http-client.ts
+async function fetchAPI(endpoint, options = {}, token, baseUrl = "") {
+  const headers = {
+    "Content-Type": "application/json",
+    ...options.headers || {}
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  const url = baseUrl ? `${baseUrl}${endpoint}` : endpoint;
+  const response = await fetch(url, {
+    ...options,
+    headers
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new APIError(response.status, errorData, errorData.message);
+  }
+  if (response.status === 204 || response.headers.get("content-length") === "0") {
+    return {};
+  }
+  return response.json();
+}
+function createFetchAPI(baseUrl) {
+  return function(endpoint, options = {}, token) {
+    return fetchAPI(endpoint, options, token, baseUrl);
+  };
+}
+function formatEventType(type, t) {
+  switch (type) {
+    case "resource.created":
+      return t("resourceCreated");
+    case "resource.cloned":
+      return t("resourceCloned");
+    case "resource.archived":
+      return t("resourceArchived");
+    case "resource.unarchived":
+      return t("resourceUnarchived");
+    case "annotation.added":
+      return t("annotationAdded");
+    case "annotation.removed":
+      return t("annotationRemoved");
+    case "annotation.body.updated":
+      return t("annotationBodyUpdated");
+    case "entitytag.added":
+      return t("entitytagAdded");
+    case "entitytag.removed":
+      return t("entitytagRemoved");
+    case "entitytype.added":
+      return t("entitytypeAdded");
+    case "job.started":
+      return t("jobStarted");
+    case "job.progress":
+      return t("jobProgress");
+    case "job.completed":
+      return t("jobCompleted");
+    case "job.failed":
+      return t("jobFailed");
+    default:
+      const _exhaustiveCheck = type;
+      return _exhaustiveCheck;
+  }
+}
+function getMotivationEmoji(motivation) {
+  switch (motivation) {
+    case "highlighting":
+      return "\u{1F7E1}";
+    case "linking":
+      return "\u{1F535}";
+    case "assessing":
+      return "\u{1F534}";
+    case "bookmarking":
+      return "\u{1F516}";
+    case "commenting":
+      return "\u{1F4AC}";
+    case "tagging":
+      return "\u{1F3F7}\uFE0F";
+    default:
+      return "\u{1F4DD}";
+  }
+}
+function getEventEmoji(type, event) {
+  switch (type) {
+    case "resource.created":
+    case "resource.cloned":
+    case "resource.archived":
+    case "resource.unarchived":
+      return "\u{1F4C4}";
+    case "annotation.added":
+      if (event) {
+        const payload = event.event.payload;
+        return getMotivationEmoji(payload.annotation.motivation);
+      }
+      return "\u{1F4DD}";
+    case "annotation.removed":
+      return "\u{1F5D1}\uFE0F";
+    case "annotation.body.updated":
+      return "\u270F\uFE0F";
+    case "entitytag.added":
+    case "entitytag.removed":
+      return "\u{1F3F7}\uFE0F";
+    case "entitytype.added":
+      return "\u{1F3F7}\uFE0F";
+    // Same emoji as entitytag (global entity type collection)
+    case "job.started":
+      return "\u25B6\uFE0F";
+    case "job.progress":
+      return "\u23F3";
+    case "job.completed":
+      return "\u2705";
+    case "job.failed":
+      return "\u274C";
+    default:
+      const _exhaustiveCheck = type;
+      return _exhaustiveCheck;
+  }
+}
+function formatRelativeTime(timestamp, t) {
+  const date = new Date(timestamp);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 6e4);
+  const diffHours = Math.floor(diffMs / 36e5);
+  const diffDays = Math.floor(diffMs / 864e5);
+  if (diffMins < 1) return t("justNow");
+  if (diffMins < 60) return t("minutesAgo", { count: diffMins });
+  if (diffHours < 24) return t("hoursAgo", { count: diffHours });
+  if (diffDays < 7) return t("daysAgo", { count: diffDays });
+  return date.toLocaleDateString();
+}
+function truncateText(text, maxLength = 50) {
+  const trimmed = text.trim();
+  return trimmed.length > maxLength ? trimmed.substring(0, maxLength) + "..." : trimmed;
+}
+function getEventDisplayContent(event, _references, _highlights, allEvents) {
+  const eventData = event.event;
+  switch (eventData.type) {
+    case "resource.created":
+    case "resource.cloned": {
+      const payload = eventData.payload;
+      return { exact: payload.name, isQuoted: false, isTag: false };
+    }
+    case "annotation.body.updated": {
+      const payload = eventData.payload;
+      const addedEvent = allEvents.find(
+        (e) => e.event.type === "annotation.added" && e.event.payload.annotation.id === payload.annotationId
+      );
+      if (addedEvent) {
+        const addedPayload = addedEvent.event.payload;
+        return { exact: truncateText(getAnnotationExactText(addedPayload.annotation)), isQuoted: true, isTag: false };
+      }
+      return null;
+    }
+    case "annotation.removed": {
+      const payload = eventData.payload;
+      const addedEvent = allEvents.find(
+        (e) => e.event.type === "annotation.added" && e.event.payload.annotation.id === payload.annotationId
+      );
+      if (addedEvent) {
+        const addedPayload = addedEvent.event.payload;
+        return { exact: truncateText(getAnnotationExactText(addedPayload.annotation)), isQuoted: true, isTag: false };
+      }
+      return null;
+    }
+    case "annotation.added": {
+      const payload = eventData.payload;
+      return { exact: truncateText(getAnnotationExactText(payload.annotation)), isQuoted: true, isTag: false };
+    }
+    case "entitytag.added":
+    case "entitytag.removed": {
+      const payload = eventData.payload;
+      return { exact: payload.entityType, isQuoted: false, isTag: true };
+    }
+    default:
+      return null;
+  }
+}
+function getEventEntityTypes(event) {
+  const eventData = event.event;
+  if (eventData.type === "annotation.added") {
+    const payload = eventData.payload;
+    return getEntityTypes(payload.annotation);
+  }
+  return [];
+}
+function formatUserId(userId2) {
+  if (userId2.startsWith("did:web:")) {
+    const parts = userId2.split(":");
+    if (parts.length >= 5) {
+      const domain = parts[2];
+      const username2 = parts[parts.length - 1];
+      return `${username2}@${domain}`;
+    }
+    const username = parts[parts.length - 1];
+    return username || userId2.substring(0, 8);
+  }
+  return userId2.substring(0, 8);
+}
+function getResourceCreationDetails(event) {
+  const eventData = event.event;
+  if (eventData.type === "resource.created") {
+    const payload = eventData.payload;
+    return {
+      type: "created",
+      userId: formatUserId(eventData.userId),
+      method: payload.creationMethod
+    };
+  }
+  if (eventData.type === "resource.cloned") {
+    const payload = eventData.payload;
+    return {
+      type: "cloned",
+      userId: formatUserId(eventData.userId),
+      method: payload.creationMethod,
+      sourceDocId: payload.parentResourceId
+    };
+  }
+  return null;
+}
+function getAnnotationIdFromEvent(event) {
+  const eventData = event.event;
+  switch (eventData.type) {
+    case "annotation.added": {
+      const payload = eventData.payload;
+      return payload.annotation.id;
+    }
+    case "annotation.removed":
+    case "annotation.body.updated": {
+      const payload = eventData.payload;
+      return payload.annotationId;
+    }
+    default:
+      return null;
+  }
+}
+function isEventRelatedToAnnotation(event, annotationId2) {
+  const eventAnnotationId = getAnnotationIdFromEvent(event);
+  return eventAnnotationId === annotationId2;
+}
+
+// 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
+    // 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;
+  }
+};
+function findProjectRoot() {
+  const root = process.env.SEMIONT_ROOT;
+  if (!root) {
+    throw new ConfigurationError(
+      "SEMIONT_ROOT environment variable is not set",
+      void 0,
+      "Set SEMIONT_ROOT to your project directory, or use the semiont CLI which sets it automatically"
+    );
+  }
+  if (!fs2.existsSync(root)) {
+    throw new ConfigurationError(
+      `SEMIONT_ROOT points to non-existent directory: ${root}`,
+      void 0,
+      "Check that SEMIONT_ROOT environment variable is set correctly"
+    );
+  }
+  if (!isProjectRoot(root)) {
+    throw new ConfigurationError(
+      `SEMIONT_ROOT does not point to a valid Semiont project: ${root}`,
+      void 0,
+      "Ensure SEMIONT_ROOT points to a directory containing semiont.json or environments/"
+    );
+  }
+  return root;
+}
+function isProjectRoot(projectPath) {
+  return fs2.existsSync(path.join(projectPath, "semiont.json")) || fs2.existsSync(path.join(projectPath, "environments"));
+}
+function getEnvironmentsPath(projectRoot) {
+  const root = projectRoot || findProjectRoot();
+  return path.join(root, "environments");
+}
+function getSemiontConfigPath(projectRoot) {
+  const root = projectRoot || findProjectRoot();
+  return path.join(root, "semiont.json");
+}
+
+// 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" },
+        url: { type: "string" },
+        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" } }
+      },
+      required: ["platform", "port", "url", "siteName"],
+      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", "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" }
+      },
+      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
+        },
+        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({
+  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 path3 = 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 `${path3}: ${message} (expected ${err.params.type})`;
+    }
+    if (err.keyword === "enum" && "allowedValues" in err.params) {
+      return `${path3}: must be one of [${err.params.allowedValues.join(", ")}]`;
+    }
+    if (err.keyword === "format") {
+      return `${path3}: invalid format (${message})`;
+    }
+    if (err.keyword === "minLength" || err.keyword === "minItems") {
+      return `${path3}: ${message}`;
+    }
+    return `${path3}: ${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) {
+  if (typeof obj === "string") {
+    return obj.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+      return process.env[varName] || match;
+    });
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => resolveEnvVars(item));
+  }
+  if (obj && typeof obj === "object") {
+    const resolved = {};
+    for (const key in obj) {
+      resolved[key] = resolveEnvVars(obj[key]);
+    }
+    return resolved;
+  }
+  return obj;
+}
+function loadEnvironmentConfig(projectRoot, environment) {
+  try {
+    const baseConfigPath = path.join(projectRoot, "semiont.json");
+    let baseConfig = {};
+    if (fs2.existsSync(baseConfigPath)) {
+      const baseContent = fs2.readFileSync(baseConfigPath, "utf-8");
+      baseConfig = JSON.parse(baseContent);
+    }
+    const envPath = path.join(projectRoot, "environments", `${environment}.json`);
+    if (!fs2.existsSync(envPath)) {
+      throw new ConfigurationError(
+        `Environment configuration missing: ${envPath}`,
+        environment,
+        `Create the configuration file or use: semiont init`
+      );
+    }
+    const envContent = fs2.readFileSync(envPath, "utf-8");
+    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);
+    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 load environment configuration: ${message}`,
+      environment,
+      `Check the configuration files exist and are valid JSON`
+    );
+  }
+}
+function getNodeEnvForEnvironment(config) {
+  const nodeEnv = config.env?.NODE_ENV;
+  return nodeEnv || "development";
+}
+function getAvailableEnvironments() {
+  try {
+    const projectRoot = findProjectRoot();
+    const configDir = path.join(projectRoot, "environments");
+    if (!fs2.existsSync(configDir)) {
+      return [];
+    }
+    return fs2.readdirSync(configDir).filter((file) => file.endsWith(".json")).map((file) => path.basename(file, ".json")).sort();
+  } catch (error) {
+    return [];
+  }
+}
+
+// src/config/environment-validator.ts
+function isValidEnvironment(value) {
+  if (!value) return false;
+  return getAvailableEnvironments().includes(value);
+}
+function parseEnvironment(value) {
+  if (!value) {
+    throw new Error("Environment is required");
+  }
+  if (!isValidEnvironment(value)) {
+    const availableEnvs = getAvailableEnvironments();
+    throw new Error(`Invalid environment: ${value}. Available environments: ${availableEnvs.join(", ")}`);
+  }
+  return value;
+}
+function validateEnvironment(value) {
+  if (!value) {
+    throw new Error("Environment is required");
+  }
+  if (!isValidEnvironment(value)) {
+    const availableEnvs = getAvailableEnvironments();
+    throw new Error(`Invalid environment: ${value}. Available environments: ${availableEnvs.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";
+
+export { APIError, CORE_TYPES_VERSION, CREATION_METHODS, ConfigurationError, ConflictError, NotFoundError, SDK_VERSION, ScriptError, SemiontError, UnauthorizedError, ValidationError, annotationId, bodyItemsMatch, calculateChecksum, createFetchAPI, didToAgent, fetchAPI, findBodyItem, findProjectRoot, formatEventType, formatRelativeTime, generateId, generateToken, generateUuid, getAllPlatformTypes, getAnnotationIdFromEvent, getAvailableEnvironments, getEnvironmentsPath, getEventDisplayContent, getEventEmoji, getEventEntityTypes, getEventType, getNodeEnvForEnvironment, getResourceCreationDetails, getSemiontConfigPath, isAnnotationId, isArray, isBoolean, isDefined, isEventRelatedToAnnotation, isFunction, isNull, isNullish, isNumber, isObject, isProjectRoot, isResourceEvent, isResourceId, isResourceScopedEvent, isString, isSystemEvent, isUndefined, isValidEnvironment, isValidPlatformType, loadEnvironmentConfig, parseEnvironment, resourceId, userId, userToAgent, userToDid, validateEnvironment, validateEnvironmentConfig, validateSemiontConfig, validateSiteConfig, verifyChecksum };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map