@jangts/agent-core 0.1.0 → 0.2.0

package/dist/esm/kits/intents/catalog.js

@@ -1,28 +1,79 @@
+/**
+ * Intents Kit: project registered intents, scopes and tools into one task-facing catalog.
+ *
+ * Place in the package: part of the `intents` Kit. It reads the actual registries supplied by
+ * the App instead of maintaining a parallel capability list, so an intent is only advertised
+ * when its tools, scopes and availability agree.
+ *
+ * Exports: `defineAgentCatalog`, and the catalog intent/scope/port types.
+ */
 import { booleanResult } from '../../utils/synchronous.js';
-/** The actual registries determine availability and relationships. No parallel capability list. */
+/**
+ * Compile a catalog projection over the App's live registries.
+ *
+ * The actual registries determine availability and relationships. No parallel capability list
+ * exists: `intentIds` filters by tool support, `modelCatalog` narrows to the currently accepted
+ * task when `restrictToTask` is enabled, and scope tool ids are filtered to tools that exist.
+ *
+ * @param ports - Sources for intent ids, intents, scopes, the current task, the tool registry
+ *   and the `restrictToTask` switch.
+ * @returns A frozen projection with `intentIds`, `intentSteps`, `intentCatalog`,
+ *   `scopeCatalog` and `modelCatalog`.
+ * @throws TypeError When a supplied predicate does not return a boolean synchronously.
+ */
 export function defineAgentCatalog(ports) {
     const ids = ports.intentIds.bind(ports), intents = ports.intents.bind(ports), scopes = ports.scopes.bind(ports), task = ports.currentTask.bind(ports);
-    const tools = { values: ports.tools.values.bind(ports.tools), has: ports.tools.has.bind(ports.tools), supports: ports.tools.supportsIntent.bind(ports.tools), describe: ports.tools.describe.bind(ports.tools) };
+    const tools = {
+        values: ports.tools.values.bind(ports.tools),
+        has: ports.tools.has.bind(ports.tools),
+        supports: ports.tools.supportsIntent.bind(ports.tools),
+        describe: ports.tools.describe.bind(ports.tools),
+    };
     const restrict = ports.restrictToTask !== false;
     const boolean = (value) => booleanResult(value, 'Catalog predicates must be synchronous', 'Catalog predicates must return boolean');
-    const intentIds = (app) => ids().filter(id => boolean(tools.supports(id, app)));
-    const intentSteps = (app) => new Map(intents().map(intent => [intent.id, [...new Set([
-                ...intent.steps, ...[...tools.values()].filter(tool => tool.invocation && (!tool.available || app === undefined || boolean(tool.available(app)))
-                    && (tool.intentIds === 'all' || tool.intentIds.includes(intent.id))).map(tool => tool.invocation.step),
-            ])]]));
+    const intentIds = (app) => ids().filter((id) => boolean(tools.supports(id, app)));
+    const intentSteps = (app) => new Map(intents().map((intent) => [
+        intent.id,
+        [
+            ...new Set([
+                ...intent.steps,
+                ...[...tools.values()]
+                    .filter((tool) => tool.invocation &&
+                    (!tool.available || app === undefined || boolean(tool.available(app))) &&
+                    (tool.intentIds === 'all' || tool.intentIds.includes(intent.id)))
+                    .map((tool) => tool.invocation.step),
+            ]),
+        ],
+    ]));
     const intentCatalog = (app) => {
         const selected = intentIds(app), described = tools.describe('model', app), steps = intentSteps(app);
-        return intents(selected).map(intent => ({ ...intent, steps: steps.get(intent.id) ?? [...intent.steps],
-            scopeIds: scopes([intent.id]).map(scope => scope.id), toolIds: described.filter(tool => tool.intentIds.includes(intent.id)).map(tool => tool.id) }));
+        return intents(selected).map((intent) => ({
+            ...intent,
+            steps: steps.get(intent.id) ?? [...intent.steps],
+            scopeIds: scopes([intent.id]).map((scope) => scope.id),
+            toolIds: described
+                .filter((tool) => tool.intentIds.includes(intent.id))
+                .map((tool) => tool.id),
+        }));
     };
-    const scopeCatalog = (app) => scopes(intentIds(app)).map(scope => ({ ...scope, toolIds: scope.toolIds.filter(tools.has) }));
-    return Object.freeze({ intentIds, intentSteps, intentCatalog, scopeCatalog,
+    const scopeCatalog = (app) => scopes(intentIds(app)).map((scope) => ({ ...scope, toolIds: scope.toolIds.filter(tools.has) }));
+    return Object.freeze({
+        intentIds,
+        intentSteps,
+        intentCatalog,
+        scopeCatalog,
         modelCatalog(app) {
-            const accepted = restrict ? task(app) : undefined, selected = intentIds(app).filter(id => !accepted || id === accepted.intentId);
-            return { availableIntentIds: selected,
-                availableIntents: intentCatalog(app).filter(intent => selected.includes(intent.id)).map(intent => accepted ? { ...intent, scopeIds: accepted.scopeId ? [accepted.scopeId] : [] } : intent),
-                availableScopes: scopeCatalog(app).filter(scope => !accepted || scope.id === accepted.scopeId),
-                availableTools: tools.describe('model', app).filter(tool => !accepted || tool.intentIds.includes(accepted.intentId)) };
+            const accepted = restrict ? task(app) : undefined, selected = intentIds(app).filter((id) => !accepted || id === accepted.intentId);
+            return {
+                availableIntentIds: selected,
+                availableIntents: intentCatalog(app)
+                    .filter((intent) => selected.includes(intent.id))
+                    .map((intent) => accepted ? { ...intent, scopeIds: accepted.scopeId ? [accepted.scopeId] : [] } : intent),
+                availableScopes: scopeCatalog(app).filter((scope) => !accepted || scope.id === accepted.scopeId),
+                availableTools: tools
+                    .describe('model', app)
+                    .filter((tool) => !accepted || tool.intentIds.includes(accepted.intentId)),
+            };
         },
     });
 }

package/dist/esm/kits/intents/index.d.ts

@@ -1,9 +1,20 @@
+/**
+ * Intents Kit entry: intent and scope registries plus the task-facing catalog projection.
+ *
+ * Place in the package: an optional App-side library for declaring what the agent may do.
+ * Applications register their own intents and scopes; this directory owns registration
+ * checks, aliases, relationship lookups and the model-visible projection. Core never imports it.
+ *
+ * Exports: everything from `./registry.js`, `./scopes.js` and `./catalog.js`, plus the
+ * `Intents` namespace object.
+ */
 export * from './registry.js';
 export * from './scopes.js';
 export * from './catalog.js';
 import { IntentRegistry } from './registry.js';
 import { ScopeRegistry } from './scopes.js';
 import { defineAgentCatalog } from './catalog.js';
+/** Namespace object for callers that prefer one import over named helpers. */
 export declare const Intents: Readonly<{
     IntentRegistry: typeof IntentRegistry;
     ScopeRegistry: typeof ScopeRegistry;

package/dist/esm/kits/intents/index.js

@@ -1,7 +1,18 @@
+/**
+ * Intents Kit entry: intent and scope registries plus the task-facing catalog projection.
+ *
+ * Place in the package: an optional App-side library for declaring what the agent may do.
+ * Applications register their own intents and scopes; this directory owns registration
+ * checks, aliases, relationship lookups and the model-visible projection. Core never imports it.
+ *
+ * Exports: everything from `./registry.js`, `./scopes.js` and `./catalog.js`, plus the
+ * `Intents` namespace object.
+ */
 export * from './registry.js';
 export * from './scopes.js';
 export * from './catalog.js';
 import { IntentRegistry } from './registry.js';
 import { ScopeRegistry } from './scopes.js';
 import { defineAgentCatalog } from './catalog.js';
+/** Namespace object for callers that prefer one import over named helpers. */
 export const Intents = Object.freeze({ IntentRegistry, ScopeRegistry, defineAgentCatalog });

package/dist/esm/kits/intents/registry.d.ts

@@ -1,30 +1,88 @@
+/**
+ * Intents Kit: an ordered, sealable registry of intent declarations.
+ *
+ * Place in the package: part of the `intents` Kit. Intent semantics and the allowed vocabulary
+ * (scope modes, target modes, context tiers, steps, actions) are App configuration; this class
+ * owns the common lifecycle — validation, ordering, duplicate detection and sealing.
+ *
+ * Exports: `IntentRegistry`, `createIntentRegistry`, and the intent registry types.
+ */
 import type { IntentDefinition, IntentDescription, IntentRegistryPolicy, IntentId, RegisteredIntent } from '../../structs/kits/intents/registry.js';
-/** Intent semantics and allowed values are configuration; the registry owns their common lifecycle. */
+/**
+ * Intent semantics and allowed values are configuration; the registry owns their common lifecycle.
+ *
+ * Registration order is preserved by `ids`, `definitions`, `values` and `entries`; once
+ * `seal()` is called the set is final and further registration is rejected.
+ */
 export declare class IntentRegistry<Definition extends IntentDefinition = IntentDefinition> {
+    /** Create and seal a complete catalog in one call. */
     static readonly create: typeof createIntentRegistry;
     private readonly byId;
     private sealed;
     private readonly policy;
+    /**
+     * @param policy - Optional id pattern, vocabulary lists, error wording and assertion hook.
+     *   Lists and the pattern are copied so later mutation of the input cannot weaken checks.
+     */
     constructor(policy?: IntentRegistryPolicy<Definition>);
+    /**
+     * Validate, freeze and add one intent.
+     *
+     * Checks run in a fixed order — sealed, identity, context contract, auxiliary actions,
+     * handoff, plan, steps — so the reported violation is stable when several rules fail.
+     *
+     * @param input - Intent declaration; the App's own assertion receives this original object,
+     *   not the compiled copy, so helpers and prototype methods keep working.
+     * @returns This registry, for chaining.
+     * @throws A configured error for a sealed registry, invalid identity or vocabulary values,
+     *   empty/duplicate steps, or a duplicate intent id.
+     */
     register(input: Definition): this;
+    /** Register every intent in iteration order. */
     registerAll(definitions: Iterable<Definition>): this;
+    /** Registered intent for `goal`, or `undefined` when it is absent. */
     get(goal: string): RegisteredIntent<Definition> | undefined;
+    /** Whether an intent id is registered. */
     has(goal: string): boolean;
+    /** Registered intent ids in registration order. */
     ids(): readonly IntentId<Definition>[];
+    /** Registered intents in registration order. */
     get definitions(): readonly RegisteredIntent<Definition>[];
+    /** Iterate the registered intents. */
     values(): MapIterator<Readonly<Omit<Readonly<IntentDefinition & import("../../utils/registration.js").RegistrationData<Definition> & Pick<Definition, Extract<keyof Definition, keyof IntentDefinition>>>, "steps" | "auxiliaryActions"> & { readonly [Key in keyof Pick<Definition, Extract<keyof Definition, "steps" | "auxiliaryActions">>]: Readonly<Definition[Key]>; } & {
         id: Definition["id"];
         steps: Readonly<Definition["steps"]>;
     }>>;
+    /** Iterate `[id, intent]` pairs. */
     entries(): MapIterator<[string, Readonly<Omit<Readonly<IntentDefinition & import("../../utils/registration.js").RegistrationData<Definition> & Pick<Definition, Extract<keyof Definition, keyof IntentDefinition>>>, "steps" | "auxiliaryActions"> & { readonly [Key in keyof Pick<Definition, Extract<keyof Definition, "steps" | "auxiliaryActions">>]: Readonly<Definition[Key]>; } & {
         id: Definition["id"];
         steps: Readonly<Definition["steps"]>;
     }>]>;
+    /**
+     * Registered intent for `id`.
+     *
+     * @throws TypeError When the id is not registered.
+     */
     require(id: string): RegisteredIntent<Definition>;
+    /** Whether the intent declares this step; unknown intents allow nothing. */
     allows(goal: string, step: string): boolean;
+    /**
+     * Copy the selected intents out of the registry.
+     *
+     * @param goals - Ids to include; the default is every registered id, in registry order.
+     * @returns Descriptions whose arrays are copied so callers cannot mutate registry state.
+     */
     describe(goals?: readonly string[]): IntentDescription<Definition>[];
+    /** Finalize the registry; no registration is accepted afterwards. */
     seal(): this;
 }
-/** Create and seal a complete catalog; use the constructor for incremental installation. */
+/**
+ * Create and seal a complete catalog; use the constructor for incremental installation.
+ *
+ * @param definitions - Intent declarations registered in iteration order.
+ * @param policy - Optional registry policy forwarded to the constructor.
+ * @returns A sealed registry.
+ * @throws A configured error for the first invalid or duplicate declaration.
+ */
 export declare function createIntentRegistry<Definition extends IntentDefinition>(definitions: Iterable<Definition>, policy?: IntentRegistryPolicy<Definition>): IntentRegistry<Definition>;
-export type { IntentDefinition, IntentDescription, IntentRegistryPolicy, IntentId, RegisteredIntent } from '../../structs/kits/intents/registry.js';
+export type { IntentDefinition, IntentDescription, IntentRegistryPolicy, IntentId, RegisteredIntent, } from '../../structs/kits/intents/registry.js';

package/dist/esm/kits/intents/registry.js

@@ -1,94 +1,239 @@
 import { assertion } from '../../utils/synchronous.js';
 import { breakWhile } from '../../utils/rules.js';
 import { registrationData } from '../../utils/registration.js';
-/** Intent semantics and allowed values are configuration; the registry owns their common lifecycle. */
+/**
+ * Intent semantics and allowed values are configuration; the registry owns their common lifecycle.
+ *
+ * Registration order is preserved by `ids`, `definitions`, `values` and `entries`; once
+ * `seal()` is called the set is final and further registration is rejected.
+ */
 export class IntentRegistry {
+    /** Create and seal a complete catalog in one call. */
     static create = createIntentRegistry;
     byId = new Map();
     sealed = false;
     policy;
+    /**
+     * @param policy - Optional id pattern, vocabulary lists, error wording and assertion hook.
+     *   Lists and the pattern are copied so later mutation of the input cannot weaken checks.
+     */
     constructor(policy = {}) {
         const pattern = policy.idPattern;
         const errorPorts = policy.errors, { sealed, invalid, duplicate } = errorPorts ?? {};
-        const listFields = ['scopeModes', 'targetModes', 'contextTiers', 'actions', 'steps', 'handoffValues', 'tags'];
-        const lists = Object.fromEntries(listFields.map(key => { const value = policy[key]; return [key, value === undefined ? undefined : Object.freeze([...value])]; }));
-        this.policy = Object.freeze({ ...registrationData(policy, ['idPattern', 'assertDefinition', 'errors', ...listFields]), ...lists, idPattern: pattern ? new RegExp(pattern.source, pattern.flags) : undefined,
-            errors: errorPorts && Object.freeze({ sealed: typeof sealed === 'function' ? sealed.bind(errorPorts) : sealed,
-                invalid: typeof invalid === 'function' ? invalid.bind(errorPorts) : invalid, duplicate: duplicate?.bind(errorPorts) }),
-            assertDefinition: policy.assertDefinition?.bind(policy) });
+        const listFields = [
+            'scopeModes',
+            'targetModes',
+            'contextTiers',
+            'actions',
+            'steps',
+            'handoffValues',
+            'tags',
+        ];
+        const lists = Object.fromEntries(listFields.map((key) => {
+            const value = policy[key];
+            return [key, value === undefined ? undefined : Object.freeze([...value])];
+        }));
+        this.policy = Object.freeze({
+            ...registrationData(policy, ['idPattern', 'assertDefinition', 'errors', ...listFields]),
+            ...lists,
+            idPattern: pattern ? new RegExp(pattern.source, pattern.flags) : undefined,
+            errors: errorPorts &&
+                Object.freeze({
+                    sealed: typeof sealed === 'function' ? sealed.bind(errorPorts) : sealed,
+                    invalid: typeof invalid === 'function' ? invalid.bind(errorPorts) : invalid,
+                    duplicate: duplicate?.bind(errorPorts),
+                }),
+            assertDefinition: policy.assertDefinition?.bind(policy),
+        });
     }
+    /**
+     * Validate, freeze and add one intent.
+     *
+     * Checks run in a fixed order — sealed, identity, context contract, auxiliary actions,
+     * handoff, plan, steps — so the reported violation is stable when several rules fail.
+     *
+     * @param input - Intent declaration; the App's own assertion receives this original object,
+     *   not the compiled copy, so helpers and prototype methods keep working.
+     * @returns This registry, for chaining.
+     * @throws A configured error for a sealed registry, invalid identity or vocabulary values,
+     *   empty/duplicate steps, or a duplicate intent id.
+     */
     register(input) {
         const id = input.id;
-        const definition = { ...registrationData(input, ['id', 'description', 'steps', 'scopePolicy', 'targetPolicy', 'contextTier', 'planIntent', 'auxiliaryActions', 'preparedHandoff']), id, description: input.description, steps: input.steps,
-            scopePolicy: input.scopePolicy, targetPolicy: input.targetPolicy, contextTier: input.contextTier,
-            planIntent: input.planIntent, auxiliaryActions: input.auxiliaryActions, preparedHandoff: input.preparedHandoff };
+        const definition = {
+            ...registrationData(input, [
+                'id',
+                'description',
+                'steps',
+                'scopePolicy',
+                'targetPolicy',
+                'contextTier',
+                'planIntent',
+                'auxiliaryActions',
+                'preparedHandoff',
+            ]),
+            id,
+            description: input.description,
+            steps: input.steps,
+            scopePolicy: input.scopePolicy,
+            targetPolicy: input.targetPolicy,
+            contextTier: input.contextTier,
+            planIntent: input.planIntent,
+            auxiliaryActions: input.auxiliaryActions,
+            preparedHandoff: input.preparedHandoff,
+        };
         const policy = this.policy;
         const invalid = policy.errors?.invalid ?? 'Invalid intent definition';
         const tags = policy.tags ?? [];
-        const validName = (name) => { if (typeof name !== 'string' || !name.trim())
-            return false; if (!policy.idPattern)
-            return true; policy.idPattern.lastIndex = 0; return policy.idPattern.test(name); };
+        const validName = (name) => {
+            if (typeof name !== 'string' || !name.trim())
+                return false;
+            if (!policy.idPattern)
+                return true;
+            policy.idPattern.lastIndex = 0;
+            return policy.idPattern.test(name);
+        };
         breakWhile([
-            { occur: () => this.sealed, error: policy.errors?.sealed ?? 'Intent registry is sealed', tags: ['sealed'] },
+            {
+                occur: () => this.sealed,
+                error: policy.errors?.sealed ?? 'Intent registry is sealed',
+                tags: ['sealed'],
+            },
             {
                 occur: [() => !validName(definition.id), () => !definition.description.trim()],
-                error: invalid, tags: ['identity'],
+                error: invalid,
+                tags: ['identity'],
             },
             {
                 occur: [
-                    () => policy.scopeModes !== undefined && !policy.scopeModes.includes(definition.scopePolicy),
-                    () => policy.targetModes !== undefined && !policy.targetModes.includes(definition.targetPolicy),
-                    () => policy.contextTiers !== undefined && !policy.contextTiers.includes(definition.contextTier),
-                ], error: invalid, tags: ['context-contract'],
+                    () => policy.scopeModes !== undefined &&
+                        !policy.scopeModes.includes(definition.scopePolicy),
+                    () => policy.targetModes !== undefined &&
+                        !policy.targetModes.includes(definition.targetPolicy),
+                    () => policy.contextTiers !== undefined &&
+                        !policy.contextTiers.includes(definition.contextTier),
+                ],
+                error: invalid,
+                tags: ['context-contract'],
             },
             {
                 occur: [
                     () => definition.auxiliaryActions !== undefined && !definition.auxiliaryActions.length,
-                    () => definition.auxiliaryActions !== undefined && definition.auxiliaryActions.some(action => policy.actions !== undefined && !policy.actions.includes(action)),
-                    () => definition.auxiliaryActions !== undefined && new Set(definition.auxiliaryActions).size !== definition.auxiliaryActions.length,
-                ], error: invalid, tags: ['auxiliary-actions'],
+                    () => definition.auxiliaryActions !== undefined &&
+                        definition.auxiliaryActions.some((action) => policy.actions !== undefined && !policy.actions.includes(action)),
+                    () => definition.auxiliaryActions !== undefined &&
+                        new Set(definition.auxiliaryActions).size !== definition.auxiliaryActions.length,
+                ],
+                error: invalid,
+                tags: ['auxiliary-actions'],
+            },
+            {
+                occur: () => definition.preparedHandoff !== undefined &&
+                    policy.handoffValues !== undefined &&
+                    !policy.handoffValues.includes(definition.preparedHandoff),
+                error: invalid,
+                tags: ['handoff'],
+            },
+            {
+                occur: () => policy.actions !== undefined && !policy.actions.includes(definition.planIntent),
+                error: invalid,
+                tags: ['plan'],
             },
-            { occur: () => definition.preparedHandoff !== undefined && policy.handoffValues !== undefined && !policy.handoffValues.includes(definition.preparedHandoff), error: invalid, tags: ['handoff'] },
-            { occur: () => policy.actions !== undefined && !policy.actions.includes(definition.planIntent), error: invalid, tags: ['plan'] },
             {
                 occur: [
                     () => !definition.steps.length,
-                    () => definition.steps.some(step => policy.steps !== undefined && !policy.steps.includes(step)),
+                    () => definition.steps.some((step) => policy.steps !== undefined && !policy.steps.includes(step)),
                     () => new Set(definition.steps).size !== definition.steps.length,
-                ], error: invalid, tags: ['steps'],
+                ],
+                error: invalid,
+                tags: ['steps'],
             },
         ], tags);
-        // App assertions may use implementation helpers; never pass a compiled view as the source instance.
+        // App assertions may use implementation helpers; never pass a compiled view as the source
+        // instance.
         assertion(policy.assertDefinition?.(input), 'Registry definition assertions must return void synchronously');
-        breakWhile(this.byId.has(definition.id), () => policy.errors?.duplicate?.(definition.id) ?? new Error(`Duplicate intent: ${definition.id}`), [...tags, 'duplicate']);
+        breakWhile(this.byId.has(definition.id), () => policy.errors?.duplicate?.(definition.id) ??
+            new Error(`Duplicate intent: ${definition.id}`), [...tags, 'duplicate']);
         this.byId.set(definition.id, Object.freeze({
-            ...definition, steps: Object.freeze([...definition.steps]),
-            ...(definition.auxiliaryActions ? { auxiliaryActions: Object.freeze([...definition.auxiliaryActions]) } : {}),
+            ...definition,
+            steps: Object.freeze([...definition.steps]),
+            ...(definition.auxiliaryActions
+                ? { auxiliaryActions: Object.freeze([...definition.auxiliaryActions]) }
+                : {}),
         }));
         return this;
     }
+    /** Register every intent in iteration order. */
     registerAll(definitions) {
         for (const definition of definitions)
             this.register(definition);
         return this;
     }
-    get(goal) { return this.byId.get(goal); }
-    has(goal) { return this.byId.has(goal); }
-    ids() { return Object.freeze([...this.byId.keys()]); }
-    get definitions() { return Object.freeze([...this.byId.values()]); }
-    values() { return this.byId.values(); }
-    entries() { return this.byId.entries(); }
-    require(id) { const value = this.byId.get(id); if (!value)
-        throw new TypeError(`Unknown intent: ${id}`); return value; }
-    allows(goal, step) { return this.byId.get(goal)?.steps.includes(step) ?? false; }
+    /** Registered intent for `goal`, or `undefined` when it is absent. */
+    get(goal) {
+        return this.byId.get(goal);
+    }
+    /** Whether an intent id is registered. */
+    has(goal) {
+        return this.byId.has(goal);
+    }
+    /** Registered intent ids in registration order. */
+    ids() {
+        return Object.freeze([...this.byId.keys()]);
+    }
+    /** Registered intents in registration order. */
+    get definitions() {
+        return Object.freeze([...this.byId.values()]);
+    }
+    /** Iterate the registered intents. */
+    values() {
+        return this.byId.values();
+    }
+    /** Iterate `[id, intent]` pairs. */
+    entries() {
+        return this.byId.entries();
+    }
+    /**
+     * Registered intent for `id`.
+     *
+     * @throws TypeError When the id is not registered.
+     */
+    require(id) {
+        const value = this.byId.get(id);
+        if (!value)
+            throw new TypeError(`Unknown intent: ${id}`);
+        return value;
+    }
+    /** Whether the intent declares this step; unknown intents allow nothing. */
+    allows(goal, step) {
+        return this.byId.get(goal)?.steps.includes(step) ?? false;
+    }
+    /**
+     * Copy the selected intents out of the registry.
+     *
+     * @param goals - Ids to include; the default is every registered id, in registry order.
+     * @returns Descriptions whose arrays are copied so callers cannot mutate registry state.
+     */
     describe(goals = this.ids()) {
         const selected = new Set(goals);
-        return [...this.byId.values()].filter(item => selected.has(item.id))
-            .map(item => ({ ...item, steps: [...item.steps] }));
+        return [...this.byId.values()]
+            .filter((item) => selected.has(item.id))
+            .map((item) => ({ ...item, steps: [...item.steps] }));
+    }
+    /** Finalize the registry; no registration is accepted afterwards. */
+    seal() {
+        this.sealed = true;
+        return this;
     }
-    seal() { this.sealed = true; return this; }
 }
-/** Create and seal a complete catalog; use the constructor for incremental installation. */
+/**
+ * Create and seal a complete catalog; use the constructor for incremental installation.
+ *
+ * @param definitions - Intent declarations registered in iteration order.
+ * @param policy - Optional registry policy forwarded to the constructor.
+ * @returns A sealed registry.
+ * @throws A configured error for the first invalid or duplicate declaration.
+ */
 export function createIntentRegistry(definitions, policy = {}) {
     return new IntentRegistry(policy).registerAll(definitions).seal();
 }