veryfront 0.1.215 → 0.1.217

package/esm/src/extensions/capabilities.js

@@ -0,0 +1,77 @@
+/**
+ * Capability audit logging and Deno permission mapping.
+ *
+ * @module extensions/capabilities
+ */
+/**
+ * Format capabilities as human-readable strings for logging.
+ */
+export function formatCapabilities(capabilities) {
+    return capabilities.map((cap) => {
+        if (cap.type === "contract") {
+            return `contract: ${cap.name}`;
+        }
+        const { type, ...rest } = cap;
+        const extras = Object.keys(rest);
+        if (extras.length === 0)
+            return type;
+        const details = extras
+            .map((key) => `${key}: ${JSON.stringify(rest[key])}`)
+            .join(", ");
+        return `${type} (${details})`;
+    });
+}
+const DENO_PERMISSION_MAP = {
+    "fs:read": { flag: "--allow-read", scopeKey: "paths" },
+    "fs:write": { flag: "--allow-write", scopeKey: "paths" },
+    "net:outbound": { flag: "--allow-net", scopeKey: "hosts" },
+    "net:listen": {
+        flag: "--allow-net",
+        resolveScopes: (cap) => {
+            const ports = cap.ports;
+            if (!ports || ports.length === 0)
+                return [];
+            const host = cap.host || "localhost";
+            return ports.map((p) => `${host}:${p}`);
+        },
+    },
+    "env:read": { flag: "--allow-env", scopeKey: "keys" },
+    "process:spawn": { flag: "--allow-run", scopeKey: "commands" },
+    "native:ffi": { flag: "--allow-ffi" },
+};
+/**
+ * Map capabilities to Deno CLI permission flags.
+ * Skips non-system capabilities (e.g., "contract").
+ */
+export function mapToDenoPermissions(capabilities) {
+    const seen = new Set();
+    const flags = [];
+    for (const cap of capabilities) {
+        const mapping = DENO_PERMISSION_MAP[cap.type];
+        if (!mapping)
+            continue;
+        let flag = mapping.flag;
+        const scopes = mapping.resolveScopes
+            ? mapping.resolveScopes(cap)
+            : mapping.scopeKey
+                ? cap[mapping.scopeKey] ?? []
+                : [];
+        if (scopes.length > 0) {
+            flag = `${flag}=${scopes.join(",")}`;
+        }
+        if (!seen.has(flag)) {
+            seen.add(flag);
+            flags.push(flag);
+        }
+    }
+    return flags;
+}
+/**
+ * Log capabilities for a named extension at startup.
+ */
+export function auditCapabilities(extensionName, capabilities, logger) {
+    if (capabilities.length === 0)
+        return;
+    const lines = formatCapabilities(capabilities);
+    logger.info(`Extension "${extensionName}" declares capabilities:`, ...lines);
+}

package/esm/src/extensions/contracts.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Contract registry — runtime resolution of extension-provided implementations.
+ *
+ * @module extensions/contracts
+ */
+export declare function resolve<T>(name: string): T;
+export declare function tryResolve<T>(name: string): T | undefined;
+export declare function register<T>(name: string, impl: T): void;
+export declare function reset(): void;
+//# sourceMappingURL=contracts.d.ts.map

package/esm/src/extensions/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../src/src/extensions/contracts.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAY1C;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAEzD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAEvD;AAED,wBAAgB,KAAK,IAAI,IAAI,CAE5B"}

package/esm/src/extensions/contracts.js

@@ -0,0 +1,28 @@
+/**
+ * Contract registry — runtime resolution of extension-provided implementations.
+ *
+ * @module extensions/contracts
+ */
+import { MISSING_EXTENSION_ERROR } from "./errors.js";
+import { getRecommendation } from "./recommendations.js";
+const contracts = new Map();
+export function resolve(name) {
+    const impl = contracts.get(name);
+    if (impl === undefined) {
+        const recommendation = getRecommendation(name);
+        throw MISSING_EXTENSION_ERROR.create({
+            message: `Missing extension for contract "${name}"${recommendation ? `. Recommended: ${recommendation}` : ""}`,
+            detail: recommendation ? `Install it with: deno add ${recommendation}` : undefined,
+        });
+    }
+    return impl;
+}
+export function tryResolve(name) {
+    return contracts.get(name);
+}
+export function register(name, impl) {
+    contracts.set(name, impl);
+}
+export function reset() {
+    contracts.clear();
+}

