@unbrained/pm-cli 2026.10.14 → 2026.10.17

package/dist/cli.d.ts

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-declare function enableNodeCompileCache(): void;
-declare function findPackageJson(startPath: string): string | undefined;
-declare function printFastVersionIfRequested(): boolean;
-declare function readPackageVersionForPath(startPath: string): string | undefined;
+declare function enableNodeCompileCache():void;
+declare function findPackageJson(startPath:string):string | undefined;
+declare function printFastVersionIfRequested():boolean;
+declare function readPackageVersionForPath(startPath:string):string | undefined;
 /** Public contract for test only, shared by SDK and presentation-layer consumers. */
-export declare const _testOnly: {
-enableNodeCompileCache: typeof enableNodeCompileCache;
-findPackageJson: typeof findPackageJson;
-printFastVersionIfRequested: typeof printFastVersionIfRequested;
-readPackageVersionForPath: typeof readPackageVersionForPath;
+export declare const _testOnly:{
+enableNodeCompileCache:typeof enableNodeCompileCache;
+findPackageJson:typeof findPackageJson;
+printFastVersionIfRequested:typeof printFastVersionIfRequested;
+readPackageVersionForPath:typeof readPackageVersionForPath;
 };
 export {};

package/dist/core/checkpoint/checkpoint-gc.d.ts

@@ -16,46 +16,46 @@
 /** Documents the checkpoint gc scan entry payload exchanged by command, SDK, and package integrations. */
 export interface CheckpointGcEntry {
 /** Relative path like "checkpoints/update-many/update-many-20260619-abc123.json". */
-file: string;
+file:string;
 /** Parsed `created_at`, or null when missing/unparseable. */
-created_at: string | null;
+created_at:string | null;
 /** floor((now - created_at)/1000), null when unparseable. */
-age_seconds: number | null;
+age_seconds:number | null;
 /** True only when classified as expired (older than the retention window). */
-stale: boolean;
+stale:boolean;
 /** Value that configures or reports reason for this contract. */
-reason: "expired" | "active" | "unparseable";
+reason:"expired" | "active" | "unparseable";
 }
 /** Documents the checkpoint gc hooks payload exchanged by command, SDK, and package integrations. */
 export interface CheckpointGcHooks {
 /** Value that configures or reports on read for this contract. */
-onRead?: (checkpointPath: string) => Promise<string[]> | string[];
+onRead?:(checkpointPath:string) => Promise<string[]> | string[];
 /** Value that configures or reports on write for this contract. */
-onWrite?: (checkpointPath: string) => Promise<string[]> | string[];
+onWrite?:(checkpointPath:string) => Promise<string[]> | string[];
 }
 /** Documents the checkpoint gc options payload exchanged by command, SDK, and package integrations. */
 export interface CheckpointGcOptions {
 /** Value that configures or reports dry run for this contract. */
-dryRun: boolean;
+dryRun:boolean;
 /** Prune checkpoints older than this many days. Negative values are clamped to zero (prune everything aged); a non-finite value (NaN/Infinity) disables pruning entirely so bad input never deletes recoverable checkpoints. */
-retentionDays: number;
+retentionDays:number;
 /** Epoch ms; defaults to Date.now() — injectable for deterministic tests. */
-now?: number;
+now?:number;
 /** Value that configures or reports hooks for this contract. */
-hooks?: CheckpointGcHooks;
+hooks?:CheckpointGcHooks;
 }
 /** Documents the checkpoint gc result payload exchanged by command, SDK, and package integrations. */
 export interface CheckpointGcResult {
 /** Number of *.json checkpoint files examined. */
-scanned: number;
+scanned:number;
 /** Relative paths removed (or would-remove under dryRun), sorted by file name asc. */
-removed: string[];
+removed:string[];
 /** Relative paths retained (active OR unparseable — never delete what we can't reason about). */
-retained: string[];
+retained:string[];
 /** Value that configures or reports warnings for this contract. */
-warnings: string[];
+warnings:string[];
 /** One per scanned checkpoint file, sorted by file name asc. */
-entries: CheckpointGcEntry[];
+entries:CheckpointGcEntry[];
 }
 /** Implements run checkpoint gc for the public runtime surface of this module. */
-export declare function runCheckpointGc(pmRoot: string, options: CheckpointGcOptions): Promise<CheckpointGcResult>;
+export declare function runCheckpointGc(pmRoot:string,options:CheckpointGcOptions):Promise<CheckpointGcResult>;

package/dist/core/checkpoint/mutation-checkpoint.d.ts

@@ -1,63 +1,63 @@
 /** Documents the mutation checkpoint item payload exchanged by command, SDK, and package integrations. */
 export interface MutationCheckpointItem {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** ISO 8601 timestamp recording when target updated occurred. */
-target_updated_at: string;
+target_updated_at:string;
 }
 /** Documents the loaded mutation checkpoint payload exchanged by command, SDK, and package integrations. */
 export interface LoadedMutationCheckpoint {
 /** The full on-disk record so callers can read their command-specific fields. */
-record: Record<string, unknown>;
+record:Record<string,unknown>;
 /** Validated item list (id + target_updated_at). */
-items: MutationCheckpointItem[];
+items:MutationCheckpointItem[];
 /** Absolute path the checkpoint was read from. */
-path: string;
+path:string;
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** ISO 8601 timestamp recording when created occurred. */
-created_at: string;
+created_at:string;
 /** Value that configures or reports author for this contract. */
-author: string;
+author:string;
 }
 /** Documents the checkpoint rollback row payload exchanged by command, SDK, and package integrations. */
 export interface CheckpointRollbackRow {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** Lifecycle state reported for status. */
-status: "restored" | "failed";
+status:"restored" | "failed";
 /** Value that configures or reports changed fields for this contract. */
-changed_fields?: string[];
+changed_fields?:string[];
 /** Value that configures or reports warnings for this contract. */
-warnings?: string[];
+warnings?:string[];
 /** Value that configures or reports error for this contract. */
-error?: string;
+error?:string;
 }
 /** Documents the checkpoint rollback result payload exchanged by command, SDK, and package integrations. */
 export interface CheckpointRollbackResult {
 /** Value that configures or reports rows for this contract. */
-rows: CheckpointRollbackRow[];
+rows:CheckpointRollbackRow[];
 /** Value that configures or reports restored ids for this contract. */
-restored_ids: string[];
+restored_ids:string[];
 /** Number of failed entries represented by this result. */
-failed_count: number;
+failed_count:number;
 }
 /** Restore a single item to its captured pre-mutation timestamp. */
-export type CheckpointRestoreFn = (id: string, targetUpdatedAt: string) => Promise<{
-changed_fields?: string[];
-warnings?: string[];
+export type CheckpointRestoreFn = (id:string,targetUpdatedAt:string) => Promise<{
+changed_fields?:string[];
+warnings?:string[];
 }>;
 /** Implements normalize checkpoint id for the public runtime surface of this module. */
-export declare function normalizeCheckpointId(raw: string): string;
+export declare function normalizeCheckpointId(raw:string):string;
 /** Implements create checkpoint id for the public runtime surface of this module. */
-export declare function createCheckpointId(prefix: string, nowValue: string): string;
+export declare function createCheckpointId(prefix:string,nowValue:string):string;
 /** Implements checkpoint directory path for the public runtime surface of this module. */
-export declare function checkpointDirectoryPath(pmRoot: string, subdir: string): string;
+export declare function checkpointDirectoryPath(pmRoot:string,subdir:string):string;
 /** Implements checkpoint file path for the public runtime surface of this module. */
-export declare function checkpointFilePath(pmRoot: string, subdir: string, checkpointId: string): string;
+export declare function checkpointFilePath(pmRoot:string,subdir:string,checkpointId:string):string;
 /** Publish immutable checkpoint bytes once, including through path aliases; identical retries succeed and conflicting IDs preserve the original evidence. */
-export declare function writeMutationCheckpoint(pmRoot: string, subdir: string, checkpointId: string, payload: unknown): Promise<string>;
+export declare function writeMutationCheckpoint(pmRoot:string,subdir:string,checkpointId:string,payload:unknown):Promise<string>;
 /** Implements load mutation checkpoint for the public runtime surface of this module. */
-export declare function loadMutationCheckpoint(pmRoot: string, subdir: string, rawCheckpointId: string, schemaVersion: number): Promise<LoadedMutationCheckpoint>;
+export declare function loadMutationCheckpoint(pmRoot:string,subdir:string,rawCheckpointId:string,schemaVersion:number):Promise<LoadedMutationCheckpoint>;
 /** Restore every checkpointed item to its captured pre-mutation timestamp, collecting per-item rows. A single item's failure is recorded and does not abort the remaining restores. */
-export declare function restoreCheckpointItems(items: MutationCheckpointItem[], restore: CheckpointRestoreFn): Promise<CheckpointRollbackResult>;
+export declare function restoreCheckpointItems(items:MutationCheckpointItem[],restore:CheckpointRestoreFn):Promise<CheckpointRollbackResult>;

package/dist/core/config/nested-settings.d.ts

@@ -27,45 +27,45 @@ export type NestedSettingKind = "string" | "boolean" | "integer" | "number" | "r
 /** Documents the nested setting descriptor payload exchanged by command, SDK, and package integrations. */
 export interface NestedSettingDescriptor {
 /** CLI key (snake_case). Kebab-case form is accepted by normalizing `-` → `_`. */
-key: string;
+key:string;
 /** Dotted JSON path in PmSettings. */
-path: string;
+path:string;
 /** Value shape. */
-kind: NestedSettingKind;
+kind:NestedSettingKind;
 /** Short human-facing summary for `pm config list`. */
-summary: string;
+summary:string;
 /** Optional accepted values for string settings. */
-choices?: readonly string[];
+choices?:readonly string[];
 /** Require a non-empty trimmed string value for string settings. */
-non_empty?: boolean;
+non_empty?:boolean;
 /** Optional minimum value for `integer` / `number` kinds. When set, `parseNestedSettingValue` rejects values strictly below `min`. Useful for settings where 0 would be silently ignored by the runtime (batch sizes, timeouts, max-results limits). */
-min?: number;
+min?:number;
 /** Optional maximum value for `integer` / `number` kinds. When set, `parseNestedSettingValue` rejects values strictly above `max` (bounded knobs like `ids.token_length`). */
-max?: number;
+max?:number;
 }
 /** Search/provider/vector-store leaves. Order is the display order in `pm config list` and in error hints. */
-export declare const NESTED_SETTING_DESCRIPTORS: readonly NestedSettingDescriptor[];
+export declare const NESTED_SETTING_DESCRIPTORS:readonly NestedSettingDescriptor[];
 /** Map a raw user-supplied key (kebab case, snake case, or the dotted settings path surfaced by `pm config list`) onto a known nested-leaf descriptor. Returns `undefined` when the key is not a nested leaf, letting callers fall back to the regular ConfigKey path. */
-export declare function resolveNestedSettingDescriptor(raw: string | undefined): NestedSettingDescriptor | undefined;
+export declare function resolveNestedSettingDescriptor(raw:string | undefined):NestedSettingDescriptor | undefined;
 /** Recoverable parsed value with the descriptor it satisfied. */
 export interface NestedSettingParsedValue {
 /** Value that configures or reports descriptor for this contract. */
-descriptor: NestedSettingDescriptor;
+descriptor:NestedSettingDescriptor;
 /** Value that configures or reports value for this contract. */
-value: string | number | boolean;
+value:string | number | boolean;
 }
 /** Throwable validation error returned as a structured result. */
 export interface NestedSettingParseError {
 /** Human-readable explanation suitable for logs and agent-facing output. */
-message: string;
+message:string;
 }
 /** Restricts nested setting parse result values accepted by command, SDK, and storage contracts. */
 export type NestedSettingParseResult = {
-ok: true;
-parsed: NestedSettingParsedValue;
+ok:true;
+parsed:NestedSettingParsedValue;
 } | {
-ok: false;
-error: NestedSettingParseError;
+ok:false;
+error:NestedSettingParseError;
 };
 /**
  * Validate and coerce a raw string value for a nested-leaf setting. The
@@ -73,8 +73,8 @@ error: NestedSettingParseError;
  *
  * Empty strings are allowed for "string" leaves unless `non_empty` is set.
  */
-export declare function parseNestedSettingValue(descriptor: NestedSettingDescriptor, rawValue: string): NestedSettingParseResult;
+export declare function parseNestedSettingValue(descriptor:NestedSettingDescriptor,rawValue:string):NestedSettingParseResult;
 /** Walk a dotted path on an arbitrary record (best-effort, returns null on miss). */
-export declare function readNestedSettingValue(settings: unknown, descriptor: NestedSettingDescriptor): string | number | boolean | null;
+export declare function readNestedSettingValue(settings:unknown,descriptor:NestedSettingDescriptor):string | number | boolean | null;
 /** Set a leaf value on a settings object by walking the descriptor's dotted path. Missing intermediate objects are created. Returns `true` when the value actually changed. */
-export declare function writeNestedSettingValue(settings: Record<string, unknown>, descriptor: NestedSettingDescriptor, value: string | number | boolean): boolean;
+export declare function writeNestedSettingValue(settings:Record<string,unknown>,descriptor:NestedSettingDescriptor,value:string | number | boolean):boolean;

package/dist/core/config/positional-value.d.ts

@@ -12,29 +12,29 @@
 /** Successful routing of a positional value to a single-value typed flag. */
 export interface ConfigPositionalScalarRouted {
 /** Value that configures or reports routable for this contract. */
-routable: true;
+routable:true;
 /** Value that configures or reports flag for this contract. */
-flag: "format" | "policy";
+flag:"format" | "policy";
 /** Normalized scalar value for single-value flags. */
-value: string;
+value:string;
 }
 /** Successful routing of a positional value to the criteria-list flag. */
 export interface ConfigPositionalListRouted {
 /** Value that configures or reports routable for this contract. */
-routable: true;
+routable:true;
 /** Value that configures or reports flag for this contract. */
-flag: "criterion";
+flag:"criterion";
 /** Criteria-list flag (`--criterion`) value, supplied as a values array. */
-values: string[];
+values:string[];
 }
 /** Restricts config positional routed values accepted by command, SDK, and storage contracts. */
 export type ConfigPositionalRouted = ConfigPositionalScalarRouted | ConfigPositionalListRouted;
 /** A key whose value cannot be carried by a single positional (e.g. `context`). */
 export interface ConfigPositionalNotRoutable {
 /** Value that configures or reports routable for this contract. */
-routable: false;
+routable:false;
 /** Human/agent-facing reason + the flags to use instead. */
-reason: string;
+reason:string;
 }
 /** Restricts config positional result values accepted by command, SDK, and storage contracts. */
 export type ConfigPositionalResult = ConfigPositionalRouted | ConfigPositionalNotRoutable;
@@ -48,4 +48,4 @@ export type ConfigKey = "definition_of_done" | "item_format" | "history_missing_
  * flags (e.g. `context`). Unknown keys also return `routable: false` so the caller
  * can fall back to the existing invalid-key path.
  */
-export declare function resolveConfigPositionalValue(canonicalKeyOrAlias: string, value: string): ConfigPositionalResult;
+export declare function resolveConfigPositionalValue(canonicalKeyOrAlias:string,value:string):ConfigPositionalResult;

package/dist/core/diagnostics/remediation.d.ts

@@ -20,14 +20,14 @@
 /** Maps a stable diagnostic warning code to the command and summary that resolve it. */
 export interface RemediationEntry {
 /** Stable warning-code prefix this entry resolves. A warning matches when it equals this code or begins with `<code>:`. Registry codes are mutually exclusive under that colon-boundary rule (no code is a `:`-delimited prefix of another — e.g. `settings:id_prefix_empty` is distinct from a bare `settings`, which is intentionally not registered), so `resolveRemediation` uses first-match with no ordering dependency. */
-readonly code: string;
+readonly code:string;
 /** Executable `pm` command (or imperative) that resolves the finding. May contain an `<id>` placeholder. */
-readonly command: string;
+readonly command:string;
 /** One-line description of what the command does / which manual step it covers. */
-readonly summary: string;
+readonly summary:string;
 }
 /** Registry of every non-extension `pm health` / `pm validate` warning code and its remediation. Extension findings keep their richer, contextual `details.triage.remediation` produced by the extension health triage and are intentionally excluded here (see pm-0hnu: "all non-extension checks"). */
-export declare const REMEDIATION_REGISTRY: readonly RemediationEntry[];
+export declare const REMEDIATION_REGISTRY:readonly RemediationEntry[];
 /**
  * Resolve the remediation entry for a warning token, or `undefined` when no
  * entry is registered. A warning matches an entry when it equals the entry code
@@ -45,8 +45,8 @@ export declare const REMEDIATION_REGISTRY: readonly RemediationEntry[];
  * Accepts unknown input defensively (this is an exported helper SDK consumers
  * may call from untyped JS): a non-string `warning` resolves to `undefined`.
  */
-export declare function resolveRemediation(warning: string): RemediationEntry | undefined;
+export declare function resolveRemediation(warning:string):RemediationEntry | undefined;
 /** Build a compact `remediation_map` (code -> command) for a set of warning tokens. First match wins per code; unknown codes are skipped. Used by `pm health --json` per-check details and as the source of deduped executable commands for `pm validate --fix-hints`. */
-export declare function buildRemediationMap(warnings: Iterable<string>): Record<string, string>;
+export declare function buildRemediationMap(warnings:Iterable<string>):Record<string,string>;
 /** Build a deduped, ordered list of executable remediation commands for a set of warning tokens (one command per distinct matched code). Used by `pm validate --fix-hints` for checks that do not already emit per-row remediation commands. */
-export declare function buildRemediationCommands(warnings: Iterable<string>): string[];
+export declare function buildRemediationCommands(warnings:Iterable<string>):string[];

package/dist/core/extensions/activation-summary-markdown.d.ts

@@ -33,16 +33,16 @@ export interface ExtensionSurfaceMarkdownOptions {
      * {@link ExtensionSurfaceMarkdownOptions.headingLevel}; per-surface sections
      * render one level deeper.
      */
-title?: string;
+title?:string;
 /**
      * ATX heading level for the title, an integer in `[1, 6]` (default `2`, i.e.
      * `##`, so the document embeds cleanly under a `# Package` README heading).
      * Section headings render at `headingLevel + 1`, clamped to `6`. Values
      * outside `[1, 6]` throw a {@link RangeError}.
      */
-headingLevel?: number;
+headingLevel?:number;
 /** When `true`, render every surface section even when it has no entries (emitting `_None._` under the heading) and always emit the capabilities line. Defaults to `false`, which omits empty sections so the reference lists only what the package actually contributes. */
-includeEmpty?: boolean;
+includeEmpty?:boolean;
 }
 /**
  * Render an {@link ExtensionActivationSummary} as a deterministic Markdown
@@ -63,4 +63,4 @@ includeEmpty?: boolean;
  *
  * @throws {RangeError} when `options.headingLevel` is not an integer in `[1, 6]`.
  */
-export declare function renderExtensionSurfaceMarkdown(summary: ExtensionActivationSummary, options?: ExtensionSurfaceMarkdownOptions): string;
+export declare function renderExtensionSurfaceMarkdown(summary:ExtensionActivationSummary,options?:ExtensionSurfaceMarkdownOptions):string;

package/dist/core/extensions/activation-summary.d.ts

@@ -24,7 +24,7 @@
  *   nothing more" check, the positive counterpart to
  *   {@link ./capability-usage.js#reconcileExtensionCapabilityUsage}.
  */
-import type { ExtensionActivationResult, ExtensionCapability, ExtensionServiceName, OutputRendererFormat } from "./extension-types.js";
+import type { ExtensionActivationResult,ExtensionCapability,ExtensionServiceName,OutputRendererFormat } from "./extension-types.js";
 /**
  * Flat, name-level enumeration of every surface an activation registered.
  *
@@ -41,58 +41,58 @@ import type { ExtensionActivationResult, ExtensionCapability, ExtensionServiceNa
  */
 export interface ExtensionActivationSummary {
 /** Known capabilities the registered surfaces exercise (sorted, de-duplicated). */
-capabilities: ExtensionCapability[];
+capabilities:ExtensionCapability[];
 /** Full command paths declared via `registerCommand`'s definition form. */
-commands: string[];
+commands:string[];
 /** Built-in command paths replaced by an `registerCommand(name, override)` handler. */
-command_overrides: string[];
+command_overrides:string[];
 /**
      * Full command paths backed by an extension-provided handler. A superset of
      * {@link ExtensionActivationSummary.commands} that also includes the
      * `<name> import`/`<name> export` paths synthesized for importers/exporters.
      */
-command_handlers: string[];
+command_handlers:string[];
 /** Lifecycle hook kinds with at least one registered hook (canonical order). */
-hooks: string[];
+hooks:string[];
 /** Command paths that received extension-registered flags. */
-flag_commands: string[];
+flag_commands:string[];
 /** Custom item-type names registered via `registerItemTypes`. */
-item_types: string[];
+item_types:string[];
 /** Custom item-metadata field names registered via `registerItemFields`. */
-item_fields: string[];
+item_fields:string[];
 /** Custom relationship-kind names registered via `registerRelationshipKinds`. */
-relationship_kinds?: string[];
+relationship_kinds?:string[];
 /** Schema migration ids registered via `registerMigration` (id-less migrations are omitted — they carry no identifier). */
-migrations: string[];
+migrations:string[];
 /** Project profile names registered via `registerProfile`. */
-profiles: string[];
+profiles:string[];
 /** Importer names registered via `registerImporter`. */
-importers: string[];
+importers:string[];
 /** Exporter names registered via `registerExporter`. */
-exporters: string[];
+exporters:string[];
 /** Search-provider names registered via `registerSearchProvider`. */
-search_providers: string[];
+search_providers:string[];
 /** Vector-store adapter names registered via `registerVectorStoreAdapter`. */
-vector_store_adapters: string[];
+vector_store_adapters:string[];
 /** Assurance provider ids registered via `registerAssuranceMeasurementProvider`. */
-assurance_providers?: string[];
+assurance_providers?:string[];
 /** Command paths with a parser override registered via `registerParser`. */
-parser_overrides: string[];
+parser_overrides:string[];
 /** Built-in service names overridden via `registerService`. */
-service_overrides: ExtensionServiceName[];
+service_overrides:ExtensionServiceName[];
 /** Output formats with a renderer override registered via `registerRenderer`. */
-renderer_overrides: OutputRendererFormat[];
+renderer_overrides:OutputRendererFormat[];
 /** Host-enforced ownership declared by scoped renderers. Omitted when every renderer is global. */
-renderer_ownership?: Array<{
-format: OutputRendererFormat;
-commands: string[];
-result_discriminator: boolean;
+renderer_ownership?:Array<{
+format:OutputRendererFormat;
+commands:string[];
+result_discriminator:boolean;
 }>;
 /** Count of registered preflight overrides. The surface carries no per-entry identifier, so this is a `number` rather than `string[]` — the only numeric field in the summary. */
-preflight_overrides: number;
+preflight_overrides:number;
 /** Command ownership for each registered preflight override. */
-preflight_ownership: Array<{
-commands: string[];
+preflight_ownership:Array<{
+commands:string[];
 }>;
 }
 /**
@@ -105,9 +105,9 @@ export interface DescribeExtensionActivationOptions {
      * {@link ./capability-usage.js#collectUsedExtensionCapabilities}. Omit to
      * union across every extension in the activation result.
      */
-extensionName?: string;
+extensionName?:string;
 /** Restrict the summary to a set of extension names. This supports package aliases that resolve to multiple extensions while keeping the historical single-name option intact. */
-extensionNames?: readonly string[];
+extensionNames?:readonly string[];
 }
 /**
  * Summarize, by name, every registration surface an activation exercised.
@@ -120,4 +120,4 @@ extensionNames?: readonly string[];
  * summary unions every extension in the activation. Failed activations register
  * nothing, so they contribute only an empty summary.
  */
-export declare function describeExtensionActivation(activation: ExtensionActivationResult, options?: DescribeExtensionActivationOptions): ExtensionActivationSummary;
+export declare function describeExtensionActivation(activation:ExtensionActivationResult,options?:DescribeExtensionActivationOptions):ExtensionActivationSummary;

package/dist/core/extensions/activation-transaction.d.ts

@@ -3,20 +3,20 @@
  *
  * Captures and restores extension registries around one activation attempt.
  */
-import type { ExtensionCommandRegistry, ExtensionHookRegistry, ExtensionParserRegistry, ExtensionPreflightRegistry, ExtensionRegistrationRegistry, ExtensionRendererRegistry, ExtensionServiceRegistry } from "./extension-types.js";
+import type { ExtensionCommandRegistry,ExtensionHookRegistry,ExtensionParserRegistry,ExtensionPreflightRegistry,ExtensionRegistrationRegistry,ExtensionRendererRegistry,ExtensionServiceRegistry } from "./extension-types.js";
 interface MutableExtensionActivationState {
-hooks: ExtensionHookRegistry;
-commands: ExtensionCommandRegistry;
-parsers: ExtensionParserRegistry;
-preflight: ExtensionPreflightRegistry;
-services: ExtensionServiceRegistry;
-renderers: ExtensionRendererRegistry;
-registrations: ExtensionRegistrationRegistry;
+hooks:ExtensionHookRegistry;
+commands:ExtensionCommandRegistry;
+parsers:ExtensionParserRegistry;
+preflight:ExtensionPreflightRegistry;
+services:ExtensionServiceRegistry;
+renderers:ExtensionRendererRegistry;
+registrations:ExtensionRegistrationRegistry;
 }
 /**
  * Return a rollback operation that restores every mutable registry to its
  * current length, making one extension activation atomic without cloning
  * handlers or user values.
  */
-export declare function captureExtensionActivationRollback(state: MutableExtensionActivationState): () => void;
+export declare function captureExtensionActivationRollback(state:MutableExtensionActivationState):() => void;
 export {};

package/dist/core/extensions/capability-usage.d.ts

@@ -12,7 +12,7 @@
  * grant. Every declared-but-unused capability is an over-broad permission a
  * reviewer would otherwise have to catch by hand.
  */
-import type { ExtensionActivationResult, ExtensionCapability, ExtensionLayer } from "./extension-types.js";
+import type { ExtensionActivationResult,ExtensionCapability,ExtensionLayer } from "./extension-types.js";
 /**
  * Canonical map from each known extension capability to the human-readable
  * registration surfaces that exercise it.
@@ -22,36 +22,36 @@ import type { ExtensionActivationResult, ExtensionCapability, ExtensionLayer } f
  * without giving it a registration surface here fails the build, which prevents
  * a capability that has *no* surface from being perpetually flagged as unused.
  */
-export declare const EXTENSION_CAPABILITY_REGISTRATION_SURFACES: {
-readonly commands: readonly ["registerCommand", "command override", "command handler"];
-readonly renderers: readonly ["registerRenderer"];
-readonly hooks: readonly ["hooks.beforeCommand", "hooks.beforeMutation", "hooks.afterCommand", "hooks.onWrite", "hooks.onRead", "hooks.onIndex"];
-readonly schema: readonly ["registerFlags", "registerItemFields", "registerItemTypes", "registerRelationshipKinds", "registerMigration", "registerProfile"];
-readonly importers: readonly ["registerImporter", "registerExporter"];
-readonly search: readonly ["registerSearchProvider", "registerVectorStoreAdapter"];
-readonly parser: readonly ["registerParser"];
-readonly preflight: readonly ["registerPreflight"];
-readonly services: readonly ["registerService", "registerAssuranceMeasurementProvider"];
+export declare const EXTENSION_CAPABILITY_REGISTRATION_SURFACES:{
+readonly commands:readonly ["registerCommand","command override","command handler"];
+readonly renderers:readonly ["registerRenderer"];
+readonly hooks:readonly ["hooks.beforeCommand","hooks.beforeMutation","hooks.afterCommand","hooks.onWrite","hooks.onRead","hooks.onIndex"];
+readonly schema:readonly ["registerFlags","registerItemFields","registerItemTypes","registerRelationshipKinds","registerMigration","registerProfile"];
+readonly importers:readonly ["registerImporter","registerExporter"];
+readonly search:readonly ["registerSearchProvider","registerVectorStoreAdapter"];
+readonly parser:readonly ["registerParser"];
+readonly preflight:readonly ["registerPreflight"];
+readonly services:readonly ["registerService","registerAssuranceMeasurementProvider"];
 };
 /** Per-extension reconciliation of declared versus exercised capabilities. */
 export interface ExtensionCapabilityUsageReconciliation {
 /** Layer the extension was loaded from (`global` or `project`). */
-layer: ExtensionLayer;
+layer:ExtensionLayer;
 /** Extension name as it appears in the manifest. */
-name: string;
+name:string;
 /** Known capabilities declared in the manifest, sorted and de-duplicated. */
-declared: ExtensionCapability[];
+declared:ExtensionCapability[];
 /** Known capabilities the extension actually registered against, sorted. */
-used: ExtensionCapability[];
+used:ExtensionCapability[];
 /** Declared capabilities with no matching registration (least-privilege gap). */
-unused: ExtensionCapability[];
+unused:ExtensionCapability[];
 }
 /** Options for {@link collectUsedExtensionCapabilities}. */
 export interface CollectUsedExtensionCapabilitiesOptions {
 /** Restrict the result to a single extension by name. Names are matched case-insensitively after trimming. Omit to union across every extension in the activation result. */
-extensionName?: string;
+extensionName?:string;
 /** Restrict the result to a set of extension names. This preserves the single-name option while allowing package aliases that activate multiple extensions to summarize their combined capability surface. */
-extensionNames?: readonly string[];
+extensionNames?:readonly string[];
 }
 /**
  * Canonical extension-name normalization (trim + lowercase) used to match an
@@ -62,7 +62,7 @@ extensionNames?: readonly string[];
  * by extension name must normalize both sides with this function to stay
  * consistent, including {@link ../extensions/activation-summary.js#describeExtensionActivation}.
  */
-export declare function normalizeExtensionName(name: string): string;
+export declare function normalizeExtensionName(name:string):string;
 /**
  * Collect the known capabilities exercised across an activation result.
  *
@@ -70,7 +70,7 @@ export declare function normalizeExtensionName(name: string): string;
  * result unions every extension in the activation; with it, only the matching
  * extension's registrations contribute (across both layers).
  */
-export declare function collectUsedExtensionCapabilities(activation: ExtensionActivationResult, options?: CollectUsedExtensionCapabilitiesOptions): ExtensionCapability[];
+export declare function collectUsedExtensionCapabilities(activation:ExtensionActivationResult,options?:CollectUsedExtensionCapabilitiesOptions):ExtensionCapability[];
 /**
  * Reconcile each loaded extension's declared capabilities against what it
  * exercised during activation.
@@ -79,8 +79,8 @@ export declare function collectUsedExtensionCapabilities(activation: ExtensionAc
  * to reconcile. The returned entries preserve every reconcilable extension even
  * when `unused` is empty so callers can report fully-minimal manifests too.
  */
-export declare function reconcileExtensionCapabilityUsage(loaded: ReadonlyArray<{
-layer: ExtensionLayer;
-name: string;
-capabilities?: readonly string[];
-}>, activation: ExtensionActivationResult): ExtensionCapabilityUsageReconciliation[];
+export declare function reconcileExtensionCapabilityUsage(loaded:ReadonlyArray<{
+layer:ExtensionLayer;
+name:string;
+capabilities?:readonly string[];
+}>,activation:ExtensionActivationResult):ExtensionCapabilityUsageReconciliation[];