@unbrained/pm-cli 2026.8.12 → 2026.8.13

package/dist/core/extensions/contribution-inventory.js

@@ -4,7 +4,7 @@
  * Validates and canonicalizes the serializable extension surface inventory.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="2c4e3831-6644-5db3-a28b-1c6a131da2e1")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="f7c79f37-1cae-59c9-b500-eb87d0089f94")}catch(e){}}();
 import { normalizeCommandName } from "./extension-runtime-helpers.js";
 const COMMAND_PATH_FIELDS = new Set([
     "commands",
@@ -28,6 +28,7 @@ const STRING_LIST_FIELDS = [
     "exporters",
     "search_providers",
     "vector_store_adapters",
+    "assurance_providers",
     "parser_overrides",
     "service_overrides",
     "renderer_overrides",
@@ -154,6 +155,9 @@ export function createExtensionContributionInventory(summary) {
         exporters: summary.exporters,
         search_providers: summary.search_providers,
         vector_store_adapters: summary.vector_store_adapters,
+        ...(summary.assurance_providers
+            ? { assurance_providers: summary.assurance_providers }
+            : {}),
         parser_overrides: summary.parser_overrides,
         service_overrides: summary.service_overrides,
         renderer_overrides: summary.renderer_overrides,
@@ -167,4 +171,4 @@ export function createExtensionContributionInventory(summary) {
     };
 }
 //# sourceMappingURL=contribution-inventory.js.map
-//# debugId=2c4e3831-6644-5db3-a28b-1c6a131da2e1
+//# debugId=f7c79f37-1cae-59c9-b500-eb87d0089f94

package/dist/core/extensions/extension-registries.js

@@ -1,6 +1,6 @@
 /** Implements create empty extension hook registry for the public runtime surface of this module. */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="baa8b608-7f1e-5382-abe3-b1af79e46da4")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="48fff41d-2667-50a1-bfbb-40908804babd")}catch(e){}}();
 export function createEmptyExtensionHookRegistry() {
     return {
         beforeCommand: [],
@@ -56,7 +56,8 @@ export function createEmptyExtensionRegistrationRegistry() {
         exporters: [],
         search_providers: [],
         vector_store_adapters: [],
+        assurance_providers: [],
     };
 }
 //# sourceMappingURL=extension-registries.js.map
-//# debugId=baa8b608-7f1e-5382-abe3-b1af79e46da4
+//# debugId=48fff41d-2667-50a1-bfbb-40908804babd

package/dist/core/extensions/extension-types.d.ts

@@ -55,7 +55,7 @@ export interface PmMaxVersionExceededModeByLayer {
 /** Settings value for `extensions.policy.pm_max_version_exceeded_mode`: either a single mode applied to both layers, or a per-layer override map. Unset (and any unset layer key) defaults to `"block"`. */
 export type PmMaxVersionExceededModeSetting = PmMaxVersionExceededMode | PmMaxVersionExceededModeByLayer;
 /** Public contract for known extension policy surfaces, shared by SDK and presentation-layer consumers. */
-export declare const KNOWN_EXTENSION_POLICY_SURFACES: readonly ["commands.override", "commands.handler", "hooks.beforecommand", "hooks.beforemutation", "hooks.aftercommand", "hooks.onwrite", "hooks.onread", "hooks.onindex", "schema.flags", "schema.itemfields", "schema.itemtypes", "schema.relationshipkinds", "schema.migrations", "schema.profiles", "parser.override", "preflight.override", "services.override", "renderers.override", "importers.importer", "importers.exporter", "search.provider", "search.vectorstore"];
+export declare const KNOWN_EXTENSION_POLICY_SURFACES: readonly ["commands.override", "commands.handler", "hooks.beforecommand", "hooks.beforemutation", "hooks.aftercommand", "hooks.onwrite", "hooks.onread", "hooks.onindex", "schema.flags", "schema.itemfields", "schema.itemtypes", "schema.relationshipkinds", "schema.migrations", "schema.profiles", "parser.override", "preflight.override", "services.override", "renderers.override", "importers.importer", "importers.exporter", "search.provider", "search.vectorstore", "services.assuranceprovider"];
 /** Restricts extension policy surface values accepted by command, SDK, and storage contracts. */
 export type ExtensionPolicySurface = (typeof KNOWN_EXTENSION_POLICY_SURFACES)[number];
 /** Public contract for known extension service names, shared by SDK and presentation-layer consumers. */
@@ -145,6 +145,8 @@ export interface ExtensionContributionInventory {
     search_providers?: string[];
     /** Declared vector-store adapter names. */
     vector_store_adapters?: string[];
+    /** Declared assurance measurement-provider ids. */
+    assurance_providers?: string[];
     /** Parser override command targets. */
     parser_overrides?: string[];
     /** Service override targets. */
@@ -1039,6 +1041,65 @@ export interface VectorStoreAdapterDefinition {
     delete?: (context: VectorStoreDeleteContext) => unknown | Promise<unknown>;
     [key: string]: unknown;
 }
+/** Cost classes let lifecycle gates reject expensive provider work before invoking it. */
+export type AssuranceMeasurementProviderCostClass = "low" | "medium" | "high";
+/** JSON-compatible parameter contract for one provider measurement key. */
+export interface AssuranceMeasurementProviderParameterDefinition {
+    /** Parameter value kind. */
+    type: "string" | "number" | "boolean";
+    /** Whether callers must supply the parameter. */
+    required?: boolean;
+    /** Human-readable parameter intent. */
+    description?: string;
+}
+/** Serializable schema for one measurement key owned by a provider. */
+export interface AssuranceMeasurementProviderKeyDefinition {
+    /** Value kind returned by the resolver. */
+    value_type: "number" | "string_set";
+    /** Human-readable metric intent. */
+    description?: string;
+    /** Accepted provider parameters. Unknown parameters are rejected. */
+    parameters?: Record<string, AssuranceMeasurementProviderParameterDefinition>;
+}
+/** Runtime request supplied to an extension-owned assurance provider. */
+export interface AssuranceMeasurementProviderContext extends PortableWorkspaceContext {
+    /** Provider id selected by the measurement declaration. */
+    provider: string;
+    /** Provider-owned metric key. */
+    key: string;
+    /** Validated provider parameters. */
+    parameters: Record<string, string | number | boolean | null>;
+    /** Gate trigger that authorized this invocation. */
+    trigger: string;
+    /** Tracker root bound to the active command or SDK request. */
+    pm_root: string;
+}
+/** Result returned by an extension-owned assurance provider. */
+export interface AssuranceMeasurementProviderResult {
+    /** Finite numeric value or deterministic labelled set. */
+    value: number | string[];
+    /** Population denominator represented by the metric. */
+    population_size: number;
+    /** Abstract compute units charged by the provider. */
+    cost: number;
+    /** Optional stable contributor ids or labels. */
+    contributors?: string[];
+}
+/** Extension registration for an open assurance measurement vocabulary. */
+export interface AssuranceMeasurementProviderDefinition {
+    /** Stable provider id used by measurement declarations and gate allow-lists. */
+    id: string;
+    /** Serializable metric-key schema. */
+    keys: Record<string, AssuranceMeasurementProviderKeyDefinition>;
+    /** Coarse execution cost used by trigger policy before invocation. */
+    cost_class: AssuranceMeasurementProviderCostClass;
+    /** Whether the resolver can access the network. */
+    network: boolean;
+    /** Maximum host wait for one resolver call. */
+    timeout_ms?: number;
+    /** Resolve one declared key. */
+    resolve(context: AssuranceMeasurementProviderContext): AssuranceMeasurementProviderResult | Promise<AssuranceMeasurementProviderResult>;
+}
 /** Documents the registered extension command override payload exchanged by command, SDK, and package integrations. */
 export interface RegisteredExtensionCommandOverride {
     /** Value that configures or reports layer for this contract. */
@@ -1250,6 +1311,21 @@ export interface RegisteredExtensionVectorStoreAdapter {
     /** Value that configures or reports runtime definition for this contract. */
     runtime_definition: VectorStoreAdapterDefinition;
 }
+/** One validated assurance measurement provider registered by an active extension. */
+export interface RegisteredExtensionAssuranceMeasurementProvider {
+    /** Extension layer owning the provider. */
+    layer: ExtensionLayer;
+    /** Extension name owning the provider. */
+    name: string;
+    /** Whether the owning manifest grants network access. */
+    network_permission: boolean;
+    /** Serializable definition used by doctor, inventory, and policy surfaces. */
+    definition: Omit<AssuranceMeasurementProviderDefinition, "resolve"> & {
+        resolve: "[Function]";
+    };
+    /** Runtime definition containing the executable resolver. */
+    runtime_definition: AssuranceMeasurementProviderDefinition;
+}
 /**
  * Documents a project profile contributed by an extension via
  * `api.registerProfile(profile)`.
@@ -1293,6 +1369,8 @@ export interface ExtensionRegistrationRegistry {
     search_providers: RegisteredExtensionSearchProvider[];
     /** Value that configures or reports vector store adapters for this contract. */
     vector_store_adapters: RegisteredExtensionVectorStoreAdapter[];
+    /** Extension-owned assurance measurement providers. */
+    assurance_providers: RegisteredExtensionAssuranceMeasurementProvider[];
 }
 /** Documents the extension registration counts payload exchanged by command, SDK, and package integrations. */
 export interface ExtensionRegistrationCounts {
@@ -1318,6 +1396,8 @@ export interface ExtensionRegistrationCounts {
     search_providers: number;
     /** Value that configures or reports vector store adapters for this contract. */
     vector_store_adapters: number;
+    /** Number of registered assurance measurement providers. */
+    assurance_providers?: number;
 }
 /** Read-only identity an extension's `activate(api)` receives about itself, so authors can emit self-identifying logs, gate on their own version, and build better error messages without re-reading the on-disk manifest or duplicating metadata in-module. Exposed as `api.extension`. */
 export interface ExtensionSelfIdentity {
@@ -1372,6 +1452,8 @@ export interface ExtensionApi {
     registerSearchProvider(provider: SearchProviderDefinition): void;
     /** Value that configures or reports register vector store adapter for this contract. */
     registerVectorStoreAdapter(adapter: VectorStoreAdapterDefinition): void;
+    /** Register an assurance measurement provider through the services capability. */
+    registerAssuranceMeasurementProvider(provider: AssuranceMeasurementProviderDefinition): void;
     /** Value that configures or reports hooks for this contract. */
     hooks: {
         beforeCommand(hook: BeforeCommandHook): void;

package/dist/core/extensions/extension-types.js

@@ -1,6 +1,6 @@
 /** Public contract for known extension capabilities, shared by SDK and presentation-layer consumers. */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="50ad61f1-6719-541c-b4e0-4a88468725cf")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="294f3a0c-e74d-5963-b966-8a4443855ce3")}catch(e){}}();
 export const KNOWN_EXTENSION_CAPABILITIES = [
     "commands",
     "renderers",
@@ -61,6 +61,7 @@ export const KNOWN_EXTENSION_POLICY_SURFACES = [
     "importers.exporter",
     "search.provider",
     "search.vectorstore",
+    "services.assuranceprovider",
 ];
 /** Public contract for known extension service names, shared by SDK and presentation-layer consumers. */
 export const KNOWN_EXTENSION_SERVICE_NAMES = [
@@ -99,4 +100,4 @@ export function createDefaultExtensionGovernancePolicy() {
     };
 }
 //# sourceMappingURL=extension-types.js.map
-//# debugId=50ad61f1-6719-541c-b4e0-4a88468725cf
+//# debugId=294f3a0c-e74d-5963-b966-8a4443855ce3

package/dist/core/extensions/loader.d.ts

@@ -1,10 +1,11 @@
 import { assertOptionalStringField, normalizeOptionalStringArrayField } from "./registration-validation.js";
 import { compareComparableVersions, parseComparableVersion } from "./version-compat.js";
 import { type NormalizedExtensionPolicy } from "./extension-policy.js";
+import { createRegistrationValidationError, extractRegistrationValidationTrace, normalizeRegistrationRecord, normalizeRegistrationRecordList, normalizeRuntimeRegistrationRecord, sanitizeRegistrationValue } from "./registration-values.js";
 export { parseUnknownExtensionCapabilityWarning, parseLegacyExtensionCapabilityAliasWarning, } from "./extension-capability-aliases.js";
 export { createEmptyExtensionHookRegistry, createEmptyExtensionCommandRegistry, createEmptyExtensionParserRegistry, createEmptyExtensionPreflightRegistry, createEmptyExtensionServiceRegistry, createEmptyExtensionRendererRegistry, createEmptyExtensionRegistrationRegistry, } from "./extension-registries.js";
 export { runBeforeCommandHooks, runBeforeMutationHooks, runAfterCommandHooks, runOnWriteHooks, runOnReadHooks, runOnIndexHooks, runCommandHandler, runParserOverride, runPreflightOverride, runServiceOverrideSync, runServiceOverride, runCommandOverride, runRendererOverride, } from "./extension-hook-runtime.js";
-import { type ExtensionDeactivationOptions, type ExtensionDeactivationResult, type PmMaxVersionExceededMode, type ExtensionLayer, type ExtensionManifest, type EffectiveExtension, type ExtensionDiscoveryResult, type LoadedExtension, type ExtensionLoadResult, type ExtensionHookRegistry, type ExtensionCommandArgumentDefinition, type ExtensionCommandRegistry, type ExtensionParserRegistry, type ExtensionPreflightRegistry, type ExtensionServiceRegistry, type ExtensionRendererRegistry, type ExtensionRegistrationRegistry, type ExtensionRegistrationCounts, type ExtensionApi, type FailedExtensionActivation, type ExtensionActivationFailureTrace, type ExtensionActivationResult, type DiscoverExtensionsOptions } from "./extension-types.js";
+import { type ExtensionDeactivationOptions, type ExtensionDeactivationResult, type PmMaxVersionExceededMode, type ExtensionLayer, type ExtensionManifest, type EffectiveExtension, type ExtensionDiscoveryResult, type LoadedExtension, type ExtensionLoadResult, type ExtensionHookRegistry, type ExtensionCommandArgumentDefinition, type ExtensionCommandRegistry, type ExtensionParserRegistry, type ExtensionPreflightRegistry, type ExtensionServiceRegistry, type ExtensionRendererRegistry, type ExtensionRegistrationRegistry, type ExtensionRegistrationCounts, type ExtensionApi, type FailedExtensionActivation, type ExtensionActivationResult, type DiscoverExtensionsOptions } from "./extension-types.js";
 export * from "./extension-types.js";
 /** Fallback extension priority used when callers do not provide an override. */
 export declare const DEFAULT_EXTENSION_PRIORITY = 100;
@@ -51,13 +52,6 @@ export declare function loadExtensions(options: DiscoverExtensionsOptions): Prom
  */
 export declare function deactivateExtensions(loadResult: ExtensionLoadResult, activationResult?: Pick<ExtensionActivationResult, "failed">, options?: ExtensionDeactivationOptions): Promise<ExtensionDeactivationResult>;
 declare function normalizeExtensionDeactivateTimeout(rawTimeout: unknown): number;
-declare function sanitizeRegistrationValue(value: unknown): unknown;
-declare function createRegistrationValidationError(message: string, trace: ExtensionActivationFailureTrace): TypeError;
-declare function extractRegistrationValidationTrace(error: unknown): ExtensionActivationFailureTrace | undefined;
-declare function normalizeRegistrationRecord(name: string, value: unknown): Record<string, unknown>;
-declare function normalizeRuntimeRegistrationRecord(name: string, value: unknown): Record<string, unknown>;
-declare function normalizeRegistrationRecordList<T extends object>(name: string, value: readonly T[]): T[];
-declare function normalizeRegistrationRecordList(name: string, value: unknown): Array<Record<string, unknown>>;
 declare function resolveCommandDefinitionAction(commandPath: string, action: unknown): string;
 declare function normalizeCommandDefinitionArguments(value: unknown): ExtensionCommandArgumentDefinition[];
 /** Reject a declared `value_type`/`type` that is not a known flag value kind, and a `default` whose value(s) would not cleanly coerce under that kind — so the typed-flag contract is enforced at registration instead of silently leaving an untyped value to surface at use time. */

package/dist/core/extensions/loader.js

@@ -4,7 +4,7 @@
  * Implements extension runtime contracts and governance for Loader.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="3d5208e5-0ea5-54a5-82a8-50294b4a0655")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="2b8750c3-7b19-5240-8179-f83830af1b77")}catch(e){}}();
 import fs from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -23,15 +23,12 @@ import { asRegistrationRecord, assertOptionalBooleanField, assertOptionalFlagDef
 import { describeExtensionLongFlagFailure, findExtensionFlagTokenFailure, } from "./flag-definition-validation.js";
 import { compareComparableVersions, evaluatePmMaxVersionBound, evaluatePmMinVersionBound, parseComparableVersion, } from "./version-compat.js";
 import { createRelationshipKindRegistry, } from "../../sdk/relationships.js";
-// Cohesive helper groups now live in sibling modules. They are imported for the
-// discovery/activation code that stays here and re-exported below so existing
-// import sites (sdk/index.ts, commands/extension.ts, health.ts, tests, …) keep
-// importing everything from "./loader.js" unchanged.
 import { normalizeNames, isKnownExtensionCapability, collectUnknownExtensionCapabilities, normalizeManifestCapabilities, formatUnknownExtensionCapabilityWarning, formatLegacyExtensionCapabilityAliasWarning, } from "./extension-capability-aliases.js";
 import { normalizeExtensionPolicy, serializeExtensionPolicy, hydrateExtensionPolicy, normalizePolicySandboxProfile, evaluateExtensionPolicyForExtension, evaluateExtensionPolicyForCapability, evaluateExtensionPolicyForRegistration, } from "./extension-policy.js";
 import { createEmptyExtensionHookRegistry, createEmptyExtensionCommandRegistry, createEmptyExtensionParserRegistry, createEmptyExtensionPreflightRegistry, createEmptyExtensionServiceRegistry, createEmptyExtensionRendererRegistry, createEmptyExtensionRegistrationRegistry, } from "./extension-registries.js";
 import { normalizeCommandName, cloneContextSnapshot, } from "./extension-runtime-helpers.js";
 import { normalizeExtensionContributionInventory } from "./contribution-inventory.js";
+import { attachRuntimeDefinition, assertHookHandler, assertNonEmptyRegistrationString, assertRegistrationFunction, cloneRuntimeRegistrationValue, createRegistrationValidationError, extractRegistrationValidationTrace, isExtensionServiceName, isOutputRendererFormat, normalizeRegistrationRecord, normalizeRegistrationRecordList, normalizeRuntimeRegistrationRecord, normalizeRegistrationName, sanitizeRegistrationValue, toRegistrationCommandPath, validateAssuranceMeasurementProviderDefinition, } from "./registration-values.js";
 import { buildReadyExtensionCandidate, } from "./extension-candidate.js";
 export { parseUnknownExtensionCapabilityWarning, parseLegacyExtensionCapabilityAliasWarning, } from "./extension-capability-aliases.js";
 export { createEmptyExtensionHookRegistry, createEmptyExtensionCommandRegistry, createEmptyExtensionParserRegistry, createEmptyExtensionPreflightRegistry, createEmptyExtensionServiceRegistry, createEmptyExtensionRendererRegistry, createEmptyExtensionRegistrationRegistry, } from "./extension-registries.js";
@@ -41,7 +38,6 @@ export * from "./extension-types.js";
 /** Fallback extension priority used when callers do not provide an override. */
 export const DEFAULT_EXTENSION_PRIORITY = 100;
 let currentPmCliVersionPromise = null;
-/* Types now in extension-types.ts - re-exported via `export * from "./extension-types.js"` above */
 const DEFAULT_EXTENSION_POLICY = Object.freeze(createDefaultExtensionGovernancePolicy());
 let extensionReloadEpoch = 0;
 /** Implements next extension reload token for the public runtime surface of this module. */
@@ -945,115 +941,6 @@ async function runExtensionDeactivateWithTimeout(deactivate, timeoutMs) {
         clearTimeout(timeoutHandle);
     }
 }
