experimental-ash 0.26.0 → 0.28.0

package/dist/src/internal/authored-definition/schema-backed.js

@@ -1,56 +1 @@
-import { isDisabledToolSentinel } from "#public/definitions/tool.js";
-import { expectFunction, expectObjectRecord, expectOnlyKnownKeys, expectString, } from "#internal/authored-module.js";
-import { normalizeJsonSchemaDefinition } from "#internal/json-schema.js";
-/**
- * Normalizes one authored tool default export. Recognizes both real tool
- * definitions (`defineTool(...)`) and disable sentinels (`disableTool()`).
- *
- * Authored `name` fields are rejected — tool identity is path-derived.
- */
-export function normalizeToolDefinition(value, message) {
-    if (isDisabledToolSentinel(value)) {
-        return { kind: "disabled" };
-    }
-    const record = expectObjectRecord(value, message);
-    expectOnlyKnownKeys(record, [
-        "description",
-        "execute",
-        "inputSchema",
-        "needsApproval",
-        "onCompact",
-        "retentionPolicy",
-        "toModelOutput",
-    ], message);
-    const inputSchema = record.inputSchema === undefined ? null : normalizeJsonSchemaDefinition(record.inputSchema);
-    const definition = {
-        description: expectString(record.description, message),
-        execute: expectFunction(record.execute, message),
-        inputSchema,
-    };
-    /*
-     * The compiler runs at build time and only validates that optional hooks
-     * (`onCompact`, `needsApproval`, `retentionPolicy`), when present, have the
-     * expected shape. The live references are captured later by
-     * `resolve-agent.ts` when it materializes the module export and attaches
-     * them to the ResolvedToolDefinition.
-     */
-    if (record.onCompact !== undefined) {
-        expectFunction(record.onCompact, message);
-    }
-    if (record.needsApproval !== undefined) {
-        expectFunction(record.needsApproval, message);
-    }
-    if (record.retentionPolicy !== undefined) {
-        const policy = record.retentionPolicy;
-        if (policy !== "auto" && policy !== "keep" && typeof policy !== "function") {
-            throw new Error(`${message} Expected \`retentionPolicy\` to be "auto", "keep", or a function.`);
-        }
-    }
-    if (record.toModelOutput !== undefined) {
-        expectFunction(record.toModelOutput, message);
-    }
-    return {
-        kind: "tool",
-        definition,
-    };
-}
+import{expectFunction,expectObjectRecord,expectOnlyKnownKeys,expectString}from"#internal/authored-module.js";import{isDisabledToolSentinel}from"#public/definitions/tool.js";import{normalizeJsonSchemaDefinition}from"#internal/json-schema.js";function normalizeToolDefinition(t,n){if(isDisabledToolSentinel(t))return{kind:`disabled`};let r=expectObjectRecord(t,n);expectOnlyKnownKeys(r,[`description`,`execute`,`inputSchema`,`needsApproval`,`onCompact`,`retentionPolicy`,`toModelOutput`],n);let i=r.inputSchema===void 0?null:normalizeJsonSchemaDefinition(r.inputSchema),a={description:expectString(r.description,n),execute:expectFunction(r.execute,n),inputSchema:i};if(r.onCompact!==void 0&&expectFunction(r.onCompact,n),r.needsApproval!==void 0&&expectFunction(r.needsApproval,n),r.retentionPolicy!==void 0){let e=r.retentionPolicy;if(e!==`auto`&&e!==`keep`&&typeof e!=`function`)throw Error(`${n} Expected \`retentionPolicy\` to be "auto", "keep", or a function.`)}return r.toModelOutput!==void 0&&expectFunction(r.toModelOutput,n),{kind:`tool`,definition:a}}export{normalizeToolDefinition};

package/dist/src/internal/authored-module-bundle.js

