@origostudio/origo-design 0.0.0

package/dist/packages/core/CHANGELOG.md

@@ -0,0 +1,275 @@
+## 0.0.22 (2026-09-04)
+
+### 🚀 Features
+
+- scaffold playground application and e2e testing suite with initial editor component and schema registry ([f097894](https://github.com/OrigoStudio/origo-design/commit/f097894))
+- add GitHub Actions workflow to automate library releases using Nx Release ([3d6651f](https://github.com/OrigoStudio/origo-design/commit/3d6651f))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.21 (2026-09-02)
+
+### 🚀 Features
+
+- add centralized test registry tool with validation logic, CI integration, and documentation artifacts ([384c1c7](https://github.com/OrigoStudio/origo-design/commit/384c1c7))
+- implement central test registry with validation tools and CI integration ([02cf656](https://github.com/OrigoStudio/origo-design/commit/02cf656))
+- initialize negative testing story and update sprint status tracking ([bbe5fdc](https://github.com/OrigoStudio/origo-design/commit/bbe5fdc))
+- implement CLI framework with validation, testing, and CI/CD workflows ([ff6ce55](https://github.com/OrigoStudio/origo-design/commit/ff6ce55))
+- implement validate command and schema validation logic for BADL files ([4f9e41d](https://github.com/OrigoStudio/origo-design/commit/4f9e41d))
+- implement path traversal guards, remove process termination from library logic, and enable error cause preservation in @origo/cli ([0854f78](https://github.com/OrigoStudio/origo-design/commit/0854f78))
+- initialize web-based editor component and track security remediation tasks in implementation artifacts ([65716bd](https://github.com/OrigoStudio/origo-design/commit/65716bd))
+- document e2e npm verification plan for cli package releases ([22dab4c](https://github.com/OrigoStudio/origo-design/commit/22dab4c))
+- initialize sprint status tracking and retrospective verification story for npm packaging ([c326751](https://github.com/OrigoStudio/origo-design/commit/c326751))
+- add generated bundle for epic7-worker-csp spike ([16ca492](https://github.com/OrigoStudio/origo-design/commit/16ca492))
+- add web worker CSP spike and associated implementation documentation ([ebf5aa4](https://github.com/OrigoStudio/origo-design/commit/ebf5aa4))
+- implement web worker CSP spike with supporting documentation and harness tools ([f57b1e5](https://github.com/OrigoStudio/origo-design/commit/f57b1e5))
+- add technical spike story for Epic 7 web worker CSP validation and ADR planning ([c977487](https://github.com/OrigoStudio/origo-design/commit/c977487))
+- initialize sprint status tracking and create Epic 7 discovery research story ([b37b967](https://github.com/OrigoStudio/origo-design/commit/b37b967))
+- implement entity generator command with template customization and ejection support ([02a3193](https://github.com/OrigoStudio/origo-design/commit/02a3193))
+- implement entity generator command and template ejection logic in CLI ([d7d519a](https://github.com/OrigoStudio/origo-design/commit/d7d519a))
+- implementation of 6-2-local-schema-validation ([45e67f6](https://github.com/OrigoStudio/origo-design/commit/45e67f6))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.20 (2026-08-25)
+
+### 🚀 Features
+
+- implementation of 6-1-cli-initialization-and-scaffolding ([f6aca9e](https://github.com/OrigoStudio/origo-design/commit/f6aca9e))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.19 (2026-08-23)
+
+### 🚀 Features
+
+- 5.5-5-define-secure-by-default-boilerplate-templates ([0eb6dde](https://github.com/OrigoStudio/origo-design/commit/0eb6dde))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.18 (2026-08-23)
+
+### 🚀 Features
+
+- 5.5-4-verify-core-compiler-source-map-preservation ([a3b0d9b](https://github.com/OrigoStudio/origo-design/commit/a3b0d9b))
+
+### 🩹 Fixes
+
+- pipeline issue ([c1bbe47](https://github.com/OrigoStudio/origo-design/commit/c1bbe47))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.17 (2026-08-21)
+
+### 🚀 Features
+
+- 5.5-3-resolve-recursive-schema-resolution-tech-debt ([943e2e7](https://github.com/OrigoStudio/origo-design/commit/943e2e7))
+- 5.5-2-establish-end-to-end-qa-protocols ([d8990ae](https://github.com/OrigoStudio/origo-design/commit/d8990ae))
+- 5.5-2-establish-end-to-end-qa-protocols ([a31d97a](https://github.com/OrigoStudio/origo-design/commit/a31d97a))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.16 (2026-08-21)
+
+### 🚀 Features
+
+- 5.5-1-create-usability-quickstart-guide ([e740a1a](https://github.com/OrigoStudio/origo-design/commit/e740a1a))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.15 (2026-08-20)
+
+### 🚀 Features
+
+- code-review 5-5-reactive-state-event-binding ([b235951](https://github.com/OrigoStudio/origo-design/commit/b235951))
+- implementation of 5-5-reactive-state-event-binding ([3a5948a](https://github.com/OrigoStudio/origo-design/commit/3a5948a))
+- story creation 5-5-reactive-state-event-binding ([21104c6](https://github.com/OrigoStudio/origo-design/commit/21104c6))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.14 (2026-08-19)
+
+### 🚀 Features
+
+- 5-4-design-token-consumption ([c1f64ed](https://github.com/OrigoStudio/origo-design/commit/c1f64ed))
+- add sprint status update and design token consumption story documentation ([49aec07](https://github.com/OrigoStudio/origo-design/commit/49aec07))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.13 (2026-08-18)
+
+### 🚀 Features
+
+- implement core primitives (Button, VBox, TextInput) with improved property coercion and accessibility support ([1be1def](https://github.com/OrigoStudio/origo-design/commit/1be1def))
+- implement VBox, TextInput, and Button core primitives with accessibility testing and improved adapter coercion ([532417f](https://github.com/OrigoStudio/origo-design/commit/532417f))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.12 (2026-08-17)
+
+### 🚀 Features
+
+- implement InteractionContract-based OrigoAdapter and transition angular-renderer architecture to web adapter pattern ([1a8ea32](https://github.com/OrigoStudio/origo-design/commit/1a8ea32))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.11 (2026-08-14)
+
+### 🚀 Features
+
+- implement angular-renderer package with AST-based dynamic component instantiation and registry support ([500f396](https://github.com/OrigoStudio/origo-design/commit/500f396))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.10 (2026-08-14)
+
+### 🚀 Features
+
+- implement extension API scaffolding, define Angular signals patterns, and add renderer test utilities ([d2adbed](https://github.com/OrigoStudio/origo-design/commit/d2adbed))
+- mark Epic 4 as complete and record its retrospective action items in sprint status ([37c2caa](https://github.com/OrigoStudio/origo-design/commit/37c2caa))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.9 (2026-08-14)
+
+### 🚀 Features
+
+- implement extension manager with manifest validation, permission security, and dependency resolution ([154b0d4](https://github.com/OrigoStudio/origo-design/commit/154b0d4))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.8 (2026-08-14)
+
+### 🚀 Features
+
+- implement formal extension manifest, capability negotiation, and lifecycle management in core extension-api ([808f113](https://github.com/OrigoStudio/origo-design/commit/808f113))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.7 (2026-08-14)
+
+### 🚀 Features
+
+- implement behavior validation test suite and expand AST validator test coverage ([d4c79ef](https://github.com/OrigoStudio/origo-design/commit/d4c79ef))
+- register behavior validation suite story and update sprint status tracking ([798ec74](https://github.com/OrigoStudio/origo-design/commit/798ec74))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.6 (2026-08-13)
+
+### 🚀 Features
+
+- initialize package.json for @origo/core with essential dependencies ([f819e96](https://github.com/OrigoStudio/origo-design/commit/f819e96))
+- implement AST validation engine with support for circular dependency detection and reference integrity checks ([afd48c9](https://github.com/OrigoStudio/origo-design/commit/afd48c9))
+- initialize sprint-status.yaml to track project development and retrospective action items ([66c6cdf](https://github.com/OrigoStudio/origo-design/commit/66c6cdf))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.5 (2026-08-13)
+
+### 🚀 Features
+
+- **core:** implement security and permissions engine ([d066d90](https://github.com/OrigoStudio/origo-design/commit/d066d90))
+- add story 4.3 for security and permissions engine and update sprint status ([3eb4aae](https://github.com/OrigoStudio/origo-design/commit/3eb4aae))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.4 (2026-08-13)
+
+### 🚀 Features
+
+- add auto-generated Domain, Entity, Capability, and Contract TypeScript types for BADL definition ([10c337d](https://github.com/OrigoStudio/origo-design/commit/10c337d))
+- implement semantic AST validator with domain, entity, and contract schema definitions ([e969466](https://github.com/OrigoStudio/origo-design/commit/e969466))
+- update sprint status and initialize story 4-2 contracts and implementations documentation ([4b37c59](https://github.com/OrigoStudio/origo-design/commit/4b37c59))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.3 (2026-08-13)
+
+### 🚀 Features
+
+- 4-1-capabilities-schema-parsing ([869c872](https://github.com/OrigoStudio/origo-design/commit/869c872))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.2 (2026-08-12)
+
+### 🚀 Features
+
+- implement defensive AST validation with depth limiting, circular reference detection, and graceful error reporting ([d2f5f98](https://github.com/OrigoStudio/origo-design/commit/d2f5f98))
+- initialize 3-5-3-defensive-ast-traversal story and update sprint status ([4f82702](https://github.com/OrigoStudio/origo-design/commit/4f82702))
+- enforce JSON import standard and document AST validator ([162db09](https://github.com/OrigoStudio/origo-design/commit/162db09))
+- implement automated semantic versioning with Nx release and commitlint enforcement ([5e7a25e](https://github.com/OrigoStudio/origo-design/commit/5e7a25e))
+- implement AST validation engine and documentation for semantic versioning workflow ([838e472](https://github.com/OrigoStudio/origo-design/commit/838e472))
+- implement AST validation engine and associated implementation artifacts ([49cbdf0](https://github.com/OrigoStudio/origo-design/commit/49cbdf0))
+- implement deterministic canonical AST serialization and interfaces in @origo/core ([c35a2c9](https://github.com/OrigoStudio/origo-design/commit/c35a2c9))
+- implement domain and entity schema parser with Ajv-based validation and circular dependency detection in new @origo/core package ([4165b5f](https://github.com/OrigoStudio/origo-design/commit/4165b5f))
+- add design tokens documentation and update Starlight navigation configuration ([ba2404a](https://github.com/OrigoStudio/origo-design/commit/ba2404a))
+- initialize Epic 3 planning and document Epic 2 retrospective findings ([4cc46f9](https://github.com/OrigoStudio/origo-design/commit/4cc46f9))
+- implement runtime theme fetching, injection, and Angular renderer integration to complete the token resolution contract ([87f583e](https://github.com/OrigoStudio/origo-design/commit/87f583e))
+- implement theme-fetcher runtime utility and create angular-renderer package with theme initialization provider ([1d5b7ab](https://github.com/OrigoStudio/origo-design/commit/1d5b7ab))
+- implement secure theme injection with CSS token validation and scope management ([a708825](https://github.com/OrigoStudio/origo-design/commit/a708825))
+- implement runtime theme injector for parsing and applying CSS variables ([969fed5](https://github.com/OrigoStudio/origo-design/commit/969fed5))
+- add astro, @astrojs/starlight, and sharp dependencies to package.json ([1c40a92](https://github.com/OrigoStudio/origo-design/commit/1c40a92))
+- implement design token compilation pipeline with CSS variable parsing and generation ([0ffe822](https://github.com/OrigoStudio/origo-design/commit/0ffe822))
+- **nx-cloud:** setup nx cloud workspace ([ee09042](https://github.com/OrigoStudio/origo-design/commit/ee09042))
+- **design-tokens:** implement css compilation pipeline ([7bd632d](https://github.com/OrigoStudio/origo-design/commit/7bd632d))
+- add script to generate automated LLM review prompts from git diffs ([1ddbd39](https://github.com/OrigoStudio/origo-design/commit/1ddbd39))
+- scaffold @origo/design-tokens package with JSON schema validation and Nx configuration ([ae61244](https://github.com/OrigoStudio/origo-design/commit/ae61244))
+- scaffold @origo/design-tokens library with JSON schema validation and initial token definitions ([efbecc9](https://github.com/OrigoStudio/origo-design/commit/efbecc9))
+- initialize Astro documentation site and relocate internal project scripts to the tools directory. ([1cd8e71](https://github.com/OrigoStudio/origo-design/commit/1cd8e71))
+- add documentation story spec and update epic-1 status to done ([b612ea3](https://github.com/OrigoStudio/origo-design/commit/b612ea3))
+- initialize and populate agent skill definitions, workflows, and technical knowledge resources ([8668c52](https://github.com/OrigoStudio/origo-design/commit/8668c52))
+- initialize Starlight documentation site within the monorepo and add benchmark tools ([9a16b03](https://github.com/OrigoStudio/origo-design/commit/9a16b03))
+- implement performance benchmark harness with regression and SLA gate logic ([350d472](https://github.com/OrigoStudio/origo-design/commit/350d472))
+- implement performance benchmark harness with CI regression gating and SLA validation ([3230ac9](https://github.com/OrigoStudio/origo-design/commit/3230ac9))
+- implement Husky pre-commit hooks and Nx-based lint-staged configuration ([9181885](https://github.com/OrigoStudio/origo-design/commit/9181885))
+- add GitHub Actions CI workflow, Husky pre-commit hooks, and update package.json with necessary configuration ([95b8bf1](https://github.com/OrigoStudio/origo-design/commit/95b8bf1))
+- configure Husky, lint-staged, and GitHub CI workflow for automated quality enforcement ([b6bf597](https://github.com/OrigoStudio/origo-design/commit/b6bf597))
+- initialize Nx monorepo workspace with core configuration and tooling ([fd0665a](https://github.com/OrigoStudio/origo-design/commit/fd0665a))
+- add sprint tracking artifacts and automation script for project bootstrapping ([ddc6149](https://github.com/OrigoStudio/origo-design/commit/ddc6149))
+- document Origo Design functional requirements and architectural scope ([d1e0b7f](https://github.com/OrigoStudio/origo-design/commit/d1e0b7f))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse

package/dist/packages/core/README.md

@@ -0,0 +1,11 @@
+# core
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build core` to build the library.
+
+## Running unit tests
+
+Run `nx test core` to execute the unit tests via [Jest](https://jestjs.io).

package/dist/packages/core/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@origo/core",
+  "version": "0.0.22",
+  "private": true,
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-errors": "^3.0.0",
+    "ajv-formats": "^3.0.1",
+    "json-schema-to-typescript": "^14.1.0",
+    "json-source-map": "^0.6.1",
+    "semver": "^7.7.4",
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "@types/json-source-map": "^0.6.0",
+    "@types/semver": "^7.8.0"
+  }
+}

package/dist/packages/core/package.json.bak

@@ -0,0 +1,21 @@
+{
+  "name": "@origo/core",
+  "version": "0.0.22",
+  "private": true,
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-errors": "^3.0.0",
+    "ajv-formats": "^3.0.1",
+    "json-schema-to-typescript": "^14.1.0",
+    "json-source-map": "^0.6.1",
+    "semver": "^7.7.4",
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "@types/json-source-map": "^0.6.0",
+    "@types/semver": "^7.8.0"
+  }
+}

package/dist/packages/core/src/extension-api/extension-manager.d.ts

@@ -0,0 +1,35 @@
+import { ExtensionManifest, ExtensionLifecycle, CorePermission, ExtensionContext } from './types';
+export declare class ExtensionError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare enum ExtensionState {
+    REGISTERED = "REGISTERED",
+    INITIALIZED = "INITIALIZED",
+    CONFIGURED = "CONFIGURED",
+    VALIDATED = "VALIDATED",
+    ACTIVATED = "ACTIVATED"
+}
+export declare class ExtensionManager {
+    private extensions;
+    private capabilities;
+    private grantedPermissions;
+    registerExtension(manifest: ExtensionManifest, lifecycle: ExtensionLifecycle): void;
+    registerCapability(capability: string): void;
+    private validateManifest;
+    private negotiateCapabilities;
+    grantPermission(id: string, permission: CorePermission): void;
+    getDeclaredPermissions(id: string): CorePermission[];
+    getGrantedPermissions(id: string): CorePermission[];
+    hasPermission(id: string, permission: CorePermission): boolean;
+    checkPermission(id: string, permission: CorePermission): void;
+    private createSandboxContext;
+    private enforcePermissionsBeforeExecution;
+    resolveDependencyGraph(): string[];
+    initializeExtension(id: string, context?: ExtensionContext): Promise<void>;
+    configureExtension(id: string, config?: unknown): Promise<void>;
+    validateExtension(id: string): Promise<void>;
+    activateExtension(id: string): Promise<void>;
+    loadAll(context?: ExtensionContext, config?: unknown): Promise<void>;
+    getExtensionState(id: string): ExtensionState | undefined;
+}

package/dist/packages/core/src/extension-api/extension-manager.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionManager = exports.ExtensionState = exports.ExtensionError = void 0;
+const tslib_1 = require("tslib");
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const semver = tslib_1.__importStar(require("semver"));
+class ExtensionError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'ExtensionError';
+    }
+}
+exports.ExtensionError = ExtensionError;
+var ExtensionState;
+(function (ExtensionState) {
+    ExtensionState["REGISTERED"] = "REGISTERED";
+    ExtensionState["INITIALIZED"] = "INITIALIZED";
+    ExtensionState["CONFIGURED"] = "CONFIGURED";
+    ExtensionState["VALIDATED"] = "VALIDATED";
+    ExtensionState["ACTIVATED"] = "ACTIVATED";
+})(ExtensionState || (exports.ExtensionState = ExtensionState = {}));
+class ExtensionManager {
+    extensions = new Map();
+    capabilities = new Set();
+    grantedPermissions = new Map();
+    registerExtension(manifest, lifecycle) {
+        if (!manifest)
+            throw new ExtensionError('Manifest is required', 'INVALID_MANIFEST');
+        if (!lifecycle)
+            throw new ExtensionError('Lifecycle is required', 'INVALID_LIFECYCLE');
+        if (this.extensions.has(manifest.id)) {
+            throw new ExtensionError(`Extension already registered: ${manifest.id}`, 'DUPLICATE_EXTENSION');
+        }
+        this.validateManifest(manifest);
+        this.grantedPermissions.set(manifest.id, new Set());
+        this.extensions.set(manifest.id, { manifest, lifecycle, state: ExtensionState.REGISTERED });
+    }
+    registerCapability(capability) {
+        if (!/^[a-z0-9-]+:[a-z0-9-]+$/i.test(capability)) {
+            throw new ExtensionError(`Invalid capability format: ${capability}. Must be namespace:name`, 'INVALID_CAPABILITY_NAMESPACE');
+        }
+        this.capabilities.add(capability);
+    }
+    validateManifest(manifest) {
+        if (!manifest.id || !manifest.name || !manifest.version || !manifest.type) {
+            throw new ExtensionError('Invalid manifest: missing required fields', 'INVALID_MANIFEST');
+        }
+        if (!semver.valid(manifest.version)) {
+            throw new ExtensionError(`Invalid semver version: ${manifest.version}`, 'INVALID_VERSION');
+        }
+        if (manifest.grammarRanges) {
+            if (typeof manifest.grammarRanges !== 'object' || Array.isArray(manifest.grammarRanges)) {
+                throw new ExtensionError('grammarRanges must be an object', 'INVALID_MANIFEST');
+            }
+            for (const [key, range] of Object.entries(manifest.grammarRanges)) {
+                if (typeof range !== 'string' || !semver.validRange(range)) {
+                    throw new ExtensionError(`Invalid semver range for grammar ${key}: ${range}`, 'INVALID_GRAMMAR_RANGE');
+                }
+            }
+        }
+        if (manifest.apiRanges) {
+            if (typeof manifest.apiRanges !== 'object' || Array.isArray(manifest.apiRanges)) {
+                throw new ExtensionError('apiRanges must be an object', 'INVALID_MANIFEST');
+            }
+            for (const [key, range] of Object.entries(manifest.apiRanges)) {
+                if (typeof range !== 'string' || !semver.validRange(range)) {
+                    throw new ExtensionError(`Invalid semver range for API ${key}: ${range}`, 'INVALID_API_RANGE');
+                }
+            }
+        }
+        if (manifest.dependencies) {
+            if (typeof manifest.dependencies !== 'object' || Array.isArray(manifest.dependencies)) {
+                throw new ExtensionError('dependencies must be an object', 'INVALID_MANIFEST');
+            }
+            for (const [key, range] of Object.entries(manifest.dependencies)) {
+                if (typeof range !== 'string' || !semver.validRange(range)) {
+                    throw new ExtensionError(`Invalid dependency range for ${key}: ${range}`, 'INVALID_DEPENDENCY_RANGE');
+                }
+            }
+        }
+        if (manifest.permissions !== undefined) {
+            if (!Array.isArray(manifest.permissions) ||
+                manifest.permissions.some(p => typeof p !== 'string' || !p.trim())) {
+                throw new ExtensionError('permissions must be an array of non-empty strings', 'INVALID_MANIFEST');
+            }
+        }
+    }
+    negotiateCapabilities(manifest) {
+        if (manifest.capabilities) {
+            if (!Array.isArray(manifest.capabilities)) {
+                throw new ExtensionError('Capabilities must be an array', 'INVALID_MANIFEST');
+            }
+            for (const cap of manifest.capabilities) {
+                if (!this.capabilities.has(cap)) {
+                    throw new ExtensionError(`Missing required capability: ${cap}`, 'MISSING_CAPABILITY');
+                }
+            }
+        }
+    }
+    grantPermission(id, permission) {
+        const ext = this.extensions.get(id);
+        if (!ext)
+            throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+        if (ext.state !== ExtensionState.REGISTERED) {
+            throw new ExtensionError(`Cannot grant permissions after extension initialization (current state: ${ext.state})`, 'INVALID_LIFECYCLE');
+        }
+        const declaredPermissions = ext.manifest.permissions || [];
+        if (!declaredPermissions.includes(permission)) {
+            throw new ExtensionError(`Permission not declared in manifest: ${permission}`, 'UNDECLARED_PERMISSION');
+        }
+        const granted = this.grantedPermissions.get(id);
+        granted.add(permission);
+    }
+    getDeclaredPermissions(id) {
+        const ext = this.extensions.get(id);
+        if (!ext)
+            throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+        return ext.manifest.permissions || [];
+    }
+    getGrantedPermissions(id) {
+        const ext = this.extensions.get(id);
+        if (!ext)
+            throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+        return Array.from(this.grantedPermissions.get(id));
+    }
+    hasPermission(id, permission) {
+        const ext = this.extensions.get(id);
+        if (!ext)
+            throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+        return this.grantedPermissions.get(id).has(permission);
+    }
+    checkPermission(id, permission) {
+        if (!this.hasPermission(id, permission)) {
+            throw new ExtensionError(`Unauthorized access: Missing permission ${permission}`, 'UNAUTHORIZED_ACCESS');
+        }
+    }
+    createSandboxContext(id, baseContext) {
+        const context = baseContext || {};
+        return {
+            getEnv: context.getEnv
+                ? (key) => {
+                    this.checkPermission(id, 'env:read');
+                    return context.getEnv(key);
+                }
+                : undefined,
+            fetch: context.fetch
+                ? ((...args) => {
+                    this.checkPermission(id, 'network:fetch');
+                    return context.fetch(...args);
+                })
+                : undefined,
+            readFile: context.readFile
+                ? (path) => {
+                    this.checkPermission(id, 'fs:read');
+                    return context.readFile(path);
+                }
+                : undefined,
+            writeFile: context.writeFile
+                ? (path, data) => {
+                    this.checkPermission(id, 'fs:write');
+                    return context.writeFile(path, data);
+                }
+                : undefined,
+        };
+    }
+    enforcePermissionsBeforeExecution(manifest) {
+        const id = manifest.id;
+        const declared = manifest.permissions || [];
+        const granted = this.grantedPermissions.get(id);
+        for (const perm of declared) {
+            if (!granted.has(perm)) {
+                throw new ExtensionError(`Cannot execute extension ${id}: Missing required permission ${perm}`, 'UNAUTHORIZED_ACCESS');
+            }
+        }
+    }
+    resolveDependencyGraph() {
+        const adjList = new Map();
+        for (const [id, { manifest }] of this.extensions.entries()) {
+            const deps = manifest.dependencies ? Object.keys(manifest.dependencies) : [];
+            for (const [depId, range] of Object.entries(manifest.dependencies || {})) {
+                const target = this.extensions.get(depId);
+                if (!target) {
+                    throw new ExtensionError(`Missing required dependency: ${depId}`, 'MISSING_DEPENDENCY');
+                }
+                if (!semver.satisfies(target.manifest.version, range)) {
+                    throw new ExtensionError(`Dependency version mismatch for ${depId}. Expected ${range}, got ${target.manifest.version}`, 'DEPENDENCY_VERSION_MISMATCH');
+                }
+            }
+            adjList.set(id, deps);
+        }
+        const visited = new Set();
+        const visiting = new Set();
+        const sorted = [];
+        const dfs = (node, path) => {
+            if (visiting.has(node)) {
+                const cycleStartIndex = path.indexOf(node);
+                const loop = cycleStartIndex >= 0 ? path.slice(cycleStartIndex) : path;
+                const cyclePath = [...loop, node].join(' -> ');
+                throw new ExtensionError(`Cyclic dependency detected: ${cyclePath}`, 'CYCLIC_DEPENDENCY');
+            }
+            if (visited.has(node))
+                return;
+            visiting.add(node);
+            path.push(node);
+            const deps = adjList.get(node) || [];
+            for (const dep of deps) {
+                dfs(dep, path);
+            }
+            path.pop();
+            visiting.delete(node);
+            visited.add(node);
+            sorted.push(node); // post-order (dependencies added before the node that depends on them)
+        };
+        for (const id of this.extensions.keys()) {
+            if (!visited.has(id)) {
+                dfs(id, []);
+            }
+        }
+        return sorted;
+    }
+    async initializeExtension(id, context) {
+        const ext = this.extensions.get(id);
+        if (!ext)
+            throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+        if (ext.state !== ExtensionState.REGISTERED) {
+            throw new ExtensionError(`Cannot initialize extension in state ${ext.state}`, 'INVALID_LIFECYCLE');
+        }
+        this.enforcePermissionsBeforeExecution(ext.manifest);
+        this.negotiateCapabilities(ext.manifest);
+        const sandboxedContext = this.createSandboxContext(id, context);
+        await ext.lifecycle.initialize(sandboxedContext);
+        ext.state = ExtensionState.INITIALIZED;
+    }
+    async configureExtension(id, config) {
+        const ext = this.extensions.get(id);
+        if (!ext)
+            throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+        if (ext.state !== ExtensionState.INITIALIZED) {
+            throw new ExtensionError(`Cannot configure extension in state ${ext.state}`, 'INVALID_LIFECYCLE');
+        }
+        this.enforcePermissionsBeforeExecution(ext.manifest);
+        await ext.lifecycle.configure(config);
+        ext.state = ExtensionState.CONFIGURED;
+    }
+    async validateExtension(id) {
+        const ext = this.extensions.get(id);
+        if (!ext)
+            throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+        if (ext.state !== ExtensionState.CONFIGURED) {
+            throw new ExtensionError(`Cannot validate extension in state ${ext.state}`, 'INVALID_LIFECYCLE');
+        }
+        this.enforcePermissionsBeforeExecution(ext.manifest);
+        const isValid = await ext.lifecycle.validate();
+        if (!isValid) {
+            throw new ExtensionError(`Extension failed validation: ${id}`, 'VALIDATION_FAILED');
+        }
+        ext.state = ExtensionState.VALIDATED;
+    }
+    async activateExtension(id) {
+        const ext = this.extensions.get(id);
+        if (!ext)
+            throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+        if (ext.state !== ExtensionState.VALIDATED) {
+            throw new ExtensionError(`Cannot activate extension in state ${ext.state}`, 'INVALID_LIFECYCLE');
+        }
+        this.enforcePermissionsBeforeExecution(ext.manifest);
+        await ext.lifecycle.activate();
+        ext.state = ExtensionState.ACTIVATED;
+    }
+    async loadAll(context, config) {
+        const sortedIds = this.resolveDependencyGraph();
+        for (const id of sortedIds) {
+            if (this.getExtensionState(id) === ExtensionState.REGISTERED) {
+                await this.initializeExtension(id, context);
+            }
+        }
+        for (const id of sortedIds) {
+            if (this.getExtensionState(id) === ExtensionState.INITIALIZED) {
+                await this.configureExtension(id, config);
+            }
+        }
+        for (const id of sortedIds) {
+            if (this.getExtensionState(id) === ExtensionState.CONFIGURED) {
+                await this.validateExtension(id);
+            }
+        }
+        for (const id of sortedIds) {
+            if (this.getExtensionState(id) === ExtensionState.VALIDATED) {
+                await this.activateExtension(id);
+            }
+        }
+    }
+    getExtensionState(id) {
+        return this.extensions.get(id)?.state;
+    }
+}
+exports.ExtensionManager = ExtensionManager;
+//# sourceMappingURL=extension-manager.js.map