package/esm/src/extensions/discovery.d.ts

@@ -0,0 +1,48 @@
+import type { Capability, ResolvedExtension } from "./types.js";
+/**
+ * Metadata extracted from a package.json that declares itself
+ * as a veryfront extension.
+ */
+export interface PackageMetadata {
+    isExtension: true;
+    capabilities: Capability[];
+}
+/**
+ * Parse veryfront extension metadata from a package.json-like object.
+ *
+ * Returns `PackageMetadata` when the package declares
+ * `veryfront.extension: true`, otherwise `undefined`. Malformed capability
+ * entries are filtered out; the caller receives only valid shapes.
+ */
+export declare function parsePackageMetadata(pkg: Record<string, unknown>): PackageMetadata | undefined;
+/**
+ * Merge extensions from all four sources in priority order.
+ *
+ * Priority (highest first): config > package > project > local-file.
+ * Duplicates are resolved by keeping the highest-priority entry.
+ * Disable directives (`{ name, enabled: false }`) remove matching
+ * extensions regardless of source.
+ */
+export declare function mergeExtensions(config: ResolvedExtension[], packages: ResolvedExtension[], project: ResolvedExtension[], local: ResolvedExtension[], disableDirectives?: Array<{
+    name: string;
+    enabled: false;
+}>): ResolvedExtension[];
+/**
+ * Scan `node_modules` (including `@scoped` packages) for packages
+ * that declare veryfront extension metadata in their `package.json`.
+ */
+export declare function discoverPackageExtensions(baseDir: string): Promise<Array<{
+    packageName: string;
+    metadata: PackageMetadata;
+}>>;
+/**
+ * Discover project extensions living under `extensions/` in the project root.
+ *
+ * Looks for `extensions/<name>/src/index.ts` and `extensions/<name>/index.ts`.
+ */
+export declare function discoverProjectExtensions(baseDir: string): Promise<string[]>;
+/**
+ * Find `*.extension.ts` files in the project root.
+ */
+export declare function discoverLocalExtensions(baseDir: string): Promise<string[]>;
+//# sourceMappingURL=discovery.d.ts.map

package/esm/src/extensions/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/src/extensions/discovery.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEhE;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,IAAI,CAAC;IAClB,YAAY,EAAE,UAAU,EAAE,CAAC;CAC5B;AAUD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,eAAe,GAAG,SAAS,CAmB7B;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,iBAAiB,EAAE,EAC3B,QAAQ,EAAE,iBAAiB,EAAE,EAC7B,OAAO,EAAE,iBAAiB,EAAE,EAC5B,KAAK,EAAE,iBAAiB,EAAE,EAC1B,iBAAiB,CAAC,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,KAAK,CAAA;CAAE,CAAC,GAC1D,iBAAiB,EAAE,CAwBrB;AA6BD;;;GAGG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,KAAK,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,CAAC,CAAC,CA4BpE;AAqBD;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,EAAE,CAAC,CAkBnB;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,EAAE,CAAC,CAKnB"}

package/esm/src/extensions/discovery.js