@@ -1,19 +1,2 @@
-/**
- * Adds actionable context to lower-level authored module bundling failures.
- */
-export function createAuthoredModuleBundleError(modulePath, error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const hints = [];
-    if (/\.node(?:\b|["'?])/i.test(message) ||
-        /native addon|native module|invalid utf-?8|Could not load .*\.node/i.test(message)) {
-        hints.push("If this comes from a native Node package, keep that package external with agent build.externalDependencies so Vercel/Nitro traces it instead of bundling it.");
-    }
-    if (/Unexpected character|No loader is configured|Could not load|Unknown file extension/i.test(message)) {
-        hints.push("If this comes from an asset import, Ash only supports assets that Rolldown can emit for a Node ESM bundle; otherwise load the file through fs/import.meta.url or externalize the package.");
-    }
-    return new Error([
-        `Failed to bundle authored module "${modulePath}".`,
-        message,
-        ...hints.map((hint) => `Hint: ${hint}`),
-    ].join("\n"));
-}
+function createAuthoredModuleBundleError(e,t){let n=t instanceof Error?t.message:String(t),r=[];return(/\.node(?:\b|["'?])/i.test(n)||/native addon|native module|invalid utf-?8|Could not load .*\.node/i.test(n))&&r.push(`If this comes from a native Node package, keep that package external with agent build.externalDependencies so Vercel/Nitro traces it instead of bundling it.`),/Unexpected character|No loader is configured|Could not load|Unknown file extension/i.test(n)&&r.push(`If this comes from an asset import, Ash only supports assets that Rolldown can emit for a Node ESM bundle; otherwise load the file through fs/import.meta.url or externalize the package.`),Error([`Failed to bundle authored module "${e}".`,n,...r.map(e=>`Hint: ${e}`)].join(`
+`))}export{createAuthoredModuleBundleError};

package/dist/src/internal/authored-module-loader.js

@@ -1,263 +1,2 @@
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve, sep } from "node:path";
-import { createAuthoredAssetImportPlugin } from "#internal/authored-asset-import-plugin.js";
-import { createAuthoredModuleBundleError } from "#internal/authored-module-bundle.js";
-import { createAuthoredPackageTsConfigPathsPlugin } from "#internal/authored-package-tsconfig-paths.js";
-import { expectObjectRecord } from "#internal/authored-module.js";
-import { buildWithNitroRolldown, getSingleRolldownChunk, } from "#internal/bundler/nitro-rolldown.js";
-import { createNodeEsmCompatBannerPlugin } from "#internal/node-esm-compat-banner.js";
-const AUTHORED_BUNDLED_MODULE_EXTENSION = /\.[cm]?[jt]sx?$/;
-const AUTHORED_MODULE_BUNDLE_DIRECTORY_PATH = join("node_modules", ".cache", "experimental-ash", "authored-modules");
-const RESOLVE_EXTENSIONS = [
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".json",
-];
-const CHANNEL_MODULE_CACHE_KEY = "__ashChannelModuleCache__";
-const CACHED_CHANNEL_PREFIX = "ash-cached-channel:";
-function getChannelModuleCache() {
-    return globalThis[CHANNEL_MODULE_CACHE_KEY];
-}
-/**
- * In-flight load deduplication map keyed by the absolute module path.
- *
- * The compiler walks every authored slot concurrently
- * (`compileChannelDefinition` and `buildChannelRouteIdentityMap` both
- * load the same channel module via `Promise.all`), so the same module
- * path is frequently loaded twice in parallel. Without dedup, both
- * callers race the bundler write/import pipeline against the
- * same `node_modules/.cache/.../<hash>.mjs` file: one call's
- * `writeFile` can truncate the bundle while another's `import()` is
- * still resolving it, surfacing as intermittent
- * "Expected … to match the public Ash shape" failures during
- * compilation.
- *
- * The map only holds in-flight promises; once a load settles the entry
- * is cleared so subsequent compiles (e.g. a dev-server reload after
- * the author edits a file) re-run the bundle pipeline against the
- * fresh source. Node's ESM cache then dedupes by content-hashed URL for
- * unchanged files. The companion "skip write when the cache file already
- * exists" check inside {@link loadBundledAuthoredModule} eliminates the
- * write/read race even when two non-concurrent compile passes overlap on
- * the same hashed bundle path.
- */
-const inFlightModuleLoads = new Map();
-/**
- * Loads one authored module namespace from disk during compile-time
- * discovery. Concurrent loads of the same `modulePath` share a single
- * Promise so the underlying bundle/import pipeline runs once.
- */
-export function loadAuthoredModuleNamespace(modulePath) {
-    const cacheKey = resolve(modulePath);
-    const inFlight = inFlightModuleLoads.get(cacheKey);
-    if (inFlight !== undefined) {
-        return inFlight;
-    }
-    const loadPromise = (async () => {
-        try {
-            return await doLoadAuthoredModuleNamespace(modulePath);
-        }
-        finally {
-            inFlightModuleLoads.delete(cacheKey);
-        }
-    })();
-    inFlightModuleLoads.set(cacheKey, loadPromise);
-    return loadPromise;
-}
-async function doLoadAuthoredModuleNamespace(modulePath) {
-    const loadedModule = AUTHORED_BUNDLED_MODULE_EXTENSION.test(modulePath)
-        ? await loadBundledAuthoredModule(modulePath)
-        : await import(createFileImportSpecifier(modulePath));
-    return expectObjectRecord(loadedModule, `Expected "${modulePath}" to export a module namespace object.`);
-}
-function createFileImportSpecifier(modulePath) {
-    const normalizedPath = modulePath.replaceAll("\\", "/");
-    if (/^[A-Za-z]:\//.test(normalizedPath)) {
-        return `file:///${encodeURI(normalizedPath)}`;
-    }
-    if (normalizedPath.startsWith("/")) {
-        return `file://${encodeURI(normalizedPath)}`;
-    }
-    return normalizedPath;
-}
-async function loadBundledAuthoredModule(modulePath) {
-    const channelCache = getChannelModuleCache();
-    const packageRoot = resolveAuthoredPackageRoot(modulePath);
-    const tsconfigPath = resolveAuthoredTsConfigPath(packageRoot);
-    const channelIdentityPlugin = channelCache && channelCache.size > 0
-        ? {
-            name: "ash-channel-identity",
-            async resolveId(source, importer, options) {
-                if (!/channels[/\\]/.test(source) || options.kind !== "import-statement") {
-                    return undefined;
-                }
-                const resolved = await this.resolve(source, importer, {
-                    kind: options.kind,
-                    skipSelf: true,
-                });
-                if (resolved === null || typeof resolved.id !== "string") {
-                    return undefined;
-                }
-                const resolvedPath = resolve(resolved.id);
-                if (!channelCache.has(resolvedPath)) {
-                    return undefined;
-                }
-                return { id: `${CACHED_CHANNEL_PREFIX}${resolvedPath}` };
-            },
-            load(id) {
-                if (!id.startsWith(CACHED_CHANNEL_PREFIX)) {
-                    return undefined;
-                }
-                const cachedPath = id.slice(CACHED_CHANNEL_PREFIX.length);
-                return {
-                    code: [
-                        `const cache = globalThis["${CHANNEL_MODULE_CACHE_KEY}"];`,
-                        `export default cache.get(${JSON.stringify(cachedPath)});`,
-                    ].join("\n"),
-                    moduleType: "js",
-                };
-            },
-        }
-        : null;
-    const plugins = [
-        createAuthoredAssetImportPlugin(),
-        createAuthoredPackageTsConfigPathsPlugin({
-            appPackageRoot: packageRoot,
-            extensions: RESOLVE_EXTENSIONS,
-        }),
-        createNodeEsmCompatBannerPlugin({ includeRequire: true }),
-        createPackageBoundaryPlugin(packageRoot),
-        channelIdentityPlugin,
-    ].filter((plugin) => plugin !== null);
-    let outputFile;
-    try {
-        const result = await buildWithNitroRolldown({
-            cwd: packageRoot,
-            input: modulePath,
-            platform: "node",
-            plugins,
-            resolve: {
-                extensions: [...RESOLVE_EXTENSIONS],
-            },
-            tsconfig: tsconfigPath,
-            write: false,
-            output: {
-                comments: false,
-                format: "esm",
-                sourcemap: "inline",
-            },
-        });
-        outputFile = getSingleRolldownChunk(result, `authored module for "${modulePath}"`);
-    }
-    catch (error) {
-        throw createAuthoredModuleBundleError(modulePath, error);
-    }
-    const bundleHash = createHash("sha1")
-        .update(modulePath)
-        .update("\0")
-        .update(outputFile.code)
-        .digest("hex");
-    const bundleDirectoryPath = join(packageRoot, AUTHORED_MODULE_BUNDLE_DIRECTORY_PATH);
-    const bundlePath = join(bundleDirectoryPath, `${bundleHash}.mjs`);
-    if (!existsSync(bundlePath)) {
-        mkdirSync(bundleDirectoryPath, { recursive: true });
-        writeFileSync(bundlePath, outputFile.code);
-    }
-    return await import(`${createFileImportSpecifier(bundlePath)}?v=${bundleHash}`);
-}
-function createPackageBoundaryPlugin(packageRoot) {
-    return {
-        name: "ash-package-boundary",
-        async resolveId(source, importer, options) {
-            if (!isPackageImport(source)) {
-                return undefined;
-            }
-            if (isAshFrameworkImport(source)) {
-                return {
-                    external: true,
-                    id: source,
-                };
-            }
-            const importerPath = importer === undefined ||
-                importer.startsWith("\0") ||
-                importer.startsWith(CACHED_CHANNEL_PREFIX)
-                ? undefined
-                : resolve(importer);
-            // Keep package imports authored directly by the app external by
-            // default, but let symlinked/file workspace packages compile as
-            // source. Those packages often export `.ts` files and rely on the
-            // bundler's extension resolution for their own relative imports.
-            if (importerPath !== undefined && isPathInsideOrEqual(importerPath, packageRoot)) {
-                const resolved = await this.resolve(source, importer, {
-                    kind: options.kind,
-                    skipSelf: true,
-                });
-                if (resolved === null || typeof resolved.id !== "string") {
-                    return {
-                        external: true,
-                        id: source,
-                    };
-                }
-                if (isNodeModulesPath(resolved.id)) {
-                    return {
-                        external: true,
-                        id: source,
-                    };
-                }
-            }
-            return undefined;
-        },
-    };
-}
-function isPackageImport(source) {
-    if (source.startsWith(".") || source.startsWith("/") || /^[A-Za-z]:[\\/]/.test(source)) {
-        return false;
-    }
-    if (/^(?:node|data|file):/.test(source)) {
-        return false;
-    }
-    if (source.startsWith("@/")) {
-        return false;
-    }
-    return !source.startsWith(CACHED_CHANNEL_PREFIX);
-}
-function isAshFrameworkImport(source) {
-    return source === "experimental-ash" || source.startsWith("experimental-ash/");
-}
-function isNodeModulesPath(path) {
-    return path.replaceAll("\\", "/").includes("/node_modules/");
-}
-function isPathInsideOrEqual(path, directory) {
-    const resolvedPath = resolve(path);
-    const resolvedDirectory = resolve(directory);
-    return (resolvedPath === resolvedDirectory || resolvedPath.startsWith(`${resolvedDirectory}${sep}`));
-}
-function resolveAuthoredTsConfigPath(packageRoot) {
-    for (const fileName of ["tsconfig.json", "jsconfig.json"]) {
-        const path = join(packageRoot, fileName);
-        if (existsSync(path)) {
-            return path;
-        }
-    }
-    return false;
-}
-function resolveAuthoredPackageRoot(modulePath) {
-    let currentDirectory = dirname(modulePath);
-    while (true) {
-        if (existsSync(join(currentDirectory, "package.json"))) {
-            return currentDirectory;
-        }
-        const parentDirectory = dirname(currentDirectory);
-        if (parentDirectory === currentDirectory) {
-            throw new Error(`Failed to resolve the authored package root for "${modulePath}".`);
-        }
-        currentDirectory = parentDirectory;
-    }
-}
+import{expectObjectRecord}from"#internal/authored-module.js";import{dirname,join,resolve,sep}from"node:path";import{existsSync,mkdirSync,writeFileSync}from"node:fs";import{createHash}from"node:crypto";import{createAuthoredAssetImportPlugin}from"#internal/authored-asset-import-plugin.js";import{createAuthoredModuleBundleError}from"#internal/authored-module-bundle.js";import{createAuthoredPackageTsConfigPathsPlugin}from"#internal/authored-package-tsconfig-paths.js";import{buildWithNitroRolldown,getSingleRolldownChunk}from"#internal/bundler/nitro-rolldown.js";import{createNodeEsmCompatBannerPlugin}from"#internal/node-esm-compat-banner.js";var AUTHORED_BUNDLED_MODULE_EXTENSION=/\.[cm]?[jt]sx?$/,AUTHORED_MODULE_BUNDLE_DIRECTORY_PATH=join(`node_modules`,`.cache`,`experimental-ash`,`authored-modules`),RESOLVE_EXTENSIONS=[`.ts`,`.tsx`,`.mts`,`.cts`,`.js`,`.jsx`,`.mjs`,`.cjs`,`.json`],CHANNEL_MODULE_CACHE_KEY=`__ashChannelModuleCache__`,CACHED_CHANNEL_PREFIX=`ash-cached-channel:`;function getChannelModuleCache(){return globalThis[CHANNEL_MODULE_CACHE_KEY]}var inFlightModuleLoads=new Map;function loadAuthoredModuleNamespace(e){let t=resolve(e),n=inFlightModuleLoads.get(t);if(n!==void 0)return n;let i=(async()=>{try{return await doLoadAuthoredModuleNamespace(e)}finally{inFlightModuleLoads.delete(t)}})();return inFlightModuleLoads.set(t,i),i}async function doLoadAuthoredModuleNamespace(t){return expectObjectRecord(AUTHORED_BUNDLED_MODULE_EXTENSION.test(t)?await loadBundledAuthoredModule(t):await import(createFileImportSpecifier(t)),`Expected "${t}" to export a module namespace object.`)}function createFileImportSpecifier(e){let t=e.replaceAll(`\\`,`/`);return/^[A-Za-z]:\//.test(t)?`file:///${encodeURI(t)}`:t.startsWith(`/`)?`file://${encodeURI(t)}`:t}async function loadBundledAuthoredModule(e){let t=getChannelModuleCache(),i=resolveAuthoredPackageRoot(e),s=resolveAuthoredTsConfigPath(i),c=t&&t.size>0?{name:`ash-channel-identity`,async resolveId(e,n,i){if(!/channels[/\\]/.test(e)||i.kind!==`import-statement`)return;let a=await this.resolve(e,n,{kind:i.kind,skipSelf:!0});if(a===null||typeof a.id!=`string`)return;let o=resolve(a.id);if(t.has(o))return{id:`${CACHED_CHANNEL_PREFIX}${o}`}},load(e){if(!e.startsWith(CACHED_CHANNEL_PREFIX))return;let t=e.slice(CACHED_CHANNEL_PREFIX.length);return{code:[`const cache = globalThis["${CHANNEL_MODULE_CACHE_KEY}"];`,`export default cache.get(${JSON.stringify(t)});`].join(`
+`),moduleType:`js`}}}:null,l=[createAuthoredAssetImportPlugin(),createAuthoredPackageTsConfigPathsPlugin({appPackageRoot:i,extensions:RESOLVE_EXTENSIONS}),createNodeEsmCompatBannerPlugin({includeRequire:!0}),createPackageBoundaryPlugin(i),c].filter(e=>e!==null),u;try{u=getSingleRolldownChunk(await buildWithNitroRolldown({cwd:i,input:e,platform:`node`,plugins:l,resolve:{extensions:[...RESOLVE_EXTENSIONS]},tsconfig:s,write:!1,output:{comments:!1,format:`esm`,sourcemap:`inline`}}),`authored module for "${e}"`)}catch(t){throw createAuthoredModuleBundleError(e,t)}let d=createHash(`sha1`).update(e).update(`\0`).update(u.code).digest(`hex`),f=join(i,AUTHORED_MODULE_BUNDLE_DIRECTORY_PATH),p=join(f,`${d}.mjs`);return existsSync(p)||(mkdirSync(f,{recursive:!0}),writeFileSync(p,u.code)),await import(`${createFileImportSpecifier(p)}?v=${d}`)}function createPackageBoundaryPlugin(e){return{name:`ash-package-boundary`,async resolveId(t,n,i){if(!isPackageImport(t))return;if(isAshFrameworkImport(t))return{external:!0,id:t};let a=n===void 0||n.startsWith(`\0`)||n.startsWith(CACHED_CHANNEL_PREFIX)?void 0:resolve(n);if(a!==void 0&&isPathInsideOrEqual(a,e)){let e=await this.resolve(t,n,{kind:i.kind,skipSelf:!0});if(e===null||typeof e.id!=`string`||isNodeModulesPath(e.id))return{external:!0,id:t}}}}}function isPackageImport(e){return e.startsWith(`.`)||e.startsWith(`/`)||/^[A-Za-z]:[\\/]/.test(e)||/^(?:node|data|file):/.test(e)||e.startsWith(`@/`)?!1:!e.startsWith(CACHED_CHANNEL_PREFIX)}function isAshFrameworkImport(e){return e===`experimental-ash`||e.startsWith(`experimental-ash/`)}function isNodeModulesPath(e){return e.replaceAll(`\\`,`/`).includes(`/node_modules/`)}function isPathInsideOrEqual(e,t){let n=resolve(e),a=resolve(t);return n===a||n.startsWith(`${a}${sep}`)}function resolveAuthoredTsConfigPath(e){for(let t of[`tsconfig.json`,`jsconfig.json`]){let r=join(e,t);if(existsSync(r))return r}return!1}function resolveAuthoredPackageRoot(e){let r=dirname(e);for(;;){if(existsSync(join(r,`package.json`)))return r;let i=dirname(r);if(i===r)throw Error(`Failed to resolve the authored package root for "${e}".`);r=i}}export{loadAuthoredModuleNamespace};

package/dist/src/internal/authored-module-map-loader.js

@@ -1,53 +1 @@
-import { join } from "node:path";
-import { ROOT_COMPILED_AGENT_NODE_ID } from "#compiler/manifest.js";
-import { collectModuleRefsForManifest } from "#compiler/module-map.js";
-import { loadCompiledManifest } from "#runtime/loaders/manifest.js";
-import { loadAuthoredModuleNamespace } from "#internal/authored-module-loader.js";
-/**
- * Loads a disk-backed module map by hydrating authored modules directly from
- * source. This is for dev/build flows that need tsconfig alias support and
- * source reloads without relying on Node's module cache for module-map.mjs.
- */
-export async function loadCompiledModuleMapFromAuthoredSource(input) {
-    const manifest = await loadCompiledManifest({
-        compiledArtifactsSource: input.compiledArtifactsSource,
-    });
-    return await hydrateCompiledModuleMapFromManifest(manifest);
-}
-async function hydrateCompiledModuleMapFromManifest(manifest) {
-    const nodes = {};
-    const nodeManifests = [
-        {
-            agentRoot: manifest.agentRoot,
-            manifest,
-            nodeId: ROOT_COMPILED_AGENT_NODE_ID,
-        },
-        ...[...manifest.subagents]
-            .sort((left, right) => left.nodeId.localeCompare(right.nodeId))
-            .map((subagent) => ({
-            agentRoot: subagent.agent.agentRoot,
-            manifest: subagent.agent,
-            nodeId: subagent.nodeId,
-        })),
-    ];
-    for (const nodeManifest of nodeManifests) {
-        nodes[nodeManifest.nodeId] = {
-            modules: await hydrateCompiledNodeScope({
-                agentRoot: nodeManifest.agentRoot,
-                manifest: nodeManifest.manifest,
-            }),
-        };
-    }
-    return {
-        nodes,
-    };
-}
-async function hydrateCompiledNodeScope(input) {
-    const refs = collectModuleRefsForManifest(input.manifest).sort((left, right) => left.sourceId.localeCompare(right.sourceId));
-    const modules = {};
-    for (const ref of refs) {
-        const modulePath = join(input.agentRoot, ref.logicalPath);
-        modules[ref.sourceId] = await loadAuthoredModuleNamespace(modulePath);
-    }
-    return modules;
-}
+import{join}from"node:path";import{collectModuleRefsForManifest}from"#compiler/module-map.js";import{ROOT_COMPILED_AGENT_NODE_ID}from"#compiler/manifest.js";import{loadAuthoredModuleNamespace}from"#internal/authored-module-loader.js";import{loadCompiledManifest}from"#runtime/loaders/manifest.js";async function loadCompiledModuleMapFromAuthoredSource(e){return await hydrateCompiledModuleMapFromManifest(await loadCompiledManifest({compiledArtifactsSource:e.compiledArtifactsSource}))}async function hydrateCompiledModuleMapFromManifest(e){let t={},r=[{agentRoot:e.agentRoot,manifest:e,nodeId:ROOT_COMPILED_AGENT_NODE_ID},...[...e.subagents].sort((e,t)=>e.nodeId.localeCompare(t.nodeId)).map(e=>({agentRoot:e.agent.agentRoot,manifest:e.agent,nodeId:e.nodeId}))];for(let e of r)t[e.nodeId]={modules:await hydrateCompiledNodeScope({agentRoot:e.agentRoot,manifest:e.manifest})};return{nodes:t}}async function hydrateCompiledNodeScope(n){let i=collectModuleRefsForManifest(n.manifest).sort((e,t)=>e.sourceId.localeCompare(t.sourceId)),a={};for(let t of i){let i=join(n.agentRoot,t.logicalPath);a[t.sourceId]=await loadAuthoredModuleNamespace(i)}return a}export{loadCompiledModuleMapFromAuthoredSource};

package/dist/src/internal/authored-module.js

@@ -1,81 +1 @@
-/**
- * Returns the selected authored module export from one namespace.
- */
-export function getAuthoredModuleExport(moduleNamespace, source) {
-    return moduleNamespace[source.exportName ?? "default"];
-}
-/**
- * Materializes one authored module export that may be a definition factory.
- */
-export async function materializeAuthoredModuleExport(exportValue) {
-    if (typeof exportValue === "function") {
-        const definitionFactory = exportValue;
-        return await definitionFactory();
-    }
-    return exportValue;
-}
-/**
- * Returns the value as a plain object or throws.
- */
-export function expectObjectRecord(value, message) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        throw new Error(message);
-    }
-    return value;
-}
-/**
- * Returns the value as a string or throws.
- */
-export function expectString(value, message) {
-    if (typeof value !== "string") {
-        throw new Error(message);
-    }
-    return value;
-}
-/**
- * Returns the value as a function or throws.
- */
-export function expectFunction(value, message) {
-    if (typeof value !== "function") {
-        throw new Error(message);
-    }
-    return value;
-}
-/**
- * Returns the value as a provider options object or throws.
- */
-export function expectProviderOptions(value, message) {
-    const record = expectObjectRecord(value, message);
-    const providerOptions = {};
-    for (const [key, entryValue] of Object.entries(record)) {
-        const entryRecord = expectObjectRecord(entryValue, message);
-        providerOptions[key] = entryRecord;
-    }
-    return providerOptions;
-}
-/**
- * Rejects unexpected keys on one plain object.
- */
-export function expectOnlyKnownKeys(record, knownKeys, message) {
-    const knownKeySet = new Set(knownKeys);
-    for (const key of Object.keys(record)) {
-        if (!knownKeySet.has(key)) {
-            throw new Error(`${message} Unknown key "${key}".`);
-        }
-    }
-}
-/**
- * Returns one optional string-record property when present.
- */
-export function getOptionalStringRecordProperty(record, key, message) {
-    const value = record[key];
-    if (value === undefined) {
-        return undefined;
-    }
-    const objectValue = expectObjectRecord(value, message);
-    const normalizedValue = {};
-    for (const [entryKey, entryValue] of Object.entries(objectValue)) {
-        normalizedValue[entryKey] = expectString(entryValue, message);
-    }
-    return normalizedValue;
-}
+function getAuthoredModuleExport(e,t){return e[t.exportName??`default`]}async function materializeAuthoredModuleExport(e){return typeof e==`function`?await e():e}function expectObjectRecord(e,t){if(typeof e!=`object`||!e||Array.isArray(e))throw Error(t);return e}function expectString(e,t){if(typeof e!=`string`)throw Error(t);return e}function expectFunction(e,t){if(typeof e!=`function`)throw Error(t);return e}function expectProviderOptions(e,t){let n=expectObjectRecord(e,t),r={};for(let[e,i]of Object.entries(n))r[e]=expectObjectRecord(i,t);return r}function expectOnlyKnownKeys(e,t,n){let r=new Set(t);for(let t of Object.keys(e))if(!r.has(t))throw Error(`${n} Unknown key "${t}".`)}function getOptionalStringRecordProperty(e,t,n){let r=e[t];if(r===void 0)return;let i=expectObjectRecord(r,n),a={};for(let[e,t]of Object.entries(i))a[e]=expectString(t,n);return a}export{expectFunction,expectObjectRecord,expectOnlyKnownKeys,expectProviderOptions,expectString,getAuthoredModuleExport,getOptionalStringRecordProperty,materializeAuthoredModuleExport};