-function isOutputRendererFormat(value) {
-    return value === "toon" || value === "json";
-}
-function isExtensionServiceName(value) {
-    return KNOWN_EXTENSION_SERVICE_NAMES.includes(value);
-}
-function assertHookHandler(hookName, hook) {
-    if (typeof hook !== "function") {
-        throw new TypeError(`api.hooks.${hookName} requires a function handler`);
-    }
-}
-function assertNonEmptyString(name, value) {
-    if (typeof value !== "string" || value.trim().length === 0) {
-        throw new TypeError(`${name} requires a non-empty string`);
-    }
-    return value.trim();
-}
-function assertFunctionHandler(name, value) {
-    if (typeof value !== "function") {
-        throw new TypeError(`${name} requires a function handler`);
-    }
-}
-function normalizeRegistrationName(name) {
-    return name
-        .trim()
-        .toLowerCase()
-        .split(/\s+/)
-        .filter((part) => part.length > 0)
-        .join(" ");
-}
-function toRegistrationCommandPath(name, action) {
-    return normalizeCommandName(`${name} ${action}`);
-}
-function sanitizeRegistrationValue(value) {
-    if (value === null) {
-        return null;
-    }
-    if (Array.isArray(value)) {
-        return value.map((entry) => sanitizeRegistrationValue(entry));
-    }
-    if (typeof value === "function") {
-        return "[Function]";
-    }
-    if (typeof value === "bigint") {
-        return value.toString();
-    }
-    if (typeof value === "symbol") {
-        return value.toString();
-    }
-    if (typeof value === "object") {
-        const record = value;
-        const normalized = {};
-        const keys = Object.keys(record).sort((left, right) => left.localeCompare(right));
-        for (const key of keys) {
-            normalized[key] = sanitizeRegistrationValue(record[key]);
-        }
-        return normalized;
-    }
-    return value;
-}
-function cloneRuntimeRegistrationValue(value) {
-    if (Array.isArray(value)) {
-        return value.map((entry) => cloneRuntimeRegistrationValue(entry));
-    }
-    if (typeof value === "object" && value !== null) {
-        const record = value;
-        const cloned = {};
-        for (const key of Object.keys(record).sort((left, right) => left.localeCompare(right))) {
-            cloned[key] = cloneRuntimeRegistrationValue(record[key]);
-        }
-        return cloned;
-    }
-    return value;
-}
-const EXTENSION_REGISTRATION_TRACE_SYMBOL = Symbol("extension_registration_trace");
-function createRegistrationValidationError(message, trace) {
-    const error = new TypeError(message);
-    Object.defineProperty(error, EXTENSION_REGISTRATION_TRACE_SYMBOL, {
-        value: trace,
-        enumerable: false,
-        configurable: false,
-        writable: false,
-    });
-    return error;
-}
-function extractRegistrationValidationTrace(error) {
-    if (!(error instanceof Error)) {
-        return undefined;
-    }
-    return error[EXTENSION_REGISTRATION_TRACE_SYMBOL];
-}
-function normalizeRegistrationRecord(name, value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        throw new TypeError(`${name} requires an object definition`);
-    }
-    return sanitizeRegistrationValue(value);
-}
-function normalizeRuntimeRegistrationRecord(name, value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        throw new TypeError(`${name} requires an object definition`);
-    }
-    return cloneRuntimeRegistrationValue(value);
-}
-function normalizeRegistrationRecordList(name, value) {
-    if (!Array.isArray(value)) {
-        throw new TypeError(`${name} requires an array of object definitions`);
-    }
-    return value.map((entry) => normalizeRegistrationRecord(name, entry));
-}
 const FLAG_DEFINITION_KEYS = new Set([
     "default",
     "description",
@@ -1108,7 +995,7 @@ function normalizeCommandDefinitionArguments(value) {
     const normalized = [];
     for (const [index, entry] of value.entries()) {
         const record = asRegistrationRecord(`registerCommand definition.arguments[${index}]`, entry);
-        const name = assertNonEmptyString(`registerCommand definition.arguments[${index}].name`, record.name);
+        const name = assertNonEmptyRegistrationString(`registerCommand definition.arguments[${index}].name`, record.name);
         assertOptionalBooleanField(`registerCommand definition.arguments[${index}].required`, record.required);
         assertOptionalBooleanField(`registerCommand definition.arguments[${index}].variadic`, record.variadic);
         assertOptionalStringField(`registerCommand definition.arguments[${index}].description`, record.description);
@@ -1218,8 +1105,8 @@ function validateItemFieldDefinitions(fields) {
     }
     for (const [index, raw] of fields.entries()) {
         const record = asRegistrationRecord(`registerItemFields fields[${index}]`, raw);
-        assertNonEmptyString(`registerItemFields fields[${index}].name`, record.name);
-        const fieldType = assertNonEmptyString(`registerItemFields fields[${index}].type`, record.type);
+        assertNonEmptyRegistrationString(`registerItemFields fields[${index}].name`, record.name);
+        const fieldType = assertNonEmptyRegistrationString(`registerItemFields fields[${index}].type`, record.type);
         if (normalizeItemFieldType(fieldType) === null) {
             const suggestion = suggestKnownItemFieldType(fieldType);
             const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
@@ -1241,8 +1128,8 @@ function validateItemTypeCommandOptionPolicies(typeIndex, value) {
     for (const [policyIndex, rawPolicy] of value.entries()) {
         const at = `${label}[${policyIndex}]`;
         const policy = asRegistrationRecord(at, rawPolicy);
-        assertNonEmptyString(`${at}.command`, policy.command);
-        assertNonEmptyString(`${at}.option`, policy.option);
+        assertNonEmptyRegistrationString(`${at}.command`, policy.command);
+        assertNonEmptyRegistrationString(`${at}.option`, policy.option);
         assertOptionalBooleanField(`${at}.enabled`, policy.enabled);
         assertOptionalBooleanField(`${at}.required`, policy.required);
         assertOptionalBooleanField(`${at}.visible`, policy.visible);
@@ -1260,7 +1147,7 @@ function validateItemTypeOptions(typeIndex, value) {
     for (const [optionIndex, rawOption] of value.entries()) {
         const at = `${label}[${optionIndex}]`;
         const option = asRegistrationRecord(at, rawOption);
-        assertNonEmptyString(`${at}.key`, option.key);
+        assertNonEmptyRegistrationString(`${at}.key`, option.key);
         assertOptionalStringArrayField(`${at}.values`, option.values);
         assertOptionalBooleanField(`${at}.required`, option.required);
         assertOptionalStringArrayField(`${at}.aliases`, option.aliases);
@@ -1273,7 +1160,7 @@ function validateItemTypeDefinitions(types) {
     for (const [typeIndex, raw] of types.entries()) {
         const at = `registerItemTypes types[${typeIndex}]`;
         const record = asRegistrationRecord(at, raw);
-        assertNonEmptyString(`${at}.name`, record.name);
+        assertNonEmptyRegistrationString(`${at}.name`, record.name);
         assertOptionalStringField(`${at}.folder`, record.folder);
         assertOptionalStringArrayField(`${at}.aliases`, record.aliases);
         assertOptionalStringArrayField(`${at}.required_create_fields`, record.required_create_fields);
@@ -1351,8 +1238,8 @@ const PROJECT_PROFILE_ENTRY_VALIDATORS = {
 };
 function validateProjectProfileDefinition(profile) {
     const record = asRegistrationRecord("registerProfile profile", profile);
-    assertNonEmptyString("registerProfile profile.name", record.name);
-    assertNonEmptyString("registerProfile profile.title", record.title);
+    assertNonEmptyRegistrationString("registerProfile profile.name", record.name);
+    assertNonEmptyRegistrationString("registerProfile profile.title", record.title);
     if (record.summary !== undefined && typeof record.summary !== "string") {
         throw new TypeError("registerProfile profile.summary must be a string when provided");
     }
@@ -1398,15 +1285,6 @@ function applyProjectProfileDefaults(profile) {
     }
     return profile;
 }
-function attachRuntimeDefinition(entry, runtimeDefinition) {
-    Object.defineProperty(entry, "runtime_definition", {
-        value: runtimeDefinition,
-        enumerable: false,
-        writable: false,
-        configurable: false,
-    });
-    return entry;
-}
 function getDeclaredExtensionCapabilities(extension) {
     if (!Array.isArray(extension.capabilities)) {
         return null;
@@ -1515,6 +1393,8 @@ class ExtensionApiRegistrar {
         this.registerSearchProvider = this.registerSearchProvider.bind(this);
         this.registerVectorStoreAdapter =
             this.registerVectorStoreAdapter.bind(this);
+        this.registerAssuranceMeasurementProvider =
+            this.registerAssuranceMeasurementProvider.bind(this);
         this.hooks = {
             beforeCommand: (hook) => this.registerBeforeCommand(hook),
             beforeMutation: (hook) => this.registerBeforeMutation(hook),
@@ -1662,8 +1542,8 @@ class ExtensionApiRegistrar {
         if (!this.allowRegistration("parser.override", "registerParser", "parser")) {
             return;
         }
-        const normalizedCommand = normalizeCommandName(assertNonEmptyString("registerParser command", command));
-        assertFunctionHandler("registerParser override", override);
+        const normalizedCommand = normalizeCommandName(assertNonEmptyRegistrationString("registerParser command", command));
+        assertRegistrationFunction("registerParser override", override);
         this.#parserRegistry.overrides.push({
             layer: this.#loadedExtension.layer,
             name: this.#loadedExtension.name,
@@ -1692,7 +1572,7 @@ class ExtensionApiRegistrar {
         if (!this.allowRegistration("services.override", "registerService", "services", { service: normalizedService })) {
             return;
         }
-        assertFunctionHandler("registerService override", override);
+        assertRegistrationFunction("registerService override", override);
         this.#serviceRegistry.overrides.push({
             layer: this.#loadedExtension.layer,
             name: this.#loadedExtension.name,
@@ -1740,7 +1620,7 @@ class ExtensionApiRegistrar {
         if (!this.allowRegistration("schema.flags", "registerFlags", "schema")) {
             return;
         }
-        const normalizedTargetCommand = normalizeCommandName(assertNonEmptyString("registerFlags targetCommand", targetCommand));
+        const normalizedTargetCommand = normalizeCommandName(assertNonEmptyRegistrationString("registerFlags targetCommand", targetCommand));
         validateFlagDefinitions(flags);
         const normalizedFlags = normalizeFlagDefinitions("registerFlags flags", flags);
         if (normalizedFlags.length === 0) {
@@ -1909,8 +1789,8 @@ class ExtensionApiRegistrar {
         if (!this.allowRegistration("importers.importer", "registerImporter", "importers")) {
             return;
         }
-        const normalizedName = normalizeRegistrationName(assertNonEmptyString("registerImporter name", name));
-        assertFunctionHandler("registerImporter importer", importer);
+        const normalizedName = normalizeRegistrationName(assertNonEmptyRegistrationString("registerImporter name", name));
+        assertRegistrationFunction("registerImporter importer", importer);
         const commandPath = toRegistrationCommandPath(normalizedName, "import");
         // Validate and register optional command metadata before mutating the registry
         // so an invalid options object leaves no partial importer registration.
@@ -1944,8 +1824,8 @@ class ExtensionApiRegistrar {
         if (!this.allowRegistration("importers.exporter", "registerExporter", "importers")) {
             return;
         }
-        const normalizedName = normalizeRegistrationName(assertNonEmptyString("registerExporter name", name));
-        assertFunctionHandler("registerExporter exporter", exporter);
+        const normalizedName = normalizeRegistrationName(assertNonEmptyRegistrationString("registerExporter name", name));
+        assertRegistrationFunction("registerExporter exporter", exporter);
         const commandPath = toRegistrationCommandPath(normalizedName, "export");
         // Validate and register optional command metadata before mutating the registry
         // so an invalid options object leaves no partial exporter registration.
@@ -1998,6 +1878,24 @@ class ExtensionApiRegistrar {
             definition: normalizeRegistrationRecord("registerVectorStoreAdapter adapter", adapter),
         }, runtimeDefinition));
     }
+    registerAssuranceMeasurementProvider(provider) {
+        assertExtensionCapability(this.#loadedExtension, "services", "registerAssuranceMeasurementProvider");
+        if (!this.allowRegistration("services.assuranceprovider", "registerAssuranceMeasurementProvider", "services")) {
+            return;
+        }
+        validateAssuranceMeasurementProviderDefinition(provider);
+        if (provider.network &&
+            this.#loadedExtension.permissions?.network !== true) {
+            throw new TypeError("registerAssuranceMeasurementProvider network provider requires permissions.network=true");
+        }
+        const runtimeDefinition = normalizeRuntimeRegistrationRecord("registerAssuranceMeasurementProvider provider", provider);
+        this.#registrationRegistry.assurance_providers.push(attachRuntimeDefinition({
+            layer: this.#loadedExtension.layer,
+            name: this.#loadedExtension.name,
+            network_permission: this.#loadedExtension.permissions?.network === true,
+            definition: normalizeRegistrationRecord("registerAssuranceMeasurementProvider provider", provider),
+        }, runtimeDefinition));
+    }
     registerBeforeCommand(hook) {
         assertExtensionCapability(this.#loadedExtension, "hooks", "api.hooks.beforeCommand");
         if (!this.allowRegistration("hooks.beforecommand", "api.hooks.beforeCommand", "hooks"))
@@ -2089,6 +1987,9 @@ function getRegistrationCounts(registrations) {
         exporters: registrations.exporters.length,
         search_providers: registrations.search_providers.length,
         vector_store_adapters: registrations.vector_store_adapters.length,
+        ...((registrations.assurance_providers?.length ?? 0) > 0
+            ? { assurance_providers: registrations.assurance_providers.length }
+            : {}),
     };
 }
 function collectCommandCollisionWarnings(commands) {
@@ -2144,7 +2045,9 @@ function collectRendererCollisionWarnings(renderers) {
         }
         const winner = bucket[bucket.length - 1];
         for (const displaced of bucket.slice(0, -1)) {
-            if (winner.commands?.length && displaced.commands?.length && !displaced.commands.some((command) => winner.commands?.includes(command))) {
+            if (winner.commands?.length &&
+                displaced.commands?.length &&
+                !displaced.commands.some((command) => winner.commands?.includes(command))) {
                 continue;
             }
             warnings.push(`extension_renderer_collision:${format}:${winner.layer}:${winner.name}:${displaced.layer}:${displaced.name}`);
@@ -2217,7 +2120,13 @@ export async function activateExtensions(loadResult) {
         }
         const failedBeforeActivation = failed.length;
         const rollbackPartialActivation = captureExtensionActivationRollback({
-            hooks, commands, parsers, preflight, services, renderers, registrations,
+            hooks,
+            commands,
+            parsers,
+            preflight,
+            services,
+            renderers,
+            registrations,
         });
         try {
             await activatable.activate(createExtensionApi(extension, hooks, commands, parsers, preflight, services, renderers, registrations, warnings, failed, policy));
@@ -2312,4 +2221,4 @@ export const _testOnlyLoader = {
     },
 };
 //# sourceMappingURL=loader.js.map
-//# debugId=3d5208e5-0ea5-54a5-82a8-50294b4a0655
+//# debugId=2b8750c3-7b19-5240-8179-f83830af1b77

package/dist/core/extensions/registration-values.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @module core/extensions/registration-values
+ *
+ * Preserves executable extension registrations while producing deterministic,
+ * serializable public inventory snapshots and validates assurance providers.
+ */
+import { type AssuranceMeasurementProviderDefinition, type ExtensionActivationFailureTrace, type ExtensionServiceName, type OutputRendererFormat } from "./extension-types.js";
+/** Narrow a string to a renderer format accepted by the extension host. */
+export declare function isOutputRendererFormat(value: string): value is OutputRendererFormat;
+/** Narrow a string to a service name accepted by the extension host. */
+export declare function isExtensionServiceName(value: string): value is ExtensionServiceName;
+/** Require a callable lifecycle hook before registry mutation. */
+export declare function assertHookHandler(hookName: string, hook: unknown): void;
+/** Create a validation error carrying a hidden structured activation trace. */
+export declare function createRegistrationValidationError(message: string, trace: ExtensionActivationFailureTrace): TypeError;
+/** Recover a hidden structured activation trace from a validation error. */
+export declare function extractRegistrationValidationTrace(error: unknown): ExtensionActivationFailureTrace | undefined;
+/** Recursively project an arbitrary registration value into serializable data. */
+export declare function sanitizeRegistrationValue(value: unknown): unknown;
+/** Recursively clone registration containers while preserving function identities. */
+export declare function cloneRuntimeRegistrationValue(value: unknown): unknown;
+/** Create a deterministic serializable registration snapshot with functions redacted. */
+export declare function normalizeRegistrationRecord(name: string, value: unknown): Record<string, unknown>;
+/** Clone a registration record without stripping executable function values. */
+export declare function normalizeRuntimeRegistrationRecord(name: string, value: unknown): Record<string, unknown>;
+/** Normalize every object in an array into deterministic serializable snapshots. */
+export declare function normalizeRegistrationRecordList<T extends object>(name: string, value: readonly T[]): T[];
+/** Normalize an untyped array crossing a JavaScript or JSON boundary. */
+export declare function normalizeRegistrationRecordList(name: string, value: unknown): Array<Record<string, unknown>>;
+/** Require a trimmed non-empty string at an extension authoring boundary. */
+export declare function assertNonEmptyRegistrationString(name: string, value: unknown): string;
+/** Require an executable handler at an extension authoring boundary. */
+export declare function assertRegistrationFunction(name: string, value: unknown): void;
+/** Canonicalize a user-facing registration name for stable routing. */
+export declare function normalizeRegistrationName(name: string): string;
+/** Build the canonical command path synthesized for an importer or exporter. */
+export declare function toRegistrationCommandPath(name: string, action: "import" | "export"): string;
+/** Attach an executable definition as hidden immutable runtime-only state. */
+export declare function attachRuntimeDefinition<TEntry extends {
+    definition: Record<string, unknown>;
+}>(entry: TEntry, runtimeDefinition: Record<string, unknown>): TEntry;
+/** Validate the closed provider schema before any activation registry mutation. */
+export declare function validateAssuranceMeasurementProviderDefinition(provider: unknown): asserts provider is AssuranceMeasurementProviderDefinition;