@@ -0,0 +1,179 @@
+/**
+ * Multi-source extension discovery.
+ *
+ * Discovers extensions from four sources with priority:
+ *   config > package > project > local-file
+ *
+ * @module extensions/discovery
+ */
+import * as dntShim from "../../_dnt.shims.js";
+import { join } from "../../deps/jsr.io/@std/path/1.1.4/mod.js";
+function isCapability(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const cap = value;
+    return typeof cap.type === "string" && cap.type.length > 0;
+}
+/**
+ * Parse veryfront extension metadata from a package.json-like object.
+ *
+ * Returns `PackageMetadata` when the package declares
+ * `veryfront.extension: true`, otherwise `undefined`. Malformed capability
+ * entries are filtered out; the caller receives only valid shapes.
+ */
+export function parsePackageMetadata(pkg) {
+    const vf = pkg.veryfront;
+    if (vf === null || vf === undefined || typeof vf !== "object" ||
+        Array.isArray(vf)) {
+        return undefined;
+    }
+    const meta = vf;
+    if (meta.extension !== true) {
+        return undefined;
+    }
+    const capabilities = Array.isArray(meta.capabilities)
+        ? meta.capabilities.filter(isCapability)
+        : [];
+    return { isExtension: true, capabilities };
+}
+/**
+ * Merge extensions from all four sources in priority order.
+ *
+ * Priority (highest first): config > package > project > local-file.
+ * Duplicates are resolved by keeping the highest-priority entry.
+ * Disable directives (`{ name, enabled: false }`) remove matching
+ * extensions regardless of source.
+ */
+export function mergeExtensions(config, packages, project, local, disableDirectives) {
+    const disabledNames = new Set((disableDirectives ?? []).map((d) => d.name));
+    const seen = new Map();
+    // Process sources in priority order -- first write wins.
+    const ordered = [
+        ...config,
+        ...packages,
+        ...project,
+        ...local,
+    ];
+    for (const resolved of ordered) {
+        const name = resolved.extension.name;
+        if (disabledNames.has(name))
+            continue;
+        if (!seen.has(name)) {
+            seen.set(name, resolved);
+        }
+    }
+    return [...seen.values()];
+}
+// ---------------------------------------------------------------------------
+// Filesystem discovery helpers
+// ---------------------------------------------------------------------------
+async function readDir(path) {
+    try {
+        const entries = [];
+        for await (const entry of dntShim.Deno.readDir(path)) {
+            entries.push(entry);
+        }
+        return entries;
+    }
+    catch (err) {
+        if (err instanceof dntShim.Deno.errors.NotFound)
+            return [];
+        throw err;
+    }
+}
+async function fileExists(path) {
+    try {
+        await dntShim.Deno.stat(path);
+        return true;
+    }
+    catch (err) {
+        if (err instanceof dntShim.Deno.errors.NotFound)
+            return false;
+        throw err;
+    }
+}
+/**
+ * Scan `node_modules` (including `@scoped` packages) for packages
+ * that declare veryfront extension metadata in their `package.json`.
+ */
+export async function discoverPackageExtensions(baseDir) {
+    const nmDir = join(baseDir, "node_modules");
+    const results = [];
+    const entries = await readDir(nmDir);
+    for (const entry of entries) {
+        // Accept symlinks so pnpm-style node_modules layouts are discovered.
+        if (!entry.isDirectory && !entry.isSymlink)
+            continue;
+        if (entry.name.startsWith("@")) {
+            // Scoped packages -- iterate one level deeper.
+            const scopeDir = join(nmDir, entry.name);
+            const scopeEntries = await readDir(scopeDir);
+            for (const scopeEntry of scopeEntries) {
+                if (!scopeEntry.isDirectory && !scopeEntry.isSymlink)
+                    continue;
+                const pkgName = `${entry.name}/${scopeEntry.name}`;
+                const meta = await tryReadPackageMeta(join(scopeDir, scopeEntry.name));
+                if (meta)
+                    results.push({ packageName: pkgName, metadata: meta });
+            }
+        }
+        else {
+            const meta = await tryReadPackageMeta(join(nmDir, entry.name));
+            if (meta)
+                results.push({ packageName: entry.name, metadata: meta });
+        }
+    }
+    return results;
+}
+async function tryReadPackageMeta(pkgDir) {
+    let raw;
+    try {
+        raw = await dntShim.Deno.readTextFile(join(pkgDir, "package.json"));
+    }
+    catch (err) {
+        if (err instanceof dntShim.Deno.errors.NotFound)
+            return undefined;
+        throw err;
+    }
+    try {
+        const pkg = JSON.parse(raw);
+        return parsePackageMetadata(pkg);
+    }
+    catch {
+        // Malformed JSON -- treat as non-extension package.
+        return undefined;
+    }
+}
+/**
+ * Discover project extensions living under `extensions/` in the project root.
+ *
+ * Looks for `extensions/<name>/src/index.ts` and `extensions/<name>/index.ts`.
+ */
+export async function discoverProjectExtensions(baseDir) {
+    const extDir = join(baseDir, "extensions");
+    const entries = await readDir(extDir);
+    const results = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory)
+            continue;
+        const srcIndex = join(extDir, entry.name, "src", "index.ts");
+        const rootIndex = join(extDir, entry.name, "index.ts");
+        if (await fileExists(srcIndex)) {
+            results.push(srcIndex);
+        }
+        else if (await fileExists(rootIndex)) {
+            results.push(rootIndex);
+        }
+    }
+    return results;
+}
+/**
+ * Find `*.extension.ts` files in the project root.
+ */
+export async function discoverLocalExtensions(baseDir) {
+    const entries = await readDir(baseDir);
+    return entries
+        .filter((e) => !e.isDirectory && e.name.endsWith(".extension.ts"))
+        .map((e) => join(baseDir, e.name));
+}

package/esm/src/extensions/errors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Extension system error definitions.
+ *
+ * @module extensions/errors
+ */
+export declare const MISSING_EXTENSION_ERROR: import("../errors/types.js").RegisteredError;
+export declare const EXTENSION_VALIDATION_ERROR: import("../errors/types.js").RegisteredError;
+export declare const CIRCULAR_DEPENDENCY_ERROR: import("../errors/types.js").RegisteredError;
+export declare const EXTENSION_CONFLICT_ERROR: import("../errors/types.js").RegisteredError;
+//# sourceMappingURL=errors.d.ts.map

package/esm/src/extensions/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/src/extensions/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,eAAO,MAAM,uBAAuB,8CAMlC,CAAC;AAEH,eAAO,MAAM,0BAA0B,8CAMrC,CAAC;AAEH,eAAO,MAAM,yBAAyB,8CAMpC,CAAC;AAEH,eAAO,MAAM,wBAAwB,8CAMnC,CAAC"}

package/esm/src/extensions/errors.js

@@ -0,0 +1,34 @@
+/**
+ * Extension system error definitions.
+ *
+ * @module extensions/errors
+ */
+import { defineError } from "../errors/index.js";
+export const MISSING_EXTENSION_ERROR = defineError({
+    slug: "missing-extension",
+    category: "RUNTIME",
+    status: 500,
+    title: "Required extension not found",
+    suggestion: "Install the missing extension package and add it to your configuration",
+});
+export const EXTENSION_VALIDATION_ERROR = defineError({
+    slug: "extension-validation",
+    category: "CONFIG",
+    status: 422,
+    title: "Extension validation failed",
+    suggestion: "Check that the extension exports a valid name, version, and capabilities array",
+});
+export const CIRCULAR_DEPENDENCY_ERROR = defineError({
+    slug: "extension-circular-dependency",
+    category: "CONFIG",
+    status: 422,
+    title: "Circular dependency detected between extensions",
+    suggestion: "Review the 'extends' fields in your extensions to break the cycle",
+});
+export const EXTENSION_CONFLICT_ERROR = defineError({
+    slug: "extension-conflict",
+    category: "CONFIG",
+    status: 409,
+    title: "Conflicting extensions detected",
+    suggestion: "Remove or disable one of the conflicting extensions in your configuration",
+});

package/esm/src/extensions/factory-loader.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Dynamic factory loader.
+ *
+ * Loads an extension factory from a filesystem path by dynamic import,
+ * invokes it, and wraps the result as a `ResolvedExtension`.
+ *
+ * @module extensions/factory-loader
+ */
+import type { ExtensionSource, ResolvedExtension } from "./types.js";
+/**
+ * Dynamically import an extension factory from `path` and resolve it.
+ *
+ * `path` may be either an absolute filesystem path (for project and
+ * local-file sources) or a bare module specifier (for `package` source).
+ * Absolute paths are converted to `file://` URLs; bare specifiers are
+ * passed through so the runtime's module resolver can find them.
+ *
+ * The module must `export default` an `ExtensionFactory` (a function that
+ * returns an `Extension`). On any error — missing default export, default
+ * export that is not a function, factory throw, or import failure — this
+ * throws `EXTENSION_VALIDATION_ERROR` with a `detail` field that names the
+ * path and what went wrong.
+ *
+ * @param path Absolute filesystem path or bare module specifier.
+ * @param source Where the extension was discovered (drives merge priority).
+ * @param config Optional config forwarded to the factory.
+ */
+export declare function loadExtensionFactory(path: string, source: ExtensionSource, config?: unknown): Promise<ResolvedExtension>;
+//# sourceMappingURL=factory-loader.d.ts.map

package/esm/src/extensions/factory-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory-loader.d.ts","sourceRoot":"","sources":["../../../src/src/extensions/factory-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAA+B,eAAe,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAElG;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,OAAO,GACf,OAAO,CAAC,iBAAiB,CAAC,CAwC5B"}

package/esm/src/extensions/factory-loader.js

@@ -0,0 +1,63 @@
+/**
+ * Dynamic factory loader.
+ *
+ * Loads an extension factory from a filesystem path by dynamic import,
+ * invokes it, and wraps the result as a `ResolvedExtension`.
+ *
+ * @module extensions/factory-loader
+ */
+import { isAbsolute, toFileUrl } from "../../deps/jsr.io/@std/path/1.1.4/mod.js";
+import { EXTENSION_VALIDATION_ERROR } from "./errors.js";
+/**
+ * Dynamically import an extension factory from `path` and resolve it.
+ *
+ * `path` may be either an absolute filesystem path (for project and
+ * local-file sources) or a bare module specifier (for `package` source).
+ * Absolute paths are converted to `file://` URLs; bare specifiers are
+ * passed through so the runtime's module resolver can find them.
+ *
+ * The module must `export default` an `ExtensionFactory` (a function that
+ * returns an `Extension`). On any error — missing default export, default
+ * export that is not a function, factory throw, or import failure — this
+ * throws `EXTENSION_VALIDATION_ERROR` with a `detail` field that names the
+ * path and what went wrong.
+ *
+ * @param path Absolute filesystem path or bare module specifier.
+ * @param source Where the extension was discovered (drives merge priority).
+ * @param config Optional config forwarded to the factory.
+ */
+export async function loadExtensionFactory(path, source, config) {
+    const specifier = isAbsolute(path) ? toFileUrl(path).href : path;
+    let mod;
+    try {
+        mod = await import(specifier);
+    }
+    catch (err) {
+        throw EXTENSION_VALIDATION_ERROR.create({
+            detail: `Failed to import extension at "${path}": ${err instanceof Error ? err.message : String(err)}`,
+            cause: err,
+        });
+    }
+    const factory = mod.default;
+    if (factory === undefined || factory === null) {
+        throw EXTENSION_VALIDATION_ERROR.create({
+            detail: `Extension at "${path}" has no default export`,
+        });
+    }
+    if (typeof factory !== "function") {
+        throw EXTENSION_VALIDATION_ERROR.create({
+            detail: `Extension at "${path}" default export is not a function (got ${typeof factory})`,
+        });
+    }
+    let extension;
+    try {
+        extension = factory(config);
+    }
+    catch (err) {
+        throw EXTENSION_VALIDATION_ERROR.create({
+            detail: `Extension factory at "${path}" threw during invocation: ${err instanceof Error ? err.message : String(err)}`,
+            cause: err,
+        });
+    }
+    return { extension, source, origin: path };
+}

package/esm/src/extensions/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Public extension API surface.
+ *
+ * Types used when authoring extensions (the scaffold template generated by
+ * `veryfront extension init` imports from this module), plus the runtime
+ * helpers consumers need to load, validate, and orchestrate extensions.
+ *
+ * @module extensions
+ * @example
+ * ```ts
+ * import { orchestrateExtensions } from "veryfront/extensions";
+ *
+ * const loader = await orchestrateExtensions({
+ *   projectDir: Deno.cwd(),
+ *   config,
+ *   logger,
+ * });
+ *
+ * // Later, on shutdown:
+ * await loader.teardownAll();
+ * ```
+ */
+import "../../_dnt.polyfills.js";
+export type { Capability, Extension, ExtensionConfigEntry, ExtensionContext, ExtensionFactory, ExtensionLogger, ExtensionSource, ResolvedExtension, } from "./types.js";
+export { resolve, tryResolve } from "./contracts.js";
+export type { PackageMetadata } from "./discovery.js";
+export { discoverLocalExtensions, discoverPackageExtensions, discoverProjectExtensions, mergeExtensions, parsePackageMetadata, } from "./discovery.js";
+export { ExtensionLoader } from "./loader.js";
+export { loadExtensionFactory } from "./factory-loader.js";
+export type { OrchestrateOptions } from "./orchestrate.js";
+export { orchestrateExtensions } from "./orchestrate.js";
+export type { ConflictInfo } from "./validation.js";
+export { detectConflicts, validateExtension } from "./validation.js";
+export { auditCapabilities, formatCapabilities, mapToDenoPermissions } from "./capabilities.js";
+export { getRecommendation } from "./recommendations.js";
+export { CIRCULAR_DEPENDENCY_ERROR, EXTENSION_CONFLICT_ERROR, EXTENSION_VALIDATION_ERROR, MISSING_EXTENSION_ERROR, } from "./errors.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/src/extensions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/extensions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,yBAAyB,CAAC;AAEjC,YAAY,EACV,UAAU,EACV,SAAS,EACT,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAKpB,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGrD,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EACL,uBAAuB,EACvB,yBAAyB,EACzB,yBAAyB,EACzB,eAAe,EACf,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAG9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAGzD,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAGrE,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGhG,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAGzD,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,aAAa,CAAC"}

package/esm/src/extensions/index.js

@@ -0,0 +1,41 @@
+/**
+ * Public extension API surface.
+ *
+ * Types used when authoring extensions (the scaffold template generated by
+ * `veryfront extension init` imports from this module), plus the runtime
+ * helpers consumers need to load, validate, and orchestrate extensions.
+ *
+ * @module extensions
+ * @example
+ * ```ts
+ * import { orchestrateExtensions } from "veryfront/extensions";
+ *
+ * const loader = await orchestrateExtensions({
+ *   projectDir: Deno.cwd(),
+ *   config,
+ *   logger,
+ * });
+ *
+ * // Later, on shutdown:
+ * await loader.teardownAll();
+ * ```
+ */
+// Core types
+import "../../_dnt.polyfills.js";
+// Contract registry — resolve/tryResolve are the consumer-facing API.
+// register()/reset() are internal primitives (used by ExtensionLoader and
+// tests) and are intentionally not exported here.
+export { resolve, tryResolve } from "./contracts.js";
+export { discoverLocalExtensions, discoverPackageExtensions, discoverProjectExtensions, mergeExtensions, parsePackageMetadata, } from "./discovery.js";
+// Loader
+export { ExtensionLoader } from "./loader.js";
+// Factory loader (dynamic-import of an extension factory)
+export { loadExtensionFactory } from "./factory-loader.js";
+export { orchestrateExtensions } from "./orchestrate.js";
+export { detectConflicts, validateExtension } from "./validation.js";
+// Capabilities
+export { auditCapabilities, formatCapabilities, mapToDenoPermissions } from "./capabilities.js";
+// Recommendations
+export { getRecommendation } from "./recommendations.js";
+// Errors
+export { CIRCULAR_DEPENDENCY_ERROR, EXTENSION_CONFLICT_ERROR, EXTENSION_VALIDATION_ERROR, MISSING_EXTENSION_ERROR, } from "./errors.js";