@unbrained/pm-cli 2026.10.4 → 2026.10.5

package/dist/core/extensions/loader.js

@@ -1,2 +1,2 @@
-!(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]="3ee03fc2-5b71-508c-8524-d22104fa2194")}catch(e2){}})();import fs from"node:fs/promises";import path from"node:path";import{pathToFileURL}from"node:url";import{createRelationshipKindRegistry}from"../../sdk/relationships.js";import{pathExists}from"../fs/fs-utils.js";import{isPathWithinDirectory}from"../fs/path-utils.js";import{isHostOutputSuppressed,suppressHostOutput}from"../output/output-control.js";import{resolvePmPackageRootFromModule}from"../packages/root.js";import{asRecordLoose,resolveActivatablePropertyRecord}from"../shared/primitives.js";import{resolveGlobalPmRoot}from"../store/paths.js";import{captureExtensionActivationRollback}from"./activation-transaction.js";import{assertCommandDefinitionMetadataStrings}from"./command-visibility-tier.js";import{normalizeExtensionContributionInventory}from"./contribution-inventory.js";import{buildImportExportContext,resolveImportExportArtifactOutput}from"./exporter-output-contract.js";import{buildReadyExtensionCandidate}from"./extension-candidate.js";import{collectUnknownExtensionCapabilities,formatLegacyExtensionCapabilityAliasWarning,formatUnknownExtensionCapabilityWarning,isKnownExtensionCapability,normalizeNames}from"./extension-capability-aliases.js";import{evaluateExtensionPolicyForCapability,evaluateExtensionPolicyForExtension,evaluateExtensionPolicyForRegistration,hydrateExtensionPolicy,normalizeExtensionPolicy,serializeExtensionPolicy}from"./extension-policy.js";import{createEmptyExtensionCommandRegistry,createEmptyExtensionHookRegistry,createEmptyExtensionParserRegistry,createEmptyExtensionPreflightRegistry,createEmptyExtensionRegistrationRegistry,createEmptyExtensionRendererRegistry,createEmptyExtensionServiceRegistry}from"./extension-registries.js";import{normalizeCommandName}from"./extension-runtime-helpers.js";import{KNOWN_EXTENSION_CAPABILITIES,KNOWN_EXTENSION_SERVICE_NAMES,createDefaultExtensionGovernancePolicy}from"./extension-types.js";import{parseExtensionManifestDocument}from"./manifest-parser.js";import{formatExtensionManifestSchemaWarnings}from"./manifest-schema.js";import{snapshotExtensionModuleGraph}from"./module-graph-snapshot.js";import{collectPreflightCollisionWarnings,normalizePreflightOverride}from"./preflight-ownership.js";import{applyProjectProfileDefaults,assertFlagValueTypeAndDefault,normalizeCommandDefinitionArguments,normalizeFlagDefinitions,resolveCommandDefinitionAction,validateFlagDefinitions,validateItemFieldDefinitions,validateItemTypeDefinitions,validateMigrationDefinition,validateProjectProfileDefinition}from"./registration-contracts.js";import{assertOptionalStringField,normalizeOptionalStringArrayField}from"./registration-validation.js";import{assertHookHandler,assertNonEmptyRegistrationString,assertRegistrationFunction,attachRuntimeDefinition,cloneRuntimeRegistrationValue,createRegistrationValidationError,extractRegistrationValidationTrace,isExtensionServiceName,isOutputRendererFormat,normalizeRegistrationName,normalizeRegistrationRecord,normalizeRegistrationRecordList,normalizeRuntimeRegistrationRecord,sanitizeRegistrationValue,toRegistrationCommandPath,validateAssuranceMeasurementProviderDefinition}from"./registration-values.js";import{normalizeServiceOverrideOwnership}from"./service-ownership.js";import{compareComparableVersions,evaluatePmMaxVersionBound,evaluatePmMinVersionBound,parseComparableVersion}from"./version-compat.js";import{parseLegacyExtensionCapabilityAliasWarning,parseUnknownExtensionCapabilityWarning}from"./extension-capability-aliases.js";import{createEmptyExtensionCommandRegistry as createEmptyExtensionCommandRegistry2,createEmptyExtensionHookRegistry as createEmptyExtensionHookRegistry2,createEmptyExtensionParserRegistry as createEmptyExtensionParserRegistry2,createEmptyExtensionPreflightRegistry as createEmptyExtensionPreflightRegistry2,createEmptyExtensionRegistrationRegistry as createEmptyExtensionRegistrationRegistry2,createEmptyExtensionRendererRegistry as createEmptyExtensionRendererRegistry2,createEmptyExtensionServiceRegistry as createEmptyExtensionServiceRegistry2}from"./extension-registries.js";import{runAfterCommandHooks,runBeforeCommandHooks,runBeforeMutationHooks,runCommandHandler,runCommandOverride,runOnIndexHooks,runOnReadHooks,runOnWriteHooks,runParserOverride,runPreflightOverride,runRendererOverride,runServiceOverride,runServiceOverrideSync}from"./extension-hook-runtime.js";export*from"./extension-types.js";import{DEFAULT_EXTENSION_PRIORITY,parseExtensionManifestDocument as parseExtensionManifestDocument2}from"./manifest-parser.js";let currentPmCliVersionPromise=null;const DEFAULT_EXTENSION_POLICY=Object.freeze(createDefaultExtensionGovernancePolicy());let extensionReloadEpoch=0;function nextExtensionReloadToken(seed=Date.now()){extensionReloadEpoch+=1;return`${extensionReloadEpoch}-${seed}`}function shouldEnable(name,enabled,disabled){if(disabled.has(name)){return false}if(enabled.size===0){return true}return enabled.has(name)}async function isCanonicalPathWithinDirectory(directory,targetPath){const[resolvedDirectory,resolvedTargetPath]=await Promise.all([fs.realpath(directory),fs.realpath(targetPath)]);return isPathWithinDirectory(resolvedDirectory,resolvedTargetPath)}function resolveExtensionRoots(pmRoot,cwd=process.cwd()){return{global:path.join(resolveGlobalPmRoot(cwd),"extensions"),project:path.join(pmRoot,"extensions")}}async function listExtensionDirectories(extensionsRoot){try{const entries=await fs.readdir(extensionsRoot,{withFileTypes:true});return entries.filter(entry=>entry.isDirectory()).map(entry=>entry.name).sort((a,b)=>a.localeCompare(b))}catch{return[]}}function summarizeCandidate(candidate){const summary={layer:candidate.layer,directory:candidate.directory,manifest_path:candidate.manifest_path,name:candidate.manifest.name,version:candidate.manifest.version,entry:candidate.manifest.entry,priority:candidate.manifest.priority,entry_path:candidate.entry_path,manifest_version:candidate.manifest.manifest_version,pm_min_version:candidate.manifest.pm_min_version,pm_max_version:candidate.manifest.pm_max_version,engines:candidate.manifest.engines,trusted:candidate.manifest.trusted,provenance:candidate.manifest.provenance,sandbox_profile:candidate.manifest.sandbox_profile,permissions:candidate.manifest.permissions,capabilities:[...candidate.manifest.capabilities],activation:candidate.manifest.activation?{commands:[...candidate.manifest.activation.commands]}:void 0,contributions:candidate.manifest.contributions??candidate.contributions};if(candidate.source_package){summary.source_package=candidate.source_package}if(candidate.source_aliases){summary.source_aliases=[...candidate.source_aliases]}return summary}function normalizeManagedSourcePackage(value){return typeof value==="string"&&value.trim().length>0?value.trim():void 0}async function readManagedExtensionSourcePackages(extensionsRoot){const packages=new Map;try{const parsed=JSON.parse(await fs.readFile(path.join(extensionsRoot,".managed-extensions.json"),"utf8"));const managedExtensions=asRecordLoose(parsed);const entries=managedExtensions?.entries;if(!Array.isArray(entries)){return packages}for(const entry of entries){if(typeof entry!=="object"||entry===null){continue}const record=entry;const sourcePackage=normalizeManagedSourcePackage(record.source?.package);const aliases=[record.source?.input,record.source?.name,sourcePackage].map(value=>normalizeManagedSourcePackage(value)).filter(value=>value!==void 0);const contributions=normalizeExtensionContributionInventory(record.contributions);const identity={aliases:[...new Set(aliases)],...sourcePackage?{package_name:sourcePackage}:{},...contributions?{contributions}:{}};if(typeof record.directory==="string"&&record.directory.trim().length>0){packages.set(`directory:${record.directory.trim()}`,identity)}if(typeof record.name==="string"&&record.name.trim().length>0){packages.set(`name:${record.name.trim()}`,identity)}}}catch{return packages}return packages}function sortCandidates(candidates){return[...candidates].sort((left,right)=>{if(left.manifest.priority!==right.manifest.priority){return left.manifest.priority-right.manifest.priority}const byName=left.manifest.name.localeCompare(right.manifest.name);if(byName!==0){return byName}return left.directory.localeCompare(right.directory)})}function buildEffectiveExtensions(globalCandidates,projectCandidates){const ordered=[...sortCandidates(globalCandidates),...sortCandidates(projectCandidates)];const effective=[];for(const candidate of ordered){const existingIndex=effective.findIndex(entry=>entry.manifest.name===candidate.manifest.name);if(existingIndex>=0){effective.splice(existingIndex,1)}effective.push(candidate)}return effective}async function scanExtensionLayer(layer,extensionsRoot,enabled,disabled,pmMaxVersionExceededMode){const diagnostics=[];const warnings=[];const candidates=[];const directories=await listExtensionDirectories(extensionsRoot);const managedSourcePackages=await readManagedExtensionSourcePackages(extensionsRoot);for(const directory of directories){const scanned=await scanExtensionDirectory(layer,extensionsRoot,directory,enabled,disabled,managedSourcePackages,pmMaxVersionExceededMode);diagnostics.push(scanned.diagnostic);warnings.push(...scanned.warnings);if(scanned.candidate){candidates.push(scanned.candidate)}}return{diagnostics,warnings,candidates}}function emptyExtensionLayerScan(){return{diagnostics:[],warnings:[],candidates:[]}}function buildUnavailableExtensionScan(layer,directory,manifestPath,warning){return{diagnostic:{layer,directory,manifest_path:manifestPath,name:null,version:null,entry:null,priority:null,entry_path:null,enabled:null,status:"warn"},warnings:[warning],candidate:null}}function collectScannedExtensionWarnings(layer,manifest,rawManifest,entryWithinDirectory,entryExists,pmVersionCompatibility,pmMaxVersionCompatibility){const extensionWarnings=formatExtensionManifestSchemaWarnings(layer,manifest,rawManifest);if(Array.isArray(manifest.legacy_capability_aliases)&&manifest.legacy_capability_aliases.length>0){extensionWarnings.push(formatLegacyExtensionCapabilityAliasWarning(layer,manifest.name,manifest.legacy_capability_aliases))}for(const capability of collectUnknownExtensionCapabilities(manifest.capabilities)){extensionWarnings.push(formatUnknownExtensionCapabilityWarning(layer,manifest.name,capability))}if(!entryWithinDirectory){extensionWarnings.push(`extension_entry_outside_extension:${layer}:${manifest.name}`)}else if(!entryExists){extensionWarnings.push(`extension_entry_missing:${layer}:${manifest.name}`)}if(pmVersionCompatibility.warning){extensionWarnings.push(pmVersionCompatibility.warning)}if(pmMaxVersionCompatibility.warning){extensionWarnings.push(pmMaxVersionCompatibility.warning)}return extensionWarnings}async function scanExtensionDirectory(layer,extensionsRoot,directory,enabled,disabled,managedSourcePackages,pmMaxVersionExceededMode){const extensionDir=path.join(extensionsRoot,directory);const manifestPath=path.join(extensionDir,"manifest.json");if(!await pathExists(manifestPath)){return buildUnavailableExtensionScan(layer,directory,manifestPath,`extension_manifest_missing:${layer}:${directory}`)}let manifest;let rawManifest;try{const parsed=JSON.parse(await fs.readFile(manifestPath,"utf8"));rawManifest=asRecordLoose(parsed);manifest=parseExtensionManifestDocument(parsed)}catch{rawManifest=null;manifest=null}if(!manifest||!rawManifest){return buildUnavailableExtensionScan(layer,directory,manifestPath,`extension_manifest_invalid:${layer}:${directory}`)}const entryPath=path.resolve(extensionDir,manifest.entry);const entryWithinDirectoryByPath=isPathWithinDirectory(extensionDir,entryPath);const entryExists=entryWithinDirectoryByPath?await pathExists(entryPath):false;const entryWithinDirectory=entryWithinDirectoryByPath&&entryExists?await isCanonicalPathWithinDirectory(extensionDir,entryPath):entryWithinDirectoryByPath;const enabledForLoad=shouldEnable(manifest.name,enabled,disabled);const pmVersionCompatibility=await evaluatePmMinVersionCompatibility(layer,manifest);const pmMaxVersionCompatibility=await evaluatePmMaxVersionCompatibility(layer,manifest,pmMaxVersionExceededMode);const extensionWarnings=collectScannedExtensionWarnings(layer,manifest,rawManifest,entryWithinDirectory,entryExists,pmVersionCompatibility,pmMaxVersionCompatibility);const extensionReady=entryWithinDirectory&&entryExists&&pmVersionCompatibility.allowed&&pmMaxVersionCompatibility.allowed;const sourceIdentity=managedSourcePackages.get(`directory:${directory}`)??managedSourcePackages.get(`name:${manifest.name}`);return{diagnostic:{layer,directory,manifest_path:manifestPath,name:manifest.name,version:manifest.version,entry:manifest.entry,priority:manifest.priority,entry_path:entryPath,enabled:enabledForLoad,status:extensionReady?"ok":"warn"},warnings:extensionWarnings,candidate:buildReadyExtensionCandidate({layer,directory,manifestPath,entryPath,manifest,sourceIdentity,extensionReady,enabledForLoad})}}async function discoverExtensions(options){const roots=resolveExtensionRoots(options.pmRoot,options.cwd??process.cwd());const configured_enabled=normalizeNames(options.settings.extensions.enabled);const configured_disabled=normalizeNames(options.settings.extensions.disabled);const policy=normalizeExtensionPolicy(options.settings);const serializedPolicy=serializeExtensionPolicy(policy);if(options.noExtensions){return{disabled_by_flag:true,roots,configured_enabled,configured_disabled,discovered:[],effective:[],warnings:[...policy.warnings],policy:serializedPolicy}}const enabled=new Set(configured_enabled);const disabled=new Set(configured_disabled);const globalScan=options.ignoreGlobalExtensions===true?emptyExtensionLayerScan():await scanExtensionLayer("global",roots.global,enabled,disabled,policy.pmMaxVersionExceededMode.global);const projectScan=await scanExtensionLayer("project",roots.project,enabled,disabled,policy.pmMaxVersionExceededMode.project);const policyWarnings=[...policy.warnings];const effectiveCandidates=buildEffectiveExtensions(globalScan.candidates,projectScan.candidates);const effective=[];for(const candidate of effectiveCandidates){const extensionRef={layer:candidate.layer,name:candidate.manifest.name,trusted:candidate.manifest.trusted===true,provenanceVerified:candidate.manifest.provenance?.verified===true,sandboxProfile:candidate.manifest.sandbox_profile,permissions:candidate.manifest.permissions&&typeof candidate.manifest.permissions==="object"?{fs_read:candidate.manifest.permissions.fs_read,fs_write:candidate.manifest.permissions.fs_write,network:candidate.manifest.permissions.network,env_read:candidate.manifest.permissions.env_read,env_write:candidate.manifest.permissions.env_write,process_spawn:candidate.manifest.permissions.process_spawn}:void 0};const extensionDecision=evaluateExtensionPolicyForExtension(policy,extensionRef);if(extensionDecision.warning){policyWarnings.push(extensionDecision.warning)}if(!extensionDecision.allowed){continue}for(const capability of candidate.manifest.capabilities){const capabilityDecision=evaluateExtensionPolicyForCapability(policy,extensionRef,capability);if(capabilityDecision.warning){policyWarnings.push(capabilityDecision.warning)}}effective.push(summarizeCandidate(candidate))}return{disabled_by_flag:false,roots,configured_enabled,configured_disabled,discovered:[...globalScan.diagnostics,...projectScan.diagnostics],effective,warnings:[...new Set([...globalScan.warnings,...projectScan.warnings,...policyWarnings])],policy:serializedPolicy}}function formatUnknownError(error){if(error instanceof Error&&error.message.trim().length>0){return error.message}return String(error)}async function readCurrentPmCliVersion(){try{const packageRoot=resolvePmPackageRootFromModule(import.meta.url,["../../.."]);const raw=await fs.readFile(path.join(packageRoot,"package.json"),"utf8");const parsed=JSON.parse(raw);return typeof parsed.version==="string"&&parsed.version.trim().length>0?parsed.version.trim():null}catch{return null}}function resolveCurrentPmCliVersion(){currentPmCliVersionPromise??=readCurrentPmCliVersion();return currentPmCliVersionPromise}function formatPmVersionCompatibilityWarning(layer,manifest,evaluation){const current=evaluation.current??"unknown";if(evaluation.kind==="pm_min_version"){switch(evaluation.status){case"invalid":return`extension_pm_min_version_invalid:${layer}:${manifest.name}:required=${evaluation.required}`;case"unchecked":return`extension_pm_min_version_unchecked:${layer}:${manifest.name}:required=${evaluation.required}:current=${current}`;case"unmet":return`extension_pm_min_version_unmet:${layer}:${manifest.name}:required=${evaluation.required}:current=${current}`;default:return void 0}}switch(evaluation.status){case"invalid":return`extension_pm_max_version_invalid:${layer}:${manifest.name}:allowed=${evaluation.required}`;case"unchecked":return`extension_pm_max_version_unchecked:${layer}:${manifest.name}:allowed=${evaluation.required}:current=${current}`;case"exceeded_warn":return`extension_pm_max_version_exceeded_warn:${layer}:${manifest.name}:allowed=${evaluation.required}:current=${current}`;case"exceeded":return`extension_pm_max_version_exceeded:${layer}:${manifest.name}:allowed=${evaluation.required}:current=${current}`;default:return void 0}}async function evaluatePmMinVersionCompatibility(layer,manifest){if(manifest.pm_min_version===void 0){return{allowed:true}}const evaluation=evaluatePmMinVersionBound(manifest.pm_min_version,await resolveCurrentPmCliVersion());const warning=formatPmVersionCompatibilityWarning(layer,manifest,evaluation);return warning?{allowed:evaluation.allowed,warning}:{allowed:evaluation.allowed}}async function evaluatePmMaxVersionCompatibility(layer,manifest,exceededMode){if(manifest.pm_max_version===void 0){return{allowed:true}}const evaluation=evaluatePmMaxVersionBound(manifest.pm_max_version,await resolveCurrentPmCliVersion(),exceededMode);const warning=formatPmVersionCompatibilityWarning(layer,manifest,evaluation);return warning?{allowed:evaluation.allowed,warning}:{allowed:evaluation.allowed}}async function fingerprintPath(pathToInspect){try{const stats=await fs.stat(pathToInspect);return`${Math.trunc(stats.mtimeMs)}-${stats.size}`}catch{return"missing"}}async function resolveExtensionImportHref(extension,options){let importEntryPath=extension.entry_path;if(options.module_graph_snapshot_root){importEntryPath=await snapshotExtensionModuleGraph(options.module_graph_snapshot_root,extension)}const baseUrl=new URL(pathToFileURL(importEntryPath).href);const shouldCacheBust=options.cache_bust===true||typeof options.reload_token==="string";if(!shouldCacheBust){return baseUrl.href}const[entryFingerprint,manifestFingerprint]=await Promise.all([fingerprintPath(extension.entry_path),fingerprintPath(extension.manifest_path)]);const reloadToken=options.reload_token??nextExtensionReloadToken();baseUrl.searchParams.set("pm_ext_reload",reloadToken);baseUrl.searchParams.set("pm_ext_entry",entryFingerprint);baseUrl.searchParams.set("pm_ext_manifest",manifestFingerprint);return baseUrl.href}async function loadExtensions(options){const discovery=await discoverExtensions(options);const loaded=[];const failed=[];const warnings=[...discovery.warnings];if(discovery.disabled_by_flag){return{...discovery,warnings,loaded,failed}}const extensionsToLoad=typeof options.extensionFilter==="function"?discovery.effective.filter(options.extensionFilter):discovery.effective;for(const extension of extensionsToLoad){try{const importHref=await resolveExtensionImportHref(extension,options);const module=await import(importHref);loaded.push({...extension,module})}catch(error){warnings.push(`extension_load_failed:${extension.layer}:${extension.name}`);failed.push({layer:extension.layer,name:extension.name,entry_path:extension.entry_path,error:formatUnknownError(error)})}}return{...discovery,warnings,loaded,failed}}const DEFAULT_EXTENSION_DEACTIVATE_TIMEOUT_MS=5e3;const MAX_EXTENSION_DEACTIVATE_TIMEOUT_MS=2147483647;function toActivatableExtension(source){const activate=source.activate;const activatable={activate:activate.bind(source)};if(typeof source.deactivate==="function"){const deactivate=source.deactivate;activatable.deactivate=deactivate.bind(source)}return activatable}function resolveActivatableExtension(module){const activatableRecord=resolveActivatablePropertyRecord(module);return activatableRecord?toActivatableExtension(activatableRecord):null}async function deactivateExtensions(loadResult,activationResult,options={}){const timeoutMs=normalizeExtensionDeactivateTimeout(options?.deactivate_timeout_ms);const failedActivationKeys=new Set((activationResult?.failed??[]).map(entry=>`${entry.layer}:${entry.name}`));const targets=[];for(const extension of loadResult.loaded){if(failedActivationKeys.has(`${extension.layer}:${extension.name}`)){continue}const activatable=resolveActivatableExtension(extension.module);if(!activatable||typeof activatable.deactivate!=="function"){continue}targets.push({extension,deactivate:activatable.deactivate})}const outcomes=await Promise.all(targets.map(async({extension,deactivate})=>{try{await runExtensionDeactivateWithTimeout(deactivate,timeoutMs);return{ok:true}}catch(error){return{ok:false,layer:extension.layer,name:extension.name,error:formatUnknownError(error)}}}));const warnings=[];const failed=[];let deactivated=0;for(const outcome of outcomes){if(outcome.ok){deactivated+=1;continue}warnings.push(`extension_deactivate_failed:${outcome.layer}:${outcome.name}`);failed.push({layer:outcome.layer,name:outcome.name,error:outcome.error})}return{deactivated,warnings,failed}}function normalizeExtensionDeactivateTimeout(rawTimeout){if(typeof rawTimeout!=="number"||rawTimeout<0){return DEFAULT_EXTENSION_DEACTIVATE_TIMEOUT_MS}if(rawTimeout===0||rawTimeout===Infinity){return 0}if(!Number.isFinite(rawTimeout)){return DEFAULT_EXTENSION_DEACTIVATE_TIMEOUT_MS}return Math.min(MAX_EXTENSION_DEACTIVATE_TIMEOUT_MS,Math.max(1,Math.floor(rawTimeout)))}async function runExtensionDeactivateWithTimeout(deactivate,timeoutMs){if(timeoutMs===0){await deactivate();return}let timeoutHandle;try{const deactivatePromise=Promise.resolve().then(()=>deactivate());deactivatePromise.catch(()=>{});await Promise.race([deactivatePromise,new Promise((_,reject)=>{timeoutHandle=setTimeout(()=>{reject(new Error(`extension deactivate timed out after ${timeoutMs}ms`))},timeoutMs);timeoutHandle.unref?.()})])}finally{clearTimeout(timeoutHandle)}}function getDeclaredExtensionCapabilities(extension){if(!Array.isArray(extension.capabilities)){return null}const declared=new Set;for(const capability of extension.capabilities){const normalized=capability.trim().toLowerCase();if(isKnownExtensionCapability(normalized)){declared.add(normalized)}}return declared}function assertExtensionCapability(extension,capability,method){const declared=getDeclaredExtensionCapabilities(extension);if(declared===null){return}if(!declared.has(capability)){throw createRegistrationValidationError(`${method} requires capability '${capability}' in extension manifest capabilities`,{method,registration_index:-1,capability,missing_capability:capability,expected_schema:`"capabilities": [..., "${capability}"]`,received:extension.capabilities,hint:`Add "${capability}" to ${extension.name} manifest capabilities, or remove the ${method} registration call.`})}}function buildExtensionSelfIdentity(extension){return Object.freeze({name:extension.name,layer:extension.layer,version:extension.version,capabilities:Object.freeze((extension.capabilities??[]).filter(capability=>KNOWN_EXTENSION_CAPABILITIES.includes(capability))),pm_min_version:extension.pm_min_version,pm_max_version:extension.pm_max_version,source_package:extension.source_package})}function buildPolicyExtensionRef(extension){return{layer:extension.layer,name:extension.name,trusted:extension.trusted===true,provenanceVerified:extension.provenance?.verified===true,sandboxProfile:extension.sandbox_profile,permissions:extension.permissions&&typeof extension.permissions==="object"?{fs_read:extension.permissions.fs_read,fs_write:extension.permissions.fs_write,network:extension.permissions.network,env_read:extension.permissions.env_read,env_write:extension.permissions.env_write,process_spawn:extension.permissions.process_spawn}:void 0}}class ExtensionApiRegistrar{extension;hooks;#loadedExtension;#extensionRef;#hookRegistry;#commandRegistry;#parserRegistry;#preflightRegistry;#serviceRegistry;#rendererRegistry;#registrationRegistry;#activationWarnings;#activationFailures;#policy;constructor(extension,hooks,commands,parsers,preflight,services,renderers,registrations,activationWarnings,activationFailures,policy){this.#loadedExtension=extension;this.extension=buildExtensionSelfIdentity(extension);this.#extensionRef=buildPolicyExtensionRef(extension);this.#hookRegistry=hooks;this.#commandRegistry=commands;this.#parserRegistry=parsers;this.#preflightRegistry=preflight;this.#serviceRegistry=services;this.#rendererRegistry=renderers;this.#registrationRegistry=registrations;this.#activationWarnings=activationWarnings;this.#activationFailures=activationFailures;this.#policy=policy;this.registerCommand=this.registerCommand.bind(this);this.registerParser=this.registerParser.bind(this);this.registerPreflight=this.registerPreflight.bind(this);this.registerService=this.registerService.bind(this);this.registerFlags=this.registerFlags.bind(this);this.registerItemFields=this.registerItemFields.bind(this);this.registerItemTypes=this.registerItemTypes.bind(this);this.registerRelationshipKinds=this.registerRelationshipKinds.bind(this);this.registerMigration=this.registerMigration.bind(this);this.registerProfile=this.registerProfile.bind(this);this.registerRenderer=this.registerRenderer.bind(this);this.registerImporter=this.registerImporter.bind(this);this.registerExporter=this.registerExporter.bind(this);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),afterCommand:hook=>this.registerAfterCommand(hook),onWrite:hook=>this.registerOnWrite(hook),onRead:hook=>this.registerOnRead(hook),onIndex:hook=>this.registerOnIndex(hook)}}allowRegistration(surface,method,capability,details){const decision=evaluateExtensionPolicyForRegistration(this.#policy,this.#extensionRef,surface,method,capability,details);if(decision.warning){this.#activationWarnings.push(decision.warning)}return decision.allowed}registerCommandTrace(mode,command,expectedSchema,received,hint){return{method:"registerCommand",registration_index:mode==="override"?this.#commandRegistry.overrides.length:this.#commandRegistry.handlers.length,command,expected_schema:expectedSchema,received:sanitizeRegistrationValue(received),hint}}registerCommandOverride(command,override){const normalizedCommand=normalizeCommandName(command);if(normalizedCommand.length===0){throw createRegistrationValidationError("registerCommand requires a non-empty command name",this.registerCommandTrace("override",command,'registerCommand("<command>", (context) => unknown)',command,"Provide a non-empty command path as the first argument."))}if(typeof override!=="function"){const trace=this.registerCommandTrace("override",normalizedCommand,'registerCommand("<command>", (context) => unknown)',override,"Provide a function as the second registerCommand argument.");throw createRegistrationValidationError(`registerCommand requires an override function when command name is provided (command="${normalizedCommand}", registration_index=${trace.registration_index})`,trace)}if(!this.allowRegistration("commands.override","registerCommand","commands",{command:normalizedCommand})){return}this.#commandRegistry.overrides.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,command:normalizedCommand,run:override})}resolveCommandDefinitionRunHandler(definition,normalizedCommand){const runHandler=typeof definition.run==="function"?definition.run:void 0;const legacyHandler=typeof definition.handler==="function"?definition.handler:void 0;if(!runHandler&&legacyHandler){this.#activationWarnings.push(`extension_command_definition_legacy_handler_alias:${this.#loadedExtension.layer}:${this.#loadedExtension.name}:${normalizedCommand}`)}return runHandler??legacyHandler}registerCommandDefinition(definition){if(typeof definition!=="object"||definition===null){throw createRegistrationValidationError("registerCommand requires a command definition object",this.registerCommandTrace("definition",void 0,"{ name: string; run: (context) => unknown; }",definition,'Use registerCommand({ name: "command path", run: (context) => ... }).'))}if(typeof definition.name!=="string"){throw createRegistrationValidationError("registerCommand requires a command definition name",this.registerCommandTrace("definition",void 0,"{ name: string; run: (context) => unknown; }",definition,"Set command definition.name to a non-empty string command path."))}const normalizedCommand=normalizeCommandName(definition.name);if(normalizedCommand.length===0){throw createRegistrationValidationError("registerCommand requires a non-empty command definition name",this.registerCommandTrace("definition",definition.name,"{ name: string; run: (context) => unknown; }",definition,"Ensure command definition.name contains a non-empty command path."))}const resolvedHandler=this.resolveCommandDefinitionRunHandler(definition,normalizedCommand);if(typeof resolvedHandler!=="function"){const trace=this.registerCommandTrace("definition",normalizedCommand,"{ name: string; run: (context) => unknown; }",resolvedHandler,"Define command definition.run as a function.");throw createRegistrationValidationError(`registerCommand requires a command definition run handler (command="${normalizedCommand}", registration_index=${trace.registration_index})`,trace)}try{assertCommandDefinitionMetadataStrings(definition);const action=resolveCommandDefinitionAction(normalizedCommand,definition.action);if(!this.allowRegistration("commands.handler","registerCommand","commands",{command:normalizedCommand,action})){return}const description=definition.description?.trim();const intent=definition.intent?.trim();const examples=normalizeOptionalStringArrayField("registerCommand definition.examples",definition.examples);const failureHints=normalizeOptionalStringArrayField("registerCommand definition.failure_hints",definition.failure_hints);const argumentsDefinition=normalizeCommandDefinitionArguments(definition.arguments);if(definition.flags!==void 0){assertExtensionCapability(this.#loadedExtension,"schema","registerCommand flags");if(this.allowRegistration("schema.flags","registerCommand flags","schema")){validateFlagDefinitions(definition.flags);this.#registrationRegistry.flags.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,target_command:normalizedCommand,flags:normalizeFlagDefinitions("registerCommand definition.flags",definition.flags)})}}const registration={layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,source_package:this.#loadedExtension.source_package,command:normalizedCommand,action,examples,failure_hints:failureHints,arguments:argumentsDefinition,tier:definition.tier??"standard",family:definition.family??"extensions"};if(description){registration.description=description}if(intent){registration.intent=intent}this.#registrationRegistry.commands.push(registration)}catch(error){const reason=formatUnknownError(error);const trace=this.registerCommandTrace("definition",normalizedCommand,"{ name: string; run: (context) => unknown; action?: string; arguments?: object[]; flags?: object[]; }",definition,reason);const validationError=createRegistrationValidationError(`registerCommand definition metadata invalid (command="${normalizedCommand}", registration_index=${trace.registration_index}): ${reason}`,trace);this.#activationWarnings.push(`extension_command_quarantined:${this.#loadedExtension.layer}:${this.#loadedExtension.name}:${normalizedCommand}`);this.#activationFailures.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,entry_path:this.#loadedExtension.entry_path,error:validationError.message,trace});return}this.#commandRegistry.handlers.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,command:normalizedCommand,run:resolvedHandler})}registerCommand(commandOrDefinition,override){assertExtensionCapability(this.#loadedExtension,"commands","registerCommand");if(typeof commandOrDefinition==="string"){this.registerCommandOverride(commandOrDefinition,override);return}this.registerCommandDefinition(commandOrDefinition)}registerParser(command,override){assertExtensionCapability(this.#loadedExtension,"parser","registerParser");if(!this.allowRegistration("parser.override","registerParser","parser")){return}const normalizedCommand=normalizeCommandName(assertNonEmptyRegistrationString("registerParser command",command));assertRegistrationFunction("registerParser override",override);this.#parserRegistry.overrides.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,command:normalizedCommand,run:override})}registerPreflight(override){assertExtensionCapability(this.#loadedExtension,"preflight","registerPreflight");if(!this.allowRegistration("preflight.override","registerPreflight","preflight")){return}const normalized=normalizePreflightOverride(override);this.#preflightRegistry.overrides.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,...normalized})}registerService(service,override,ownership={}){assertExtensionCapability(this.#loadedExtension,"services","registerService");const normalizedService=String(service).trim().toLowerCase();if(!isExtensionServiceName(normalizedService)){throw new TypeError(`registerService service must be one of: ${KNOWN_EXTENSION_SERVICE_NAMES.join(", ")}`)}if(!this.allowRegistration("services.override","registerService","services",{service:normalizedService})){return}assertRegistrationFunction("registerService override",override);this.#serviceRegistry.overrides.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,service:normalizedService,run:override,...normalizeServiceOverrideOwnership(ownership)?{passThrough:true}:{}})}registerRenderer(format,renderer,ownership={}){assertExtensionCapability(this.#loadedExtension,"renderers","registerRenderer");if(!this.allowRegistration("renderers.override","registerRenderer","renderers")){return}if(typeof renderer!=="function"){throw new TypeError("registerRenderer requires a renderer function")}const normalizedFormat=String(format).trim().toLowerCase();if(!isOutputRendererFormat(normalizedFormat)){throw new Error(`registerRenderer format must be toon|json, received: ${String(format)}`)}if(ownership.resultDiscriminator!==void 0&&typeof ownership.resultDiscriminator!=="function"){throw new TypeError("registerRenderer ownership.resultDiscriminator must be a function when provided")}const commands=[...new Set((ownership.commands??[]).map(command=>{if(typeof command!=="string"||command.trim().length===0){throw new TypeError("registerRenderer ownership.commands must contain non-empty command paths")}return normalizeCommandName(command)}))];this.#rendererRegistry.overrides.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,format:normalizedFormat,run:renderer,commands,...ownership.resultDiscriminator?{resultDiscriminator:ownership.resultDiscriminator}:{}})}registerFlags(targetCommand,flags){assertExtensionCapability(this.#loadedExtension,"schema","registerFlags");if(!this.allowRegistration("schema.flags","registerFlags","schema")){return}const normalizedTargetCommand=normalizeCommandName(assertNonEmptyRegistrationString("registerFlags targetCommand",targetCommand));validateFlagDefinitions(flags);const normalizedFlags=normalizeFlagDefinitions("registerFlags flags",flags);if(normalizedFlags.length===0){throw new TypeError("registerFlags requires at least one flag definition")}this.#registrationRegistry.flags.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,target_command:normalizedTargetCommand,flags:normalizedFlags})}registerItemFields(fields){assertExtensionCapability(this.#loadedExtension,"schema","registerItemFields");if(!this.allowRegistration("schema.itemfields","registerItemFields","schema")){return}validateItemFieldDefinitions(fields);const normalizedFields=normalizeRegistrationRecordList("registerItemFields fields",fields);if(normalizedFields.length===0){throw new TypeError("registerItemFields requires at least one field definition")}this.#registrationRegistry.item_fields.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,fields:normalizedFields})}registerItemTypes(types){assertExtensionCapability(this.#loadedExtension,"schema","registerItemTypes");if(!this.allowRegistration("schema.itemtypes","registerItemTypes","schema")){return}validateItemTypeDefinitions(types);const normalizedTypes=normalizeRegistrationRecordList("registerItemTypes types",types);if(normalizedTypes.length===0){throw new TypeError("registerItemTypes requires at least one type definition")}this.#registrationRegistry.item_types.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,types:normalizedTypes})}registerRelationshipKinds(definitions){assertExtensionCapability(this.#loadedExtension,"schema","registerRelationshipKinds");if(!this.allowRegistration("schema.relationshipkinds","registerRelationshipKinds","schema")){return}if(!Array.isArray(definitions)){throw new TypeError("registerRelationshipKinds definitions requires an array of object definitions")}if(definitions.length===0){throw new TypeError("registerRelationshipKinds requires at least one definition")}const registry=createRelationshipKindRegistry();for(const registration of this.#registrationRegistry.relationship_kinds){for(const definition of registration.definitions){registry.register(definition)}}const validated=definitions.map(definition=>{registry.register(definition);return registry.require(definition.kind)});this.#registrationRegistry.relationship_kinds.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,definitions:validated})}registerMigration(definition){assertExtensionCapability(this.#loadedExtension,"schema","registerMigration");if(!this.allowRegistration("schema.migrations","registerMigration","schema")){return}validateMigrationDefinition(definition);const runtimeDefinition=normalizeRuntimeRegistrationRecord("registerMigration definition",definition);this.#registrationRegistry.migrations.push(attachRuntimeDefinition({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,definition:normalizeRegistrationRecord("registerMigration definition",definition)},runtimeDefinition))}registerProfile(profile){assertExtensionCapability(this.#loadedExtension,"schema","registerProfile");if(!this.allowRegistration("schema.profiles","registerProfile","schema")){return}const snapshot=cloneRuntimeRegistrationValue(profile);validateProjectProfileDefinition(snapshot);this.#registrationRegistry.profiles.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,profile:applyProjectProfileDefaults(snapshot)})}registerImportExportCommandFlags(method,commandPath,resolvedOptions){if(resolvedOptions.flags===void 0){return}assertExtensionCapability(this.#loadedExtension,"schema",`${method} options.flags`);if(!this.allowRegistration("schema.flags",`${method} options.flags`,"schema")){return}validateFlagDefinitions(resolvedOptions.flags);this.#registrationRegistry.flags.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,target_command:commandPath,flags:normalizeFlagDefinitions(`${method} options.flags`,resolvedOptions.flags)})}applyImportExportCommandMetadata(method,commandPath,options){if(options!==void 0&&(typeof options!=="object"||options===null||Array.isArray(options))){throw new TypeError(`${method} options must be an object when provided`)}const defaultDescription=`${method==="registerImporter"?"Import":"Export"} items with the registered extension adapter.`;const defaultArguments=[{name:"file",required:false,description:"Optional input or output file path."}];const resolvedOptions={...options,description:options?.description??defaultDescription,arguments:options?.arguments??defaultArguments};const output=resolveImportExportArtifactOutput(method,resolvedOptions,options?.description!==void 0);assertOptionalStringField(`${method} options.action`,resolvedOptions.action);assertOptionalStringField(`${method} options.description`,resolvedOptions.description);assertOptionalStringField(`${method} options.intent`,resolvedOptions.intent);const action=resolveCommandDefinitionAction(commandPath,resolvedOptions.action);const examples=normalizeOptionalStringArrayField(`${method} options.examples`,resolvedOptions.examples);const failureHints=normalizeOptionalStringArrayField(`${method} options.failure_hints`,resolvedOptions.failure_hints);const argumentsDefinition=normalizeCommandDefinitionArguments(resolvedOptions.arguments);this.registerImportExportCommandFlags(method,commandPath,resolvedOptions);const registration={layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,source_package:this.#loadedExtension.source_package,command:commandPath,action,examples,failure_hints:failureHints,arguments:argumentsDefinition};const description=resolvedOptions.description?.trim();if(description){registration.description=description}const intent=resolvedOptions.intent?.trim();if(intent){registration.intent=intent}this.#registrationRegistry.commands.push(registration);return output}registerImporter(name,importer,options){assertExtensionCapability(this.#loadedExtension,"importers","registerImporter");if(!this.allowRegistration("importers.importer","registerImporter","importers")){return}const normalizedName=normalizeRegistrationName(assertNonEmptyRegistrationString("registerImporter name",name));assertRegistrationFunction("registerImporter importer",importer);const commandPath=toRegistrationCommandPath(normalizedName,"import");this.applyImportExportCommandMetadata("registerImporter",commandPath,options);this.#registrationRegistry.importers.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,importer:normalizedName});this.#commandRegistry.handlers.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,command:commandPath,run:async context=>importer(buildImportExportContext(context,normalizedName,"import"))})}registerExporter(name,exporter,options){assertExtensionCapability(this.#loadedExtension,"importers","registerExporter");if(!this.allowRegistration("importers.exporter","registerExporter","importers")){return}const normalizedName=normalizeRegistrationName(assertNonEmptyRegistrationString("registerExporter name",name));assertRegistrationFunction("registerExporter exporter",exporter);const commandPath=toRegistrationCommandPath(normalizedName,"export");const output=this.applyImportExportCommandMetadata("registerExporter",commandPath,options);this.#registrationRegistry.exporters.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,exporter:normalizedName,...output===void 0?{}:{output}});this.#commandRegistry.handlers.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,command:commandPath,run:async context=>{const result=await exporter(buildImportExportContext(context,normalizedName,"export"));return output?.receipt==="suppress"&&!isHostOutputSuppressed(result)?suppressHostOutput(result):result}})}registerSearchProvider(provider){assertExtensionCapability(this.#loadedExtension,"search","registerSearchProvider");if(!this.allowRegistration("search.provider","registerSearchProvider","search")){return}const runtimeDefinition=normalizeRuntimeRegistrationRecord("registerSearchProvider provider",provider);this.#registrationRegistry.search_providers.push(attachRuntimeDefinition({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,definition:normalizeRegistrationRecord("registerSearchProvider provider",provider)},runtimeDefinition))}registerVectorStoreAdapter(adapter){assertExtensionCapability(this.#loadedExtension,"search","registerVectorStoreAdapter");if(!this.allowRegistration("search.vectorstore","registerVectorStoreAdapter","search")){return}const runtimeDefinition=normalizeRuntimeRegistrationRecord("registerVectorStoreAdapter adapter",adapter);this.#registrationRegistry.vector_store_adapters.push(attachRuntimeDefinition({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,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"))return;assertHookHandler("beforeCommand",hook);this.#hookRegistry.beforeCommand.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,run:hook})}registerBeforeMutation(hook){assertExtensionCapability(this.#loadedExtension,"hooks","api.hooks.beforeMutation");if(!this.allowRegistration("hooks.beforemutation","api.hooks.beforeMutation","hooks"))return;assertHookHandler("beforeMutation",hook);this.#hookRegistry.beforeMutation.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,run:hook})}registerAfterCommand(hook){assertExtensionCapability(this.#loadedExtension,"hooks","api.hooks.afterCommand");if(!this.allowRegistration("hooks.aftercommand","api.hooks.afterCommand","hooks"))return;assertHookHandler("afterCommand",hook);this.#hookRegistry.afterCommand.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,run:hook})}registerOnWrite(hook){assertExtensionCapability(this.#loadedExtension,"hooks","api.hooks.onWrite");if(!this.allowRegistration("hooks.onwrite","api.hooks.onWrite","hooks"))return;assertHookHandler("onWrite",hook);this.#hookRegistry.onWrite.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,run:hook})}registerOnRead(hook){assertExtensionCapability(this.#loadedExtension,"hooks","api.hooks.onRead");if(!this.allowRegistration("hooks.onread","api.hooks.onRead","hooks"))return;assertHookHandler("onRead",hook);this.#hookRegistry.onRead.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,run:hook})}registerOnIndex(hook){assertExtensionCapability(this.#loadedExtension,"hooks","api.hooks.onIndex");if(!this.allowRegistration("hooks.onindex","api.hooks.onIndex","hooks"))return;assertHookHandler("onIndex",hook);this.#hookRegistry.onIndex.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,run:hook})}}function createExtensionApi(extension,hooks,commands,parsers,preflight,services,renderers,registrations,activationWarnings,activationFailures,policy){return new ExtensionApiRegistrar(extension,hooks,commands,parsers,preflight,services,renderers,registrations,activationWarnings,activationFailures,policy)}function getRegistrationCounts(registrations){const commandCount=registrations.commands.length;const flagCount=registrations.flags.reduce((total,entry)=>total+entry.flags.length,0);const itemFieldCount=registrations.item_fields.reduce((total,entry)=>total+entry.fields.length,0);const itemTypeCount=registrations.item_types.reduce((total,entry)=>total+entry.types.length,0);const relationshipKindCount=(registrations.relationship_kinds??[]).reduce((total,entry)=>total+entry.definitions.length,0);return{commands:commandCount,flags:flagCount,item_fields:itemFieldCount,item_types:itemTypeCount,...relationshipKindCount>0?{relationship_kinds:relationshipKindCount}:{},migrations:registrations.migrations.length,profiles:registrations.profiles.length,importers:registrations.importers.length,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){const warnings=[];const collectByCommand=(entries,codePrefix)=>{const grouped=new Map;for(const entry of entries){const bucket=grouped.get(entry.command)??[];bucket.push(entry);grouped.set(entry.command,bucket)}for(const command of[...grouped.keys()].sort((left,right)=>left.localeCompare(right))){const bucket=grouped.get(command);if(bucket.length<=1){continue}const winner=bucket[bucket.length-1];for(const displaced of bucket.slice(0,-1)){warnings.push(`${codePrefix}:${command}:${winner.layer}:${winner.name}:${displaced.layer}:${displaced.name}`)}}};collectByCommand(commands.handlers,"extension_command_handler_collision");collectByCommand(commands.overrides,"extension_command_override_collision");const handlerCommands=new Set(commands.handlers.map(entry=>entry.command));const overlapCommands=[...new Set(commands.overrides.map(entry=>entry.command))].filter(command=>handlerCommands.has(command));overlapCommands.sort((left,right)=>left.localeCompare(right));for(const command of overlapCommands){const handlers=commands.handlers.filter(entry=>entry.command===command);const overrides=commands.overrides.filter(entry=>entry.command===command);for(const override of overrides){for(const handler of handlers){warnings.push(`extension_command_override_handler_overlap:${command}:${override.layer}:${override.name}:${handler.layer}:${handler.name}`)}}}return warnings}function collectRendererCollisionWarnings(renderers){const grouped=new Map;for(const entry of renderers.overrides){const bucket=grouped.get(entry.format)??[];bucket.push(entry);grouped.set(entry.format,bucket)}const warnings=[];for(const format of[...grouped.keys()].sort((left,right)=>left.localeCompare(right))){const bucket=grouped.get(format);if(bucket.length<=1){continue}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))){continue}warnings.push(`extension_renderer_collision:${format}:${winner.layer}:${winner.name}:${displaced.layer}:${displaced.name}`)}}return warnings}function collectParserCollisionWarnings(parsers){const warnings=[];const grouped=new Map;for(const entry of parsers.overrides){const bucket=grouped.get(entry.command)??[];bucket.push(entry);grouped.set(entry.command,bucket)}for(const command of[...grouped.keys()].sort((left,right)=>left.localeCompare(right))){const bucket=grouped.get(command);if(bucket.length<=1){continue}const winner=bucket[bucket.length-1];for(const displaced of bucket.slice(0,-1)){warnings.push(`extension_parser_override_collision:${command}:${winner.layer}:${winner.name}:${displaced.layer}:${displaced.name}`)}}return warnings}const CHAINED_SERVICE_NAMES=new Set(["output_format"]);function collectServiceCollisionWarnings(services){const warnings=[];const grouped=new Map;for(const entry of services.overrides){const bucket=grouped.get(entry.service)??[];bucket.push(entry);grouped.set(entry.service,bucket)}for(const service of[...grouped.keys()].sort((left,right)=>left.localeCompare(right))){const bucket=grouped.get(service);if(bucket.length<=1){continue}if(CHAINED_SERVICE_NAMES.has(service)){continue}const winner=bucket[bucket.length-1];for(const displaced of bucket.slice(0,-1)){warnings.push(`extension_service_override_collision:${service}:${winner.layer}:${winner.name}:${displaced.layer}:${displaced.name}`)}}return warnings}async function activateExtensions(loadResult){const policy=hydrateExtensionPolicy(loadResult.policy??DEFAULT_EXTENSION_POLICY);const hooks=createEmptyExtensionHookRegistry();const commands=createEmptyExtensionCommandRegistry();const parsers=createEmptyExtensionParserRegistry();const preflight=createEmptyExtensionPreflightRegistry();const services=createEmptyExtensionServiceRegistry();const renderers=createEmptyExtensionRendererRegistry();const registrations=createEmptyExtensionRegistrationRegistry();const failed=[];const warnings=[];for(const extension of loadResult.loaded){const activatable=resolveActivatableExtension(extension.module);if(!activatable){continue}const failedBeforeActivation=failed.length;const rollbackPartialActivation=captureExtensionActivationRollback({hooks,commands,parsers,preflight,services,renderers,registrations});try{await activatable.activate(createExtensionApi(extension,hooks,commands,parsers,preflight,services,renderers,registrations,warnings,failed,policy));if(failed.length>failedBeforeActivation){rollbackPartialActivation();warnings.push(`extension_activation_rolled_back:${extension.layer}:${extension.name}`)}}catch(error){rollbackPartialActivation();warnings.push(`extension_activate_failed:${extension.layer}:${extension.name}`);const trace=extractRegistrationValidationTrace(error);failed.push({layer:extension.layer,name:extension.name,entry_path:extension.entry_path,error:formatUnknownError(error),trace})}}const collisionWarnings=[...collectCommandCollisionWarnings(commands),...collectParserCollisionWarnings(parsers),...collectPreflightCollisionWarnings(preflight),...collectServiceCollisionWarnings(services),...collectRendererCollisionWarnings(renderers)];const mergedWarnings=[...new Set([...warnings,...collisionWarnings])];return{hooks,commands,parsers,preflight,services,renderers,registrations,failed,warnings:mergedWarnings,hook_counts:{before_command:hooks.beforeCommand.length,before_mutation:hooks.beforeMutation.length,after_command:hooks.afterCommand.length,on_write:hooks.onWrite.length,on_read:hooks.onRead.length,on_index:hooks.onIndex.length},command_override_count:commands.overrides.length,command_handler_count:commands.handlers.length,parser_override_count:parsers.overrides.length,preflight_override_count:preflight.overrides.length,service_override_count:services.overrides.length,renderer_override_count:renderers.overrides.length,registration_counts:getRegistrationCounts(registrations)}}const _testOnlyLoader={assertFlagValueTypeAndDefault,assertOptionalStringField,compareComparableVersions,collectCommandCollisionWarnings,collectParserCollisionWarnings,collectRendererCollisionWarnings,collectServiceCollisionWarnings,createExtensionApi,createRegistrationValidationError,evaluatePmMaxVersionCompatibility,evaluatePmMinVersionCompatibility,extractRegistrationValidationTrace,fingerprintPath,getRegistrationCounts,normalizeCommandDefinitionArguments,normalizeExtensionDeactivateTimeout,normalizeOptionalStringArrayField,normalizeRegistrationRecord,normalizeRegistrationRecordList,normalizeRuntimeRegistrationRecord,parseComparableVersion,parseManifest:parseExtensionManifestDocument,readCurrentPmCliVersion,readManagedExtensionSourcePackages:async extensionsRoot=>new Map([...await readManagedExtensionSourcePackages(extensionsRoot)].filter(entry=>typeof entry[1].package_name==="string").map(([key,identity])=>[key,identity.package_name])),resolveExtensionImportHref,resolveCurrentPmCliVersion,resolveCommandDefinitionAction,sanitizeRegistrationValue,validateItemFieldDefinitions,resetCurrentPmCliVersionCacheForTest:()=>{currentPmCliVersionPromise=null}};export{DEFAULT_EXTENSION_PRIORITY,_testOnlyLoader,activateExtensions,createEmptyExtensionCommandRegistry2 as createEmptyExtensionCommandRegistry,createEmptyExtensionHookRegistry2 as createEmptyExtensionHookRegistry,createEmptyExtensionParserRegistry2 as createEmptyExtensionParserRegistry,createEmptyExtensionPreflightRegistry2 as createEmptyExtensionPreflightRegistry,createEmptyExtensionRegistrationRegistry2 as createEmptyExtensionRegistrationRegistry,createEmptyExtensionRendererRegistry2 as createEmptyExtensionRendererRegistry,createEmptyExtensionServiceRegistry2 as createEmptyExtensionServiceRegistry,deactivateExtensions,discoverExtensions,isCanonicalPathWithinDirectory,loadExtensions,nextExtensionReloadToken,parseExtensionManifestDocument2 as parseExtensionManifestDocument,parseLegacyExtensionCapabilityAliasWarning,parseUnknownExtensionCapabilityWarning,resolveExtensionRoots,runAfterCommandHooks,runBeforeCommandHooks,runBeforeMutationHooks,runCommandHandler,runCommandOverride,runOnIndexHooks,runOnReadHooks,runOnWriteHooks,runParserOverride,runPreflightOverride,runRendererOverride,runServiceOverride,runServiceOverrideSync};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="79f32043-06a1-5929-ac52-bc4a003806fc")}catch{}})();import fs from"node:fs/promises";import path from"node:path";import{pathToFileURL}from"node:url";import{createRelationshipKindRegistry}from"../../sdk/relationships.js";import{pathExists}from"../fs/fs-utils.js";import{isPathWithinDirectory}from"../fs/path-utils.js";import{isHostOutputSuppressed,suppressHostOutput}from"../output/output-control.js";import{resolvePmPackageRootFromModule}from"../packages/root.js";import{asRecordLoose,resolveActivatablePropertyRecord}from"../shared/primitives.js";import{resolveGlobalPmRoot}from"../store/paths.js";import{captureExtensionActivationRollback}from"./activation-transaction.js";import{assertCommandDefinitionMetadataStrings}from"./command-visibility-tier.js";import{normalizeExtensionContributionInventory}from"./contribution-inventory.js";import{buildImportExportContext,resolveImportExportArtifactOutput}from"./exporter-output-contract.js";import{buildReadyExtensionCandidate}from"./extension-candidate.js";import{collectUnknownExtensionCapabilities,formatLegacyExtensionCapabilityAliasWarning,formatUnknownExtensionCapabilityWarning,isKnownExtensionCapability,normalizeNames}from"./extension-capability-aliases.js";import{evaluateExtensionPolicyForCapability,evaluateExtensionPolicyForExtension,evaluateExtensionPolicyForRegistration,hydrateExtensionPolicy,normalizeExtensionPolicy,serializeExtensionPolicy}from"./extension-policy.js";import{createEmptyExtensionCommandRegistry,createEmptyExtensionHookRegistry,createEmptyExtensionParserRegistry,createEmptyExtensionPreflightRegistry,createEmptyExtensionRegistrationRegistry,createEmptyExtensionRendererRegistry,createEmptyExtensionServiceRegistry}from"./extension-registries.js";import{normalizeCommandName}from"./extension-runtime-helpers.js";import{KNOWN_EXTENSION_CAPABILITIES,KNOWN_EXTENSION_SERVICE_NAMES,createDefaultExtensionGovernancePolicy}from"./extension-types.js";import{parseExtensionManifestDocument}from"./manifest-parser.js";import{formatExtensionManifestSchemaWarnings}from"./manifest-schema.js";import{snapshotExtensionModuleGraph}from"./module-graph-snapshot.js";import{collectPreflightCollisionWarnings,normalizePreflightOverride}from"./preflight-ownership.js";import{applyProjectProfileDefaults,assertFlagValueTypeAndDefault,normalizeCommandDefinitionArguments,normalizeFlagDefinitions,resolveCommandDefinitionAction,validateFlagDefinitions,validateItemFieldDefinitions,validateItemTypeDefinitions,validateMigrationDefinition,validateProjectProfileDefinition}from"./registration-contracts.js";import{assertOptionalStringField,normalizeOptionalStringArrayField}from"./registration-validation.js";import{assertHookHandler,assertNonEmptyRegistrationString,assertRegistrationFunction,attachRuntimeDefinition,cloneRuntimeRegistrationValue,createRegistrationValidationError,extractRegistrationValidationTrace,isExtensionServiceName,isOutputRendererFormat,normalizeRegistrationName,normalizeRegistrationRecord,normalizeRegistrationRecordList,normalizeRuntimeRegistrationRecord,sanitizeRegistrationValue,toRegistrationCommandPath,validateAssuranceMeasurementProviderDefinition}from"./registration-values.js";import{normalizeServiceOverrideOwnership}from"./service-ownership.js";import{compareComparableVersions,evaluatePmMaxVersionBound,evaluatePmMinVersionBound,parseComparableVersion}from"./version-compat.js";import{parseLegacyExtensionCapabilityAliasWarning,parseUnknownExtensionCapabilityWarning}from"./extension-capability-aliases.js";import{createEmptyExtensionCommandRegistry as createEmptyExtensionCommandRegistry2,createEmptyExtensionHookRegistry as createEmptyExtensionHookRegistry2,createEmptyExtensionParserRegistry as createEmptyExtensionParserRegistry2,createEmptyExtensionPreflightRegistry as createEmptyExtensionPreflightRegistry2,createEmptyExtensionRegistrationRegistry as createEmptyExtensionRegistrationRegistry2,createEmptyExtensionRendererRegistry as createEmptyExtensionRendererRegistry2,createEmptyExtensionServiceRegistry as createEmptyExtensionServiceRegistry2}from"./extension-registries.js";import{runAfterCommandHooks,runBeforeCommandHooks,runBeforeMutationHooks,runCommandHandler,runCommandOverride,runOnIndexHooks,runOnReadHooks,runOnWriteHooks,runParserOverride,runPreflightOverride,runRendererOverride,runServiceOverride,runServiceOverrideSync}from"./extension-hook-runtime.js";export*from"./extension-types.js";import{DEFAULT_EXTENSION_PRIORITY,parseExtensionManifestDocument as parseExtensionManifestDocument2}from"./manifest-parser.js";let currentPmCliVersionPromise=null;const DEFAULT_EXTENSION_POLICY=Object.freeze(createDefaultExtensionGovernancePolicy());let extensionReloadEpoch=0;function nextExtensionReloadToken(seed=Date.now()){return extensionReloadEpoch+=1,`${extensionReloadEpoch}-${seed}`}function shouldEnable(name,enabled,disabled){return disabled.has(name)?!1:enabled.size===0?!0:enabled.has(name)}async function isCanonicalPathWithinDirectory(directory,targetPath){const[resolvedDirectory,resolvedTargetPath]=await Promise.all([fs.realpath(directory),fs.realpath(targetPath)]);return isPathWithinDirectory(resolvedDirectory,resolvedTargetPath)}function resolveExtensionRoots(pmRoot,cwd=process.cwd()){return{global:path.join(resolveGlobalPmRoot(cwd),"extensions"),project:path.join(pmRoot,"extensions")}}async function listExtensionDirectories(extensionsRoot){try{return(await fs.readdir(extensionsRoot,{withFileTypes:!0})).filter(entry=>entry.isDirectory()).map(entry=>entry.name).sort((a,b)=>a.localeCompare(b))}catch{return[]}}function summarizeCandidate(candidate){const summary={layer:candidate.layer,directory:candidate.directory,manifest_path:candidate.manifest_path,name:candidate.manifest.name,version:candidate.manifest.version,entry:candidate.manifest.entry,priority:candidate.manifest.priority,entry_path:candidate.entry_path,manifest_version:candidate.manifest.manifest_version,pm_min_version:candidate.manifest.pm_min_version,pm_max_version:candidate.manifest.pm_max_version,engines:candidate.manifest.engines,trusted:candidate.manifest.trusted,provenance:candidate.manifest.provenance,sandbox_profile:candidate.manifest.sandbox_profile,permissions:candidate.manifest.permissions,capabilities:[...candidate.manifest.capabilities],activation:candidate.manifest.activation?{commands:[...candidate.manifest.activation.commands]}:void 0,contributions:candidate.manifest.contributions??candidate.contributions};return candidate.source_package&&(summary.source_package=candidate.source_package),candidate.source_aliases&&(summary.source_aliases=[...candidate.source_aliases]),summary}function normalizeManagedSourcePackage(value){return typeof value=="string"&&value.trim().length>0?value.trim():void 0}async function readManagedExtensionSourcePackages(extensionsRoot){const packages=new Map;try{const parsed=JSON.parse(await fs.readFile(path.join(extensionsRoot,".managed-extensions.json"),"utf8")),entries=asRecordLoose(parsed)?.entries;if(!Array.isArray(entries))return packages;for(const entry of entries){if(typeof entry!="object"||entry===null)continue;const record=entry,sourcePackage=normalizeManagedSourcePackage(record.source?.package),aliases=[record.source?.input,record.source?.name,sourcePackage].map(value=>normalizeManagedSourcePackage(value)).filter(value=>value!==void 0),contributions=normalizeExtensionContributionInventory(record.contributions),identity={aliases:[...new Set(aliases)],...sourcePackage?{package_name:sourcePackage}:{},...contributions?{contributions}:{}};typeof record.directory=="string"&&record.directory.trim().length>0&&packages.set(`directory:${record.directory.trim()}`,identity),typeof record.name=="string"&&record.name.trim().length>0&&packages.set(`name:${record.name.trim()}`,identity)}}catch{return packages}return packages}function sortCandidates(candidates){return[...candidates].sort((left,right)=>{if(left.manifest.priority!==right.manifest.priority)return left.manifest.priority-right.manifest.priority;const byName=left.manifest.name.localeCompare(right.manifest.name);return byName!==0?byName:left.directory.localeCompare(right.directory)})}function buildEffectiveExtensions(globalCandidates,projectCandidates){const ordered=[...sortCandidates(globalCandidates),...sortCandidates(projectCandidates)],effective=[];for(const candidate of ordered){const existingIndex=effective.findIndex(entry=>entry.manifest.name===candidate.manifest.name);existingIndex>=0&&effective.splice(existingIndex,1),effective.push(candidate)}return effective}async function scanExtensionLayer(layer,extensionsRoot,enabled,disabled,pmMaxVersionExceededMode){const diagnostics=[],warnings=[],candidates=[],directories=await listExtensionDirectories(extensionsRoot),managedSourcePackages=await readManagedExtensionSourcePackages(extensionsRoot);for(const directory of directories){const scanned=await scanExtensionDirectory(layer,extensionsRoot,directory,enabled,disabled,managedSourcePackages,pmMaxVersionExceededMode);diagnostics.push(scanned.diagnostic),warnings.push(...scanned.warnings),scanned.candidate&&candidates.push(scanned.candidate)}return{diagnostics,warnings,candidates}}function emptyExtensionLayerScan(){return{diagnostics:[],warnings:[],candidates:[]}}function buildUnavailableExtensionScan(layer,directory,manifestPath,warning){return{diagnostic:{layer,directory,manifest_path:manifestPath,name:null,version:null,entry:null,priority:null,entry_path:null,enabled:null,status:"warn"},warnings:[warning],candidate:null}}function collectScannedExtensionWarnings(layer,manifest,rawManifest,entryWithinDirectory,entryExists,pmVersionCompatibility,pmMaxVersionCompatibility){const extensionWarnings=formatExtensionManifestSchemaWarnings(layer,manifest,rawManifest);Array.isArray(manifest.legacy_capability_aliases)&&manifest.legacy_capability_aliases.length>0&&extensionWarnings.push(formatLegacyExtensionCapabilityAliasWarning(layer,manifest.name,manifest.legacy_capability_aliases));for(const capability of collectUnknownExtensionCapabilities(manifest.capabilities))extensionWarnings.push(formatUnknownExtensionCapabilityWarning(layer,manifest.name,capability));return entryWithinDirectory?entryExists||extensionWarnings.push(`extension_entry_missing:${layer}:${manifest.name}`):extensionWarnings.push(`extension_entry_outside_extension:${layer}:${manifest.name}`),pmVersionCompatibility.warning&&extensionWarnings.push(pmVersionCompatibility.warning),pmMaxVersionCompatibility.warning&&extensionWarnings.push(pmMaxVersionCompatibility.warning),extensionWarnings}async function scanExtensionDirectory(layer,extensionsRoot,directory,enabled,disabled,managedSourcePackages,pmMaxVersionExceededMode){const extensionDir=path.join(extensionsRoot,directory),manifestPath=path.join(extensionDir,"manifest.json");if(!await pathExists(manifestPath))return buildUnavailableExtensionScan(layer,directory,manifestPath,`extension_manifest_missing:${layer}:${directory}`);let manifest,rawManifest;try{const parsed=JSON.parse(await fs.readFile(manifestPath,"utf8"));rawManifest=asRecordLoose(parsed),manifest=parseExtensionManifestDocument(parsed)}catch{rawManifest=null,manifest=null}if(!manifest||!rawManifest)return buildUnavailableExtensionScan(layer,directory,manifestPath,`extension_manifest_invalid:${layer}:${directory}`);const entryPath=path.resolve(extensionDir,manifest.entry),entryWithinDirectoryByPath=isPathWithinDirectory(extensionDir,entryPath),entryExists=entryWithinDirectoryByPath?await pathExists(entryPath):!1,entryWithinDirectory=entryWithinDirectoryByPath&&entryExists?await isCanonicalPathWithinDirectory(extensionDir,entryPath):entryWithinDirectoryByPath,enabledForLoad=shouldEnable(manifest.name,enabled,disabled),pmVersionCompatibility=await evaluatePmMinVersionCompatibility(layer,manifest),pmMaxVersionCompatibility=await evaluatePmMaxVersionCompatibility(layer,manifest,pmMaxVersionExceededMode),extensionWarnings=collectScannedExtensionWarnings(layer,manifest,rawManifest,entryWithinDirectory,entryExists,pmVersionCompatibility,pmMaxVersionCompatibility),extensionReady=entryWithinDirectory&&entryExists&&pmVersionCompatibility.allowed&&pmMaxVersionCompatibility.allowed,sourceIdentity=managedSourcePackages.get(`directory:${directory}`)??managedSourcePackages.get(`name:${manifest.name}`);return{diagnostic:{layer,directory,manifest_path:manifestPath,name:manifest.name,version:manifest.version,entry:manifest.entry,priority:manifest.priority,entry_path:entryPath,enabled:enabledForLoad,status:extensionReady?"ok":"warn"},warnings:extensionWarnings,candidate:buildReadyExtensionCandidate({layer,directory,manifestPath,entryPath,manifest,sourceIdentity,extensionReady,enabledForLoad})}}async function discoverExtensions(options){const roots=resolveExtensionRoots(options.pmRoot,options.cwd??process.cwd()),configured_enabled=normalizeNames(options.settings.extensions.enabled),configured_disabled=normalizeNames(options.settings.extensions.disabled),policy=normalizeExtensionPolicy(options.settings),serializedPolicy=serializeExtensionPolicy(policy);if(options.noExtensions)return{disabled_by_flag:!0,roots,configured_enabled,configured_disabled,discovered:[],effective:[],warnings:[...policy.warnings],policy:serializedPolicy};const enabled=new Set(configured_enabled),disabled=new Set(configured_disabled),globalScan=options.ignoreGlobalExtensions===!0?emptyExtensionLayerScan():await scanExtensionLayer("global",roots.global,enabled,disabled,policy.pmMaxVersionExceededMode.global),projectScan=await scanExtensionLayer("project",roots.project,enabled,disabled,policy.pmMaxVersionExceededMode.project),policyWarnings=[...policy.warnings],effectiveCandidates=buildEffectiveExtensions(globalScan.candidates,projectScan.candidates),effective=[];for(const candidate of effectiveCandidates){const extensionRef={layer:candidate.layer,name:candidate.manifest.name,trusted:candidate.manifest.trusted===!0,provenanceVerified:candidate.manifest.provenance?.verified===!0,sandboxProfile:candidate.manifest.sandbox_profile,permissions:candidate.manifest.permissions&&typeof candidate.manifest.permissions=="object"?{fs_read:candidate.manifest.permissions.fs_read,fs_write:candidate.manifest.permissions.fs_write,network:candidate.manifest.permissions.network,env_read:candidate.manifest.permissions.env_read,env_write:candidate.manifest.permissions.env_write,process_spawn:candidate.manifest.permissions.process_spawn}:void 0},extensionDecision=evaluateExtensionPolicyForExtension(policy,extensionRef);if(extensionDecision.warning&&policyWarnings.push(extensionDecision.warning),!!extensionDecision.allowed){for(const capability of candidate.manifest.capabilities){const capabilityDecision=evaluateExtensionPolicyForCapability(policy,extensionRef,capability);capabilityDecision.warning&&policyWarnings.push(capabilityDecision.warning)}effective.push(summarizeCandidate(candidate))}}return{disabled_by_flag:!1,roots,configured_enabled,configured_disabled,discovered:[...globalScan.diagnostics,...projectScan.diagnostics],effective,warnings:[...new Set([...globalScan.warnings,...projectScan.warnings,...policyWarnings])],policy:serializedPolicy}}function formatUnknownError(error){return error instanceof Error&&error.message.trim().length>0?error.message:String(error)}async function readCurrentPmCliVersion(){try{const packageRoot=resolvePmPackageRootFromModule(import.meta.url,["../../.."]),raw=await fs.readFile(path.join(packageRoot,"package.json"),"utf8"),parsed=JSON.parse(raw);return typeof parsed.version=="string"&&parsed.version.trim().length>0?parsed.version.trim():null}catch{return null}}function resolveCurrentPmCliVersion(){return currentPmCliVersionPromise??=readCurrentPmCliVersion(),currentPmCliVersionPromise}function formatPmVersionCompatibilityWarning(layer,manifest,evaluation){const current=evaluation.current??"unknown";if(evaluation.kind==="pm_min_version")switch(evaluation.status){case"invalid":return`extension_pm_min_version_invalid:${layer}:${manifest.name}:required=${evaluation.required}`;case"unchecked":return`extension_pm_min_version_unchecked:${layer}:${manifest.name}:required=${evaluation.required}:current=${current}`;case"unmet":return`extension_pm_min_version_unmet:${layer}:${manifest.name}:required=${evaluation.required}:current=${current}`;default:return}switch(evaluation.status){case"invalid":return`extension_pm_max_version_invalid:${layer}:${manifest.name}:allowed=${evaluation.required}`;case"unchecked":return`extension_pm_max_version_unchecked:${layer}:${manifest.name}:allowed=${evaluation.required}:current=${current}`;case"exceeded_warn":return`extension_pm_max_version_exceeded_warn:${layer}:${manifest.name}:allowed=${evaluation.required}:current=${current}`;case"exceeded":return`extension_pm_max_version_exceeded:${layer}:${manifest.name}:allowed=${evaluation.required}:current=${current}`;default:return}}async function evaluatePmMinVersionCompatibility(layer,manifest){if(manifest.pm_min_version===void 0)return{allowed:!0};const evaluation=evaluatePmMinVersionBound(manifest.pm_min_version,await resolveCurrentPmCliVersion()),warning=formatPmVersionCompatibilityWarning(layer,manifest,evaluation);return warning?{allowed:evaluation.allowed,warning}:{allowed:evaluation.allowed}}async function evaluatePmMaxVersionCompatibility(layer,manifest,exceededMode){if(manifest.pm_max_version===void 0)return{allowed:!0};const evaluation=evaluatePmMaxVersionBound(manifest.pm_max_version,await resolveCurrentPmCliVersion(),exceededMode),warning=formatPmVersionCompatibilityWarning(layer,manifest,evaluation);return warning?{allowed:evaluation.allowed,warning}:{allowed:evaluation.allowed}}async function fingerprintPath(pathToInspect){try{const stats=await fs.stat(pathToInspect);return`${Math.trunc(stats.mtimeMs)}-${stats.size}`}catch{return"missing"}}async function resolveExtensionImportHref(extension,options){let importEntryPath=extension.entry_path;options.module_graph_snapshot_root&&(importEntryPath=await snapshotExtensionModuleGraph(options.module_graph_snapshot_root,extension));const baseUrl=new URL(pathToFileURL(importEntryPath).href);if(!(options.cache_bust===!0||typeof options.reload_token=="string"))return baseUrl.href;const[entryFingerprint,manifestFingerprint]=await Promise.all([fingerprintPath(extension.entry_path),fingerprintPath(extension.manifest_path)]),reloadToken=options.reload_token??nextExtensionReloadToken();return baseUrl.searchParams.set("pm_ext_reload",reloadToken),baseUrl.searchParams.set("pm_ext_entry",entryFingerprint),baseUrl.searchParams.set("pm_ext_manifest",manifestFingerprint),baseUrl.href}async function loadExtensions(options){const discovery=await discoverExtensions(options),loaded=[],failed=[],warnings=[...discovery.warnings];if(discovery.disabled_by_flag)return{...discovery,warnings,loaded,failed};const extensionsToLoad=typeof options.extensionFilter=="function"?discovery.effective.filter(options.extensionFilter):discovery.effective;for(const extension of extensionsToLoad)try{const module=await import(await resolveExtensionImportHref(extension,options));loaded.push({...extension,module})}catch(error){warnings.push(`extension_load_failed:${extension.layer}:${extension.name}`),failed.push({layer:extension.layer,name:extension.name,entry_path:extension.entry_path,error:formatUnknownError(error)})}return{...discovery,warnings,loaded,failed}}const DEFAULT_EXTENSION_DEACTIVATE_TIMEOUT_MS=5e3,MAX_EXTENSION_DEACTIVATE_TIMEOUT_MS=2147483647;function toActivatableExtension(source){const activatable={activate:source.activate.bind(source)};if(typeof source.deactivate=="function"){const deactivate=source.deactivate;activatable.deactivate=deactivate.bind(source)}return activatable}function resolveActivatableExtension(module){const activatableRecord=resolveActivatablePropertyRecord(module);return activatableRecord?toActivatableExtension(activatableRecord):null}async function deactivateExtensions(loadResult,activationResult,options={}){const timeoutMs=normalizeExtensionDeactivateTimeout(options?.deactivate_timeout_ms),failedActivationKeys=new Set((activationResult?.failed??[]).map(entry=>`${entry.layer}:${entry.name}`)),targets=[];for(const extension of loadResult.loaded){if(failedActivationKeys.has(`${extension.layer}:${extension.name}`))continue;const activatable=resolveActivatableExtension(extension.module);!activatable||typeof activatable.deactivate!="function"||targets.push({extension,deactivate:activatable.deactivate})}const outcomes=await Promise.all(targets.map(async({extension,deactivate})=>{try{return await runExtensionDeactivateWithTimeout(deactivate,timeoutMs),{ok:!0}}catch(error){return{ok:!1,layer:extension.layer,name:extension.name,error:formatUnknownError(error)}}})),warnings=[],failed=[];let deactivated=0;for(const outcome of outcomes){if(outcome.ok){deactivated+=1;continue}warnings.push(`extension_deactivate_failed:${outcome.layer}:${outcome.name}`),failed.push({layer:outcome.layer,name:outcome.name,error:outcome.error})}return{deactivated,warnings,failed}}function normalizeExtensionDeactivateTimeout(rawTimeout){return typeof rawTimeout!="number"||rawTimeout<0?DEFAULT_EXTENSION_DEACTIVATE_TIMEOUT_MS:rawTimeout===0||rawTimeout===1/0?0:Number.isFinite(rawTimeout)?Math.min(MAX_EXTENSION_DEACTIVATE_TIMEOUT_MS,Math.max(1,Math.floor(rawTimeout))):DEFAULT_EXTENSION_DEACTIVATE_TIMEOUT_MS}async function runExtensionDeactivateWithTimeout(deactivate,timeoutMs){if(timeoutMs===0){await deactivate();return}let timeoutHandle;try{const deactivatePromise=Promise.resolve().then(()=>deactivate());deactivatePromise.catch(()=>{}),await Promise.race([deactivatePromise,new Promise((_,reject)=>{timeoutHandle=setTimeout(()=>{reject(new Error(`extension deactivate timed out after ${timeoutMs}ms`))},timeoutMs),timeoutHandle.unref?.()})])}finally{clearTimeout(timeoutHandle)}}function getDeclaredExtensionCapabilities(extension){if(!Array.isArray(extension.capabilities))return null;const declared=new Set;for(const capability of extension.capabilities){const normalized=capability.trim().toLowerCase();isKnownExtensionCapability(normalized)&&declared.add(normalized)}return declared}function assertExtensionCapability(extension,capability,method){const declared=getDeclaredExtensionCapabilities(extension);if(declared!==null&&!declared.has(capability))throw createRegistrationValidationError(`${method} requires capability '${capability}' in extension manifest capabilities`,{method,registration_index:-1,capability,missing_capability:capability,expected_schema:`"capabilities": [..., "${capability}"]`,received:extension.capabilities,hint:`Add "${capability}" to ${extension.name} manifest capabilities, or remove the ${method} registration call.`})}function buildExtensionSelfIdentity(extension){return Object.freeze({name:extension.name,layer:extension.layer,version:extension.version,capabilities:Object.freeze((extension.capabilities??[]).filter(capability=>KNOWN_EXTENSION_CAPABILITIES.includes(capability))),pm_min_version:extension.pm_min_version,pm_max_version:extension.pm_max_version,source_package:extension.source_package})}function buildPolicyExtensionRef(extension){return{layer:extension.layer,name:extension.name,trusted:extension.trusted===!0,provenanceVerified:extension.provenance?.verified===!0,sandboxProfile:extension.sandbox_profile,permissions:extension.permissions&&typeof extension.permissions=="object"?{fs_read:extension.permissions.fs_read,fs_write:extension.permissions.fs_write,network:extension.permissions.network,env_read:extension.permissions.env_read,env_write:extension.permissions.env_write,process_spawn:extension.permissions.process_spawn}:void 0}}class ExtensionApiRegistrar{extension;hooks;#loadedExtension;#extensionRef;#hookRegistry;#commandRegistry;#parserRegistry;#preflightRegistry;#serviceRegistry;#rendererRegistry;#registrationRegistry;#activationWarnings;#activationFailures;#policy;constructor(extension,hooks,commands,parsers,preflight,services,renderers,registrations,activationWarnings,activationFailures,policy){this.#loadedExtension=extension,this.extension=buildExtensionSelfIdentity(extension),this.#extensionRef=buildPolicyExtensionRef(extension),this.#hookRegistry=hooks,this.#commandRegistry=commands,this.#parserRegistry=parsers,this.#preflightRegistry=preflight,this.#serviceRegistry=services,this.#rendererRegistry=renderers,this.#registrationRegistry=registrations,this.#activationWarnings=activationWarnings,this.#activationFailures=activationFailures,this.#policy=policy,this.registerCommand=this.registerCommand.bind(this),this.registerParser=this.registerParser.bind(this),this.registerPreflight=this.registerPreflight.bind(this),this.registerService=this.registerService.bind(this),this.registerFlags=this.registerFlags.bind(this),this.registerItemFields=this.registerItemFields.bind(this),this.registerItemTypes=this.registerItemTypes.bind(this),this.registerRelationshipKinds=this.registerRelationshipKinds.bind(this),this.registerMigration=this.registerMigration.bind(this),this.registerProfile=this.registerProfile.bind(this),this.registerRenderer=this.registerRenderer.bind(this),this.registerImporter=this.registerImporter.bind(this),this.registerExporter=this.registerExporter.bind(this),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),afterCommand:hook=>this.registerAfterCommand(hook),onWrite:hook=>this.registerOnWrite(hook),onRead:hook=>this.registerOnRead(hook),onIndex:hook=>this.registerOnIndex(hook)}}allowRegistration(surface,method,capability,details){const decision=evaluateExtensionPolicyForRegistration(this.#policy,this.#extensionRef,surface,method,capability,details);return decision.warning&&this.#activationWarnings.push(decision.warning),decision.allowed}registerCommandTrace(mode,command,expectedSchema,received,hint){return{method:"registerCommand",registration_index:mode==="override"?this.#commandRegistry.overrides.length:this.#commandRegistry.handlers.length,command,expected_schema:expectedSchema,received:sanitizeRegistrationValue(received),hint}}registerCommandOverride(command,override){const normalizedCommand=normalizeCommandName(command);if(normalizedCommand.length===0)throw createRegistrationValidationError("registerCommand requires a non-empty command name",this.registerCommandTrace("override",command,'registerCommand("<command>", (context) => unknown)',command,"Provide a non-empty command path as the first argument."));if(typeof override!="function"){const trace=this.registerCommandTrace("override",normalizedCommand,'registerCommand("<command>", (context) => unknown)',override,"Provide a function as the second registerCommand argument.");throw createRegistrationValidationError(`registerCommand requires an override function when command name is provided (command="${normalizedCommand}", registration_index=${trace.registration_index})`,trace)}this.allowRegistration("commands.override","registerCommand","commands",{command:normalizedCommand})&&this.#commandRegistry.overrides.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,command:normalizedCommand,run:override})}resolveCommandDefinitionRunHandler(definition,normalizedCommand){const runHandler=typeof definition.run=="function"?definition.run:void 0,legacyHandler=typeof definition.handler=="function"?definition.handler:void 0;return!runHandler&&legacyHandler&&this.#activationWarnings.push(`extension_command_definition_legacy_handler_alias:${this.#loadedExtension.layer}:${this.#loadedExtension.name}:${normalizedCommand}`),runHandler??legacyHandler}registerCommandDefinition(definition){if(typeof definition!="object"||definition===null)throw createRegistrationValidationError("registerCommand requires a command definition object",this.registerCommandTrace("definition",void 0,"{ name: string; run: (context) => unknown; }",definition,'Use registerCommand({ name: "command path", run: (context) => ... }).'));if(typeof definition.name!="string")throw createRegistrationValidationError("registerCommand requires a command definition name",this.registerCommandTrace("definition",void 0,"{ name: string; run: (context) => unknown; }",definition,"Set command definition.name to a non-empty string command path."));const normalizedCommand=normalizeCommandName(definition.name);if(normalizedCommand.length===0)throw createRegistrationValidationError("registerCommand requires a non-empty command definition name",this.registerCommandTrace("definition",definition.name,"{ name: string; run: (context) => unknown; }",definition,"Ensure command definition.name contains a non-empty command path."));const resolvedHandler=this.resolveCommandDefinitionRunHandler(definition,normalizedCommand);if(typeof resolvedHandler!="function"){const trace=this.registerCommandTrace("definition",normalizedCommand,"{ name: string; run: (context) => unknown; }",resolvedHandler,"Define command definition.run as a function.");throw createRegistrationValidationError(`registerCommand requires a command definition run handler (command="${normalizedCommand}", registration_index=${trace.registration_index})`,trace)}try{assertCommandDefinitionMetadataStrings(definition);const action=resolveCommandDefinitionAction(normalizedCommand,definition.action);if(!this.allowRegistration("commands.handler","registerCommand","commands",{command:normalizedCommand,action}))return;const description=definition.description?.trim(),intent=definition.intent?.trim(),examples=normalizeOptionalStringArrayField("registerCommand definition.examples",definition.examples),failureHints=normalizeOptionalStringArrayField("registerCommand definition.failure_hints",definition.failure_hints),argumentsDefinition=normalizeCommandDefinitionArguments(definition.arguments);definition.flags!==void 0&&(assertExtensionCapability(this.#loadedExtension,"schema","registerCommand flags"),this.allowRegistration("schema.flags","registerCommand flags","schema")&&(validateFlagDefinitions(definition.flags),this.#registrationRegistry.flags.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,target_command:normalizedCommand,flags:normalizeFlagDefinitions("registerCommand definition.flags",definition.flags)})));const registration={layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,source_package:this.#loadedExtension.source_package,command:normalizedCommand,action,examples,failure_hints:failureHints,arguments:argumentsDefinition,tier:definition.tier??"standard",family:definition.family??"extensions"};description&&(registration.description=description),intent&&(registration.intent=intent),this.#registrationRegistry.commands.push(registration)}catch(error){const reason=formatUnknownError(error),trace=this.registerCommandTrace("definition",normalizedCommand,"{ name: string; run: (context) => unknown; action?: string; arguments?: object[]; flags?: object[]; }",definition,reason),validationError=createRegistrationValidationError(`registerCommand definition metadata invalid (command="${normalizedCommand}", registration_index=${trace.registration_index}): ${reason}`,trace);this.#activationWarnings.push(`extension_command_quarantined:${this.#loadedExtension.layer}:${this.#loadedExtension.name}:${normalizedCommand}`),this.#activationFailures.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,entry_path:this.#loadedExtension.entry_path,error:validationError.message,trace});return}this.#commandRegistry.handlers.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,command:normalizedCommand,run:resolvedHandler})}registerCommand(commandOrDefinition,override){if(assertExtensionCapability(this.#loadedExtension,"commands","registerCommand"),typeof commandOrDefinition=="string"){this.registerCommandOverride(commandOrDefinition,override);return}this.registerCommandDefinition(commandOrDefinition)}registerParser(command,override){if(assertExtensionCapability(this.#loadedExtension,"parser","registerParser"),!this.allowRegistration("parser.override","registerParser","parser"))return;const normalizedCommand=normalizeCommandName(assertNonEmptyRegistrationString("registerParser command",command));assertRegistrationFunction("registerParser override",override),this.#parserRegistry.overrides.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,command:normalizedCommand,run:override})}registerPreflight(override){if(assertExtensionCapability(this.#loadedExtension,"preflight","registerPreflight"),!this.allowRegistration("preflight.override","registerPreflight","preflight"))return;const normalized=normalizePreflightOverride(override);this.#preflightRegistry.overrides.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,...normalized})}registerService(service,override,ownership={}){assertExtensionCapability(this.#loadedExtension,"services","registerService");const normalizedService=String(service).trim().toLowerCase();if(!isExtensionServiceName(normalizedService))throw new TypeError(`registerService service must be one of: ${KNOWN_EXTENSION_SERVICE_NAMES.join(", ")}`);this.allowRegistration("services.override","registerService","services",{service:normalizedService})&&(assertRegistrationFunction("registerService override",override),this.#serviceRegistry.overrides.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,service:normalizedService,run:override,...normalizeServiceOverrideOwnership(ownership)?{passThrough:!0}:{}}))}registerRenderer(format,renderer,ownership={}){if(assertExtensionCapability(this.#loadedExtension,"renderers","registerRenderer"),!this.allowRegistration("renderers.override","registerRenderer","renderers"))return;if(typeof renderer!="function")throw new TypeError("registerRenderer requires a renderer function");const normalizedFormat=String(format).trim().toLowerCase();if(!isOutputRendererFormat(normalizedFormat))throw new Error(`registerRenderer format must be toon|json, received: ${String(format)}`);if(ownership.resultDiscriminator!==void 0&&typeof ownership.resultDiscriminator!="function")throw new TypeError("registerRenderer ownership.resultDiscriminator must be a function when provided");const commands=[...new Set((ownership.commands??[]).map(command=>{if(typeof command!="string"||command.trim().length===0)throw new TypeError("registerRenderer ownership.commands must contain non-empty command paths");return normalizeCommandName(command)}))];this.#rendererRegistry.overrides.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,format:normalizedFormat,run:renderer,commands,...ownership.resultDiscriminator?{resultDiscriminator:ownership.resultDiscriminator}:{}})}registerFlags(targetCommand,flags){if(assertExtensionCapability(this.#loadedExtension,"schema","registerFlags"),!this.allowRegistration("schema.flags","registerFlags","schema"))return;const normalizedTargetCommand=normalizeCommandName(assertNonEmptyRegistrationString("registerFlags targetCommand",targetCommand));validateFlagDefinitions(flags);const normalizedFlags=normalizeFlagDefinitions("registerFlags flags",flags);if(normalizedFlags.length===0)throw new TypeError("registerFlags requires at least one flag definition");this.#registrationRegistry.flags.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,target_command:normalizedTargetCommand,flags:normalizedFlags})}registerItemFields(fields){if(assertExtensionCapability(this.#loadedExtension,"schema","registerItemFields"),!this.allowRegistration("schema.itemfields","registerItemFields","schema"))return;validateItemFieldDefinitions(fields);const normalizedFields=normalizeRegistrationRecordList("registerItemFields fields",fields);if(normalizedFields.length===0)throw new TypeError("registerItemFields requires at least one field definition");this.#registrationRegistry.item_fields.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,fields:normalizedFields})}registerItemTypes(types){if(assertExtensionCapability(this.#loadedExtension,"schema","registerItemTypes"),!this.allowRegistration("schema.itemtypes","registerItemTypes","schema"))return;validateItemTypeDefinitions(types);const normalizedTypes=normalizeRegistrationRecordList("registerItemTypes types",types);if(normalizedTypes.length===0)throw new TypeError("registerItemTypes requires at least one type definition");this.#registrationRegistry.item_types.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,types:normalizedTypes})}registerRelationshipKinds(definitions){if(assertExtensionCapability(this.#loadedExtension,"schema","registerRelationshipKinds"),!this.allowRegistration("schema.relationshipkinds","registerRelationshipKinds","schema"))return;if(!Array.isArray(definitions))throw new TypeError("registerRelationshipKinds definitions requires an array of object definitions");if(definitions.length===0)throw new TypeError("registerRelationshipKinds requires at least one definition");const registry=createRelationshipKindRegistry();for(const registration of this.#registrationRegistry.relationship_kinds)for(const definition of registration.definitions)registry.register(definition);const validated=definitions.map(definition=>(registry.register(definition),registry.require(definition.kind)));this.#registrationRegistry.relationship_kinds.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,definitions:validated})}registerMigration(definition){if(assertExtensionCapability(this.#loadedExtension,"schema","registerMigration"),!this.allowRegistration("schema.migrations","registerMigration","schema"))return;validateMigrationDefinition(definition);const runtimeDefinition=normalizeRuntimeRegistrationRecord("registerMigration definition",definition);this.#registrationRegistry.migrations.push(attachRuntimeDefinition({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,definition:normalizeRegistrationRecord("registerMigration definition",definition)},runtimeDefinition))}registerProfile(profile){if(assertExtensionCapability(this.#loadedExtension,"schema","registerProfile"),!this.allowRegistration("schema.profiles","registerProfile","schema"))return;const snapshot=cloneRuntimeRegistrationValue(profile);validateProjectProfileDefinition(snapshot),this.#registrationRegistry.profiles.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,profile:applyProjectProfileDefaults(snapshot)})}registerImportExportCommandFlags(method,commandPath,resolvedOptions){resolvedOptions.flags!==void 0&&(assertExtensionCapability(this.#loadedExtension,"schema",`${method} options.flags`),this.allowRegistration("schema.flags",`${method} options.flags`,"schema")&&(validateFlagDefinitions(resolvedOptions.flags),this.#registrationRegistry.flags.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,target_command:commandPath,flags:normalizeFlagDefinitions(`${method} options.flags`,resolvedOptions.flags)})))}applyImportExportCommandMetadata(method,commandPath,options){if(options!==void 0&&(typeof options!="object"||options===null||Array.isArray(options)))throw new TypeError(`${method} options must be an object when provided`);const defaultDescription=`${method==="registerImporter"?"Import":"Export"} items with the registered extension adapter.`,defaultArguments=[{name:"file",required:!1,description:"Optional input or output file path."}],resolvedOptions={...options,description:options?.description??defaultDescription,arguments:options?.arguments??defaultArguments},output=resolveImportExportArtifactOutput(method,resolvedOptions,options?.description!==void 0);assertOptionalStringField(`${method} options.action`,resolvedOptions.action),assertOptionalStringField(`${method} options.description`,resolvedOptions.description),assertOptionalStringField(`${method} options.intent`,resolvedOptions.intent);const action=resolveCommandDefinitionAction(commandPath,resolvedOptions.action),examples=normalizeOptionalStringArrayField(`${method} options.examples`,resolvedOptions.examples),failureHints=normalizeOptionalStringArrayField(`${method} options.failure_hints`,resolvedOptions.failure_hints),argumentsDefinition=normalizeCommandDefinitionArguments(resolvedOptions.arguments);this.registerImportExportCommandFlags(method,commandPath,resolvedOptions);const registration={layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,source_package:this.#loadedExtension.source_package,command:commandPath,action,examples,failure_hints:failureHints,arguments:argumentsDefinition},description=resolvedOptions.description?.trim();description&&(registration.description=description);const intent=resolvedOptions.intent?.trim();return intent&&(registration.intent=intent),this.#registrationRegistry.commands.push(registration),output}registerImporter(name,importer,options){if(assertExtensionCapability(this.#loadedExtension,"importers","registerImporter"),!this.allowRegistration("importers.importer","registerImporter","importers"))return;const normalizedName=normalizeRegistrationName(assertNonEmptyRegistrationString("registerImporter name",name));assertRegistrationFunction("registerImporter importer",importer);const commandPath=toRegistrationCommandPath(normalizedName,"import");this.applyImportExportCommandMetadata("registerImporter",commandPath,options),this.#registrationRegistry.importers.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,importer:normalizedName}),this.#commandRegistry.handlers.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,command:commandPath,run:async context=>importer(buildImportExportContext(context,normalizedName,"import"))})}registerExporter(name,exporter,options){if(assertExtensionCapability(this.#loadedExtension,"importers","registerExporter"),!this.allowRegistration("importers.exporter","registerExporter","importers"))return;const normalizedName=normalizeRegistrationName(assertNonEmptyRegistrationString("registerExporter name",name));assertRegistrationFunction("registerExporter exporter",exporter);const commandPath=toRegistrationCommandPath(normalizedName,"export"),output=this.applyImportExportCommandMetadata("registerExporter",commandPath,options);this.#registrationRegistry.exporters.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,exporter:normalizedName,...output===void 0?{}:{output}}),this.#commandRegistry.handlers.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,command:commandPath,run:async context=>{const result=await exporter(buildImportExportContext(context,normalizedName,"export"));return output?.receipt==="suppress"&&!isHostOutputSuppressed(result)?suppressHostOutput(result):result}})}registerSearchProvider(provider){if(assertExtensionCapability(this.#loadedExtension,"search","registerSearchProvider"),!this.allowRegistration("search.provider","registerSearchProvider","search"))return;const runtimeDefinition=normalizeRuntimeRegistrationRecord("registerSearchProvider provider",provider);this.#registrationRegistry.search_providers.push(attachRuntimeDefinition({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,definition:normalizeRegistrationRecord("registerSearchProvider provider",provider)},runtimeDefinition))}registerVectorStoreAdapter(adapter){if(assertExtensionCapability(this.#loadedExtension,"search","registerVectorStoreAdapter"),!this.allowRegistration("search.vectorstore","registerVectorStoreAdapter","search"))return;const runtimeDefinition=normalizeRuntimeRegistrationRecord("registerVectorStoreAdapter adapter",adapter);this.#registrationRegistry.vector_store_adapters.push(attachRuntimeDefinition({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,definition:normalizeRegistrationRecord("registerVectorStoreAdapter adapter",adapter)},runtimeDefinition))}registerAssuranceMeasurementProvider(provider){if(assertExtensionCapability(this.#loadedExtension,"services","registerAssuranceMeasurementProvider"),!this.allowRegistration("services.assuranceprovider","registerAssuranceMeasurementProvider","services"))return;if(validateAssuranceMeasurementProviderDefinition(provider),provider.network&&this.#loadedExtension.permissions?.network!==!0)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===!0,definition:normalizeRegistrationRecord("registerAssuranceMeasurementProvider provider",provider)},runtimeDefinition))}registerBeforeCommand(hook){assertExtensionCapability(this.#loadedExtension,"hooks","api.hooks.beforeCommand"),this.allowRegistration("hooks.beforecommand","api.hooks.beforeCommand","hooks")&&(assertHookHandler("beforeCommand",hook),this.#hookRegistry.beforeCommand.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,run:hook}))}registerBeforeMutation(hook){assertExtensionCapability(this.#loadedExtension,"hooks","api.hooks.beforeMutation"),this.allowRegistration("hooks.beforemutation","api.hooks.beforeMutation","hooks")&&(assertHookHandler("beforeMutation",hook),this.#hookRegistry.beforeMutation.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,run:hook}))}registerAfterCommand(hook){assertExtensionCapability(this.#loadedExtension,"hooks","api.hooks.afterCommand"),this.allowRegistration("hooks.aftercommand","api.hooks.afterCommand","hooks")&&(assertHookHandler("afterCommand",hook),this.#hookRegistry.afterCommand.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,run:hook}))}registerOnWrite(hook){assertExtensionCapability(this.#loadedExtension,"hooks","api.hooks.onWrite"),this.allowRegistration("hooks.onwrite","api.hooks.onWrite","hooks")&&(assertHookHandler("onWrite",hook),this.#hookRegistry.onWrite.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,run:hook}))}registerOnRead(hook){assertExtensionCapability(this.#loadedExtension,"hooks","api.hooks.onRead"),this.allowRegistration("hooks.onread","api.hooks.onRead","hooks")&&(assertHookHandler("onRead",hook),this.#hookRegistry.onRead.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,run:hook}))}registerOnIndex(hook){assertExtensionCapability(this.#loadedExtension,"hooks","api.hooks.onIndex"),this.allowRegistration("hooks.onindex","api.hooks.onIndex","hooks")&&(assertHookHandler("onIndex",hook),this.#hookRegistry.onIndex.push({layer:this.#loadedExtension.layer,name:this.#loadedExtension.name,run:hook}))}}function createExtensionApi(extension,hooks,commands,parsers,preflight,services,renderers,registrations,activationWarnings,activationFailures,policy){return new ExtensionApiRegistrar(extension,hooks,commands,parsers,preflight,services,renderers,registrations,activationWarnings,activationFailures,policy)}function getRegistrationCounts(registrations){const commandCount=registrations.commands.length,flagCount=registrations.flags.reduce((total,entry)=>total+entry.flags.length,0),itemFieldCount=registrations.item_fields.reduce((total,entry)=>total+entry.fields.length,0),itemTypeCount=registrations.item_types.reduce((total,entry)=>total+entry.types.length,0),relationshipKindCount=(registrations.relationship_kinds??[]).reduce((total,entry)=>total+entry.definitions.length,0);return{commands:commandCount,flags:flagCount,item_fields:itemFieldCount,item_types:itemTypeCount,...relationshipKindCount>0?{relationship_kinds:relationshipKindCount}:{},migrations:registrations.migrations.length,profiles:registrations.profiles.length,importers:registrations.importers.length,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){const warnings=[],collectByCommand=(entries,codePrefix)=>{const grouped=new Map;for(const entry of entries){const bucket=grouped.get(entry.command)??[];bucket.push(entry),grouped.set(entry.command,bucket)}for(const command of[...grouped.keys()].sort((left,right)=>left.localeCompare(right))){const bucket=grouped.get(command);if(bucket.length<=1)continue;const winner=bucket[bucket.length-1];for(const displaced of bucket.slice(0,-1))warnings.push(`${codePrefix}:${command}:${winner.layer}:${winner.name}:${displaced.layer}:${displaced.name}`)}};collectByCommand(commands.handlers,"extension_command_handler_collision"),collectByCommand(commands.overrides,"extension_command_override_collision");const handlerCommands=new Set(commands.handlers.map(entry=>entry.command)),overlapCommands=[...new Set(commands.overrides.map(entry=>entry.command))].filter(command=>handlerCommands.has(command));overlapCommands.sort((left,right)=>left.localeCompare(right));for(const command of overlapCommands){const handlers=commands.handlers.filter(entry=>entry.command===command),overrides=commands.overrides.filter(entry=>entry.command===command);for(const override of overrides)for(const handler of handlers)warnings.push(`extension_command_override_handler_overlap:${command}:${override.layer}:${override.name}:${handler.layer}:${handler.name}`)}return warnings}function collectRendererCollisionWarnings(renderers){const grouped=new Map;for(const entry of renderers.overrides){const bucket=grouped.get(entry.format)??[];bucket.push(entry),grouped.set(entry.format,bucket)}const warnings=[];for(const format of[...grouped.keys()].sort((left,right)=>left.localeCompare(right))){const bucket=grouped.get(format);if(bucket.length<=1)continue;const winner=bucket[bucket.length-1];for(const displaced of bucket.slice(0,-1))winner.commands?.length&&displaced.commands?.length&&!displaced.commands.some(command=>winner.commands?.includes(command))||warnings.push(`extension_renderer_collision:${format}:${winner.layer}:${winner.name}:${displaced.layer}:${displaced.name}`)}return warnings}function collectParserCollisionWarnings(parsers){const warnings=[],grouped=new Map;for(const entry of parsers.overrides){const bucket=grouped.get(entry.command)??[];bucket.push(entry),grouped.set(entry.command,bucket)}for(const command of[...grouped.keys()].sort((left,right)=>left.localeCompare(right))){const bucket=grouped.get(command);if(bucket.length<=1)continue;const winner=bucket[bucket.length-1];for(const displaced of bucket.slice(0,-1))warnings.push(`extension_parser_override_collision:${command}:${winner.layer}:${winner.name}:${displaced.layer}:${displaced.name}`)}return warnings}const CHAINED_SERVICE_NAMES=new Set(["output_format"]);function collectServiceCollisionWarnings(services){const warnings=[],grouped=new Map;for(const entry of services.overrides){const bucket=grouped.get(entry.service)??[];bucket.push(entry),grouped.set(entry.service,bucket)}for(const service of[...grouped.keys()].sort((left,right)=>left.localeCompare(right))){const bucket=grouped.get(service);if(bucket.length<=1||CHAINED_SERVICE_NAMES.has(service))continue;const winner=bucket[bucket.length-1];for(const displaced of bucket.slice(0,-1))warnings.push(`extension_service_override_collision:${service}:${winner.layer}:${winner.name}:${displaced.layer}:${displaced.name}`)}return warnings}async function activateExtensions(loadResult){const policy=hydrateExtensionPolicy(loadResult.policy??DEFAULT_EXTENSION_POLICY),hooks=createEmptyExtensionHookRegistry(),commands=createEmptyExtensionCommandRegistry(),parsers=createEmptyExtensionParserRegistry(),preflight=createEmptyExtensionPreflightRegistry(),services=createEmptyExtensionServiceRegistry(),renderers=createEmptyExtensionRendererRegistry(),registrations=createEmptyExtensionRegistrationRegistry(),failed=[],warnings=[];for(const extension of loadResult.loaded){const activatable=resolveActivatableExtension(extension.module);if(!activatable)continue;const failedBeforeActivation=failed.length,rollbackPartialActivation=captureExtensionActivationRollback({hooks,commands,parsers,preflight,services,renderers,registrations});try{await activatable.activate(createExtensionApi(extension,hooks,commands,parsers,preflight,services,renderers,registrations,warnings,failed,policy)),failed.length>failedBeforeActivation&&(rollbackPartialActivation(),warnings.push(`extension_activation_rolled_back:${extension.layer}:${extension.name}`))}catch(error){rollbackPartialActivation(),warnings.push(`extension_activate_failed:${extension.layer}:${extension.name}`);const trace=extractRegistrationValidationTrace(error);failed.push({layer:extension.layer,name:extension.name,entry_path:extension.entry_path,error:formatUnknownError(error),trace})}}const collisionWarnings=[...collectCommandCollisionWarnings(commands),...collectParserCollisionWarnings(parsers),...collectPreflightCollisionWarnings(preflight),...collectServiceCollisionWarnings(services),...collectRendererCollisionWarnings(renderers)],mergedWarnings=[...new Set([...warnings,...collisionWarnings])];return{hooks,commands,parsers,preflight,services,renderers,registrations,failed,warnings:mergedWarnings,hook_counts:{before_command:hooks.beforeCommand.length,before_mutation:hooks.beforeMutation.length,after_command:hooks.afterCommand.length,on_write:hooks.onWrite.length,on_read:hooks.onRead.length,on_index:hooks.onIndex.length},command_override_count:commands.overrides.length,command_handler_count:commands.handlers.length,parser_override_count:parsers.overrides.length,preflight_override_count:preflight.overrides.length,service_override_count:services.overrides.length,renderer_override_count:renderers.overrides.length,registration_counts:getRegistrationCounts(registrations)}}const _testOnlyLoader={assertFlagValueTypeAndDefault,assertOptionalStringField,compareComparableVersions,collectCommandCollisionWarnings,collectParserCollisionWarnings,collectRendererCollisionWarnings,collectServiceCollisionWarnings,createExtensionApi,createRegistrationValidationError,evaluatePmMaxVersionCompatibility,evaluatePmMinVersionCompatibility,extractRegistrationValidationTrace,fingerprintPath,getRegistrationCounts,normalizeCommandDefinitionArguments,normalizeExtensionDeactivateTimeout,normalizeOptionalStringArrayField,normalizeRegistrationRecord,normalizeRegistrationRecordList,normalizeRuntimeRegistrationRecord,parseComparableVersion,parseManifest:parseExtensionManifestDocument,readCurrentPmCliVersion,readManagedExtensionSourcePackages:async extensionsRoot=>new Map([...await readManagedExtensionSourcePackages(extensionsRoot)].filter(entry=>typeof entry[1].package_name=="string").map(([key,identity])=>[key,identity.package_name])),resolveExtensionImportHref,resolveCurrentPmCliVersion,resolveCommandDefinitionAction,sanitizeRegistrationValue,validateItemFieldDefinitions,resetCurrentPmCliVersionCacheForTest:()=>{currentPmCliVersionPromise=null}};export{DEFAULT_EXTENSION_PRIORITY,_testOnlyLoader,activateExtensions,createEmptyExtensionCommandRegistry2 as createEmptyExtensionCommandRegistry,createEmptyExtensionHookRegistry2 as createEmptyExtensionHookRegistry,createEmptyExtensionParserRegistry2 as createEmptyExtensionParserRegistry,createEmptyExtensionPreflightRegistry2 as createEmptyExtensionPreflightRegistry,createEmptyExtensionRegistrationRegistry2 as createEmptyExtensionRegistrationRegistry,createEmptyExtensionRendererRegistry2 as createEmptyExtensionRendererRegistry,createEmptyExtensionServiceRegistry2 as createEmptyExtensionServiceRegistry,deactivateExtensions,discoverExtensions,isCanonicalPathWithinDirectory,loadExtensions,nextExtensionReloadToken,parseExtensionManifestDocument2 as parseExtensionManifestDocument,parseLegacyExtensionCapabilityAliasWarning,parseUnknownExtensionCapabilityWarning,resolveExtensionRoots,runAfterCommandHooks,runBeforeCommandHooks,runBeforeMutationHooks,runCommandHandler,runCommandOverride,runOnIndexHooks,runOnReadHooks,runOnWriteHooks,runParserOverride,runPreflightOverride,runRendererOverride,runServiceOverride,runServiceOverrideSync};
 //# sourceMappingURL=loader.js.map

package/dist/core/extensions/manifest-parser.js

@@ -1,2 +1,2 @@
-!(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]="1c944ddd-e05b-5d8c-bdc5-7bc9677fa5d1")}catch(e2){}})();import{asRecordLoose}from"../shared/primitives.js";import{normalizeExtensionContributionInventory}from"./contribution-inventory.js";import{normalizeManifestCapabilities}from"./extension-capability-aliases.js";import{normalizePolicySandboxProfile}from"./extension-policy.js";import{normalizeCommandName}from"./extension-runtime-helpers.js";const DEFAULT_EXTENSION_PRIORITY=100;function parseOptionalManifestString(candidate,field){const value=candidate[field];if(value===void 0||value===null){return void 0}if(typeof value!=="string"||value.trim().length===0){return null}return value.trim()}function parseManifestEngines(value){if(value===void 0||value===null){return void 0}const enginesRecord=asRecordLoose(value);if(!enginesRecord){return null}const engines={};for(const key of Object.keys(enginesRecord).sort((left,right)=>left.localeCompare(right))){if(key.trim().length===0){return null}const engineValue=enginesRecord[key];if(typeof engineValue!=="string"||engineValue.trim().length===0){return null}engines[key.trim()]=engineValue.trim()}return Object.keys(engines).length>0?engines:void 0}function parseRequiredManifestString(candidate,field){const value=candidate[field];if(typeof value!=="string"||value.trim().length===0){return null}return value.trim()}function parseOptionalIntegerValue(value){if(value===void 0||value===null){return void 0}if(typeof value!=="number"||!Number.isInteger(value)){return null}return value}function parseOptionalBooleanValue(value){if(value===void 0||value===null){return void 0}if(typeof value!=="boolean"){return null}return value}function parseManifestPriority(candidate){const value=parseOptionalIntegerValue(candidate.priority);return value===void 0?DEFAULT_EXTENSION_PRIORITY:value}function parseManifestSandboxProfile(candidate){const value=candidate.sandbox_profile;if(value===void 0||value===null){return void 0}if(typeof value!=="string"){return null}const normalizedProfile=normalizePolicySandboxProfile(value);if(normalizedProfile!==value.trim().toLowerCase()){return null}return normalizedProfile}function optionalTrimmedString(value){return typeof value==="string"&&value.trim().length>0?value.trim():void 0}function parseManifestProvenance(value){if(value===void 0||value===null){return void 0}const provenanceRecord=asRecordLoose(value);if(!provenanceRecord){return null}const source=optionalTrimmedString(provenanceRecord.source);const signature=optionalTrimmedString(provenanceRecord.signature);const attestation=optionalTrimmedString(provenanceRecord.attestation);const verified=provenanceRecord.verified===void 0||provenanceRecord.verified===null?void 0:typeof provenanceRecord.verified==="boolean"?provenanceRecord.verified:null;if(verified===null){return null}return{...source?{source}:{},...signature?{signature}:{},...attestation?{attestation}:{},...typeof verified==="boolean"?{verified}:{}}}function parseManifestPermissions(value){if(value===void 0||value===null){return void 0}const permissionsRecord=asRecordLoose(value);if(!permissionsRecord){return null}const fsRead=parseOptionalBooleanValue(permissionsRecord.fs_read);const fsWrite=parseOptionalBooleanValue(permissionsRecord.fs_write);const network=parseOptionalBooleanValue(permissionsRecord.network);const envRead=parseOptionalBooleanValue(permissionsRecord.env_read);const envWrite=parseOptionalBooleanValue(permissionsRecord.env_write);const processSpawn=parseOptionalBooleanValue(permissionsRecord.process_spawn);if([fsRead,fsWrite,network,envRead,envWrite,processSpawn].includes(null)){return null}return{...typeof fsRead==="boolean"?{fs_read:fsRead}:{},...typeof fsWrite==="boolean"?{fs_write:fsWrite}:{},...typeof network==="boolean"?{network}:{},...typeof envRead==="boolean"?{env_read:envRead}:{},...typeof envWrite==="boolean"?{env_write:envWrite}:{},...typeof processSpawn==="boolean"?{process_spawn:processSpawn}:{}}}function parseManifestCapabilities(value){if(value===void 0||value===null){return{capabilities:[],legacy_aliases:[]}}if(!Array.isArray(value)||value.some(entry=>typeof entry!=="string")){return null}const normalizedCapabilities=normalizeManifestCapabilities(value);return{capabilities:normalizedCapabilities.capabilities,legacy_aliases:normalizedCapabilities.legacy_aliases}}function parseManifestActivation(value){if(value===void 0||value===null){return void 0}const activationRecord=asRecordLoose(value);if(!activationRecord){return null}const rawCommands=activationRecord.commands;if(rawCommands===void 0||rawCommands===null){return void 0}if(!Array.isArray(rawCommands)||rawCommands.some(entry=>typeof entry!=="string")){return null}const commands=[...new Set(rawCommands.map(entry=>normalizeCommandName(entry)).filter(entry=>entry.length>0))].sort((left,right)=>left.localeCompare(right));return commands.length>0?{commands}:void 0}function parseManifestMetadata(candidate){const manifestVersion=parseOptionalIntegerValue(candidate.manifest_version);if(manifestVersion===null){return null}const pmMinVersion=parseOptionalManifestString(candidate,"pm_min_version");if(pmMinVersion===null){return null}const pmMaxVersion=parseOptionalManifestString(candidate,"pm_max_version");if(pmMaxVersion===null){return null}const engines=parseManifestEngines(candidate.engines);if(engines===null){return null}const trusted=parseOptionalBooleanValue(candidate.trusted);if(trusted===null){return null}const sandboxProfile=parseManifestSandboxProfile(candidate);if(sandboxProfile===null){return null}const provenance=parseManifestProvenance(candidate.provenance);if(provenance===null){return null}const permissions=parseManifestPermissions(candidate.permissions);if(permissions===null){return null}const capabilities=parseManifestCapabilities(candidate.capabilities);if(capabilities===null){return null}const activation=parseManifestActivation(candidate.activation);if(activation===null){return null}const contributions=normalizeExtensionContributionInventory(candidate.contributions);if(contributions===null){return null}return{manifest_version:manifestVersion,pm_min_version:pmMinVersion,pm_max_version:pmMaxVersion,engines,trusted,sandbox_profile:sandboxProfile,provenance,permissions,capabilities:capabilities.capabilities,legacy_capability_aliases:capabilities.legacy_aliases,activation,contributions}}function parseExtensionManifestDocument(raw){if(typeof raw!=="object"||raw===null){return null}const candidate=raw;const name=parseRequiredManifestString(candidate,"name");if(name===null){return null}const version=parseRequiredManifestString(candidate,"version");if(version===null){return null}const entry=parseRequiredManifestString(candidate,"entry");if(entry===null){return null}const priority=parseManifestPriority(candidate);if(priority===null){return null}const metadata=parseManifestMetadata(candidate);if(metadata===null){return null}return{name,version,entry,priority,manifest_version:metadata.manifest_version,pm_min_version:metadata.pm_min_version,pm_max_version:metadata.pm_max_version,engines:metadata.engines,trusted:metadata.trusted,provenance:metadata.provenance,sandbox_profile:metadata.sandbox_profile,permissions:metadata.permissions,activation:metadata.activation,contributions:metadata.contributions,capabilities:metadata.capabilities,legacy_capability_aliases:metadata.legacy_capability_aliases.length>0?metadata.legacy_capability_aliases:void 0}}export{DEFAULT_EXTENSION_PRIORITY,parseExtensionManifestDocument};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="cd1de600-27e4-522b-842e-1993c12e9f0e")}catch{}})();import{asRecordLoose}from"../shared/primitives.js";import{normalizeExtensionContributionInventory}from"./contribution-inventory.js";import{normalizeManifestCapabilities}from"./extension-capability-aliases.js";import{normalizePolicySandboxProfile}from"./extension-policy.js";import{normalizeCommandName}from"./extension-runtime-helpers.js";const DEFAULT_EXTENSION_PRIORITY=100;function parseOptionalManifestString(candidate,field){const value=candidate[field];if(value!=null)return typeof value!="string"||value.trim().length===0?null:value.trim()}function parseManifestEngines(value){if(value==null)return;const enginesRecord=asRecordLoose(value);if(!enginesRecord)return null;const engines={};for(const key of Object.keys(enginesRecord).sort((left,right)=>left.localeCompare(right))){if(key.trim().length===0)return null;const engineValue=enginesRecord[key];if(typeof engineValue!="string"||engineValue.trim().length===0)return null;engines[key.trim()]=engineValue.trim()}return Object.keys(engines).length>0?engines:void 0}function parseRequiredManifestString(candidate,field){const value=candidate[field];return typeof value!="string"||value.trim().length===0?null:value.trim()}function parseOptionalIntegerValue(value){if(value!=null)return typeof value!="number"||!Number.isInteger(value)?null:value}function parseOptionalBooleanValue(value){if(value!=null)return typeof value!="boolean"?null:value}function parseManifestPriority(candidate){const value=parseOptionalIntegerValue(candidate.priority);return value===void 0?DEFAULT_EXTENSION_PRIORITY:value}function parseManifestSandboxProfile(candidate){const value=candidate.sandbox_profile;if(value==null)return;if(typeof value!="string")return null;const normalizedProfile=normalizePolicySandboxProfile(value);return normalizedProfile!==value.trim().toLowerCase()?null:normalizedProfile}function optionalTrimmedString(value){return typeof value=="string"&&value.trim().length>0?value.trim():void 0}function parseManifestProvenance(value){if(value==null)return;const provenanceRecord=asRecordLoose(value);if(!provenanceRecord)return null;const source=optionalTrimmedString(provenanceRecord.source),signature=optionalTrimmedString(provenanceRecord.signature),attestation=optionalTrimmedString(provenanceRecord.attestation),verified=provenanceRecord.verified===void 0||provenanceRecord.verified===null?void 0:typeof provenanceRecord.verified=="boolean"?provenanceRecord.verified:null;return verified===null?null:{...source?{source}:{},...signature?{signature}:{},...attestation?{attestation}:{},...typeof verified=="boolean"?{verified}:{}}}function parseManifestPermissions(value){if(value==null)return;const permissionsRecord=asRecordLoose(value);if(!permissionsRecord)return null;const fsRead=parseOptionalBooleanValue(permissionsRecord.fs_read),fsWrite=parseOptionalBooleanValue(permissionsRecord.fs_write),network=parseOptionalBooleanValue(permissionsRecord.network),envRead=parseOptionalBooleanValue(permissionsRecord.env_read),envWrite=parseOptionalBooleanValue(permissionsRecord.env_write),processSpawn=parseOptionalBooleanValue(permissionsRecord.process_spawn);return[fsRead,fsWrite,network,envRead,envWrite,processSpawn].includes(null)?null:{...typeof fsRead=="boolean"?{fs_read:fsRead}:{},...typeof fsWrite=="boolean"?{fs_write:fsWrite}:{},...typeof network=="boolean"?{network}:{},...typeof envRead=="boolean"?{env_read:envRead}:{},...typeof envWrite=="boolean"?{env_write:envWrite}:{},...typeof processSpawn=="boolean"?{process_spawn:processSpawn}:{}}}function parseManifestCapabilities(value){if(value==null)return{capabilities:[],legacy_aliases:[]};if(!Array.isArray(value)||value.some(entry=>typeof entry!="string"))return null;const normalizedCapabilities=normalizeManifestCapabilities(value);return{capabilities:normalizedCapabilities.capabilities,legacy_aliases:normalizedCapabilities.legacy_aliases}}function parseManifestActivation(value){if(value==null)return;const activationRecord=asRecordLoose(value);if(!activationRecord)return null;const rawCommands=activationRecord.commands;if(rawCommands==null)return;if(!Array.isArray(rawCommands)||rawCommands.some(entry=>typeof entry!="string"))return null;const commands=[...new Set(rawCommands.map(entry=>normalizeCommandName(entry)).filter(entry=>entry.length>0))].sort((left,right)=>left.localeCompare(right));return commands.length>0?{commands}:void 0}function parseManifestMetadata(candidate){const manifestVersion=parseOptionalIntegerValue(candidate.manifest_version);if(manifestVersion===null)return null;const pmMinVersion=parseOptionalManifestString(candidate,"pm_min_version");if(pmMinVersion===null)return null;const pmMaxVersion=parseOptionalManifestString(candidate,"pm_max_version");if(pmMaxVersion===null)return null;const engines=parseManifestEngines(candidate.engines);if(engines===null)return null;const trusted=parseOptionalBooleanValue(candidate.trusted);if(trusted===null)return null;const sandboxProfile=parseManifestSandboxProfile(candidate);if(sandboxProfile===null)return null;const provenance=parseManifestProvenance(candidate.provenance);if(provenance===null)return null;const permissions=parseManifestPermissions(candidate.permissions);if(permissions===null)return null;const capabilities=parseManifestCapabilities(candidate.capabilities);if(capabilities===null)return null;const activation=parseManifestActivation(candidate.activation);if(activation===null)return null;const contributions=normalizeExtensionContributionInventory(candidate.contributions);return contributions===null?null:{manifest_version:manifestVersion,pm_min_version:pmMinVersion,pm_max_version:pmMaxVersion,engines,trusted,sandbox_profile:sandboxProfile,provenance,permissions,capabilities:capabilities.capabilities,legacy_capability_aliases:capabilities.legacy_aliases,activation,contributions}}function parseExtensionManifestDocument(raw){if(typeof raw!="object"||raw===null)return null;const candidate=raw,name=parseRequiredManifestString(candidate,"name");if(name===null)return null;const version=parseRequiredManifestString(candidate,"version");if(version===null)return null;const entry=parseRequiredManifestString(candidate,"entry");if(entry===null)return null;const priority=parseManifestPriority(candidate);if(priority===null)return null;const metadata=parseManifestMetadata(candidate);return metadata===null?null:{name,version,entry,priority,manifest_version:metadata.manifest_version,pm_min_version:metadata.pm_min_version,pm_max_version:metadata.pm_max_version,engines:metadata.engines,trusted:metadata.trusted,provenance:metadata.provenance,sandbox_profile:metadata.sandbox_profile,permissions:metadata.permissions,activation:metadata.activation,contributions:metadata.contributions,capabilities:metadata.capabilities,legacy_capability_aliases:metadata.legacy_capability_aliases.length>0?metadata.legacy_capability_aliases:void 0}}export{DEFAULT_EXTENSION_PRIORITY,parseExtensionManifestDocument};
 //# sourceMappingURL=manifest-parser.js.map

package/dist/core/extensions/manifest-schema.js

@@ -1,2 +1,2 @@
-!(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]="9961b408-ad70-5556-84dd-5ca1b1497c27")}catch(e2){}})();const KNOWN_EXTENSION_MANIFEST_KEYS=new Set(["name","version","entry","priority","description","author","capabilities","manifest_version","pm_min_version","pm_max_version","engines","trusted","provenance","sandbox_profile","permissions","activation","contributions","legacy_capability_aliases"]);function inspectExtensionManifestSchema(manifest){return{unknownKeys:Object.keys(manifest).filter(key=>!KNOWN_EXTENSION_MANIFEST_KEYS.has(key)).sort((left,right)=>left>right?1:-1),missingVersionBounds:manifest.pm_min_version===void 0&&manifest.pm_max_version===void 0}}function lintExtensionManifestSchema(manifest){const inspection=inspectExtensionManifestSchema(manifest);const findings=inspection.unknownKeys.map(key=>({code:"manifest_unknown_key",path:key,...key==="compatibility"?{suggested_key:"pm_min_version"}:{},message:key==="compatibility"?'Manifest key "compatibility" is ignored; declare the canonical pm_min_version and optional pm_max_version fields instead.':`Manifest key "${key}" is not part of the extension manifest contract and will be ignored.`}));if(inspection.missingVersionBounds){findings.push({code:"no_version_bounds_declared",path:"$",suggested_key:"pm_min_version",message:"No canonical pm version bounds are declared; add pm_min_version so compatibility intent is explicit."})}return{ok:findings.length===0,findings}}function formatExtensionManifestSchemaWarnings(layer,manifest,rawManifest){return lintExtensionManifestSchema(rawManifest).findings.map(finding=>finding.code==="manifest_unknown_key"?`extension_manifest_unknown_key:${layer}:${manifest.name}:key=${finding.path}${finding.suggested_key?`:suggested=${finding.suggested_key}`:""}`:`extension_manifest_no_version_bounds:${layer}:${manifest.name}:suggested=pm_min_version`)}export{KNOWN_EXTENSION_MANIFEST_KEYS,formatExtensionManifestSchemaWarnings,inspectExtensionManifestSchema,lintExtensionManifestSchema};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="67511565-01f8-58a6-ad06-45b5d0ce831b")}catch{}})();const KNOWN_EXTENSION_MANIFEST_KEYS=new Set(["name","version","entry","priority","description","author","capabilities","manifest_version","pm_min_version","pm_max_version","engines","trusted","provenance","sandbox_profile","permissions","activation","contributions","legacy_capability_aliases"]);function inspectExtensionManifestSchema(manifest){return{unknownKeys:Object.keys(manifest).filter(key=>!KNOWN_EXTENSION_MANIFEST_KEYS.has(key)).sort((left,right)=>left>right?1:-1),missingVersionBounds:manifest.pm_min_version===void 0&&manifest.pm_max_version===void 0}}function lintExtensionManifestSchema(manifest){const inspection=inspectExtensionManifestSchema(manifest),findings=inspection.unknownKeys.map(key=>({code:"manifest_unknown_key",path:key,...key==="compatibility"?{suggested_key:"pm_min_version"}:{},message:key==="compatibility"?'Manifest key "compatibility" is ignored; declare the canonical pm_min_version and optional pm_max_version fields instead.':`Manifest key "${key}" is not part of the extension manifest contract and will be ignored.`}));return inspection.missingVersionBounds&&findings.push({code:"no_version_bounds_declared",path:"$",suggested_key:"pm_min_version",message:"No canonical pm version bounds are declared; add pm_min_version so compatibility intent is explicit."}),{ok:findings.length===0,findings}}function formatExtensionManifestSchemaWarnings(layer,manifest,rawManifest){return lintExtensionManifestSchema(rawManifest).findings.map(finding=>finding.code==="manifest_unknown_key"?`extension_manifest_unknown_key:${layer}:${manifest.name}:key=${finding.path}${finding.suggested_key?`:suggested=${finding.suggested_key}`:""}`:`extension_manifest_no_version_bounds:${layer}:${manifest.name}:suggested=pm_min_version`)}export{KNOWN_EXTENSION_MANIFEST_KEYS,formatExtensionManifestSchemaWarnings,inspectExtensionManifestSchema,lintExtensionManifestSchema};
 //# sourceMappingURL=manifest-schema.js.map

package/dist/core/extensions/module-graph-snapshot.js

@@ -1,2 +1,2 @@
-!(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]="6d77d806-1c41-5235-b56b-802089979395")}catch(e2){}})();import{withHostEnvironmentBoundary}from"../fs/host-environment-errors.js";import fs from"node:fs/promises";import path from"node:path";async function snapshotExtensionModuleGraph(snapshotRoot,extension){const sourceDirectory=path.dirname(extension.manifest_path);const relativeEntryPath=path.relative(sourceDirectory,extension.entry_path);if(relativeEntryPath.startsWith("..")||path.isAbsolute(relativeEntryPath)){throw new Error(`Cannot snapshot extension entry outside its package directory: ${extension.entry_path}`)}const snapshotDirectory=path.join(snapshotRoot,`${extension.layer}-${extension.directory.replace(/[^a-zA-Z0-9._-]/gu,"_")}`);await withHostEnvironmentBoundary("extension_module_graph_snapshot",()=>fs.cp(sourceDirectory,snapshotDirectory,{recursive:true,force:true}));return path.join(snapshotDirectory,relativeEntryPath)}export{snapshotExtensionModuleGraph};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="029e0066-2ef5-5204-92ad-4866321710f4")}catch{}})();import{withHostEnvironmentBoundary}from"../fs/host-environment-errors.js";import fs from"node:fs/promises";import path from"node:path";async function snapshotExtensionModuleGraph(snapshotRoot,extension){const sourceDirectory=path.dirname(extension.manifest_path),relativeEntryPath=path.relative(sourceDirectory,extension.entry_path);if(relativeEntryPath.startsWith("..")||path.isAbsolute(relativeEntryPath))throw new Error(`Cannot snapshot extension entry outside its package directory: ${extension.entry_path}`);const snapshotDirectory=path.join(snapshotRoot,`${extension.layer}-${extension.directory.replace(/[^a-zA-Z0-9._-]/gu,"_")}`);return await withHostEnvironmentBoundary("extension_module_graph_snapshot",()=>fs.cp(sourceDirectory,snapshotDirectory,{recursive:!0,force:!0})),path.join(snapshotDirectory,relativeEntryPath)}export{snapshotExtensionModuleGraph};
 //# sourceMappingURL=module-graph-snapshot.js.map

package/dist/core/extensions/preflight-ownership.js

@@ -1,2 +1,2 @@
-!(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]="092f2852-fa07-5f0f-8266-e9e2ca078cb6")}catch(e2){}})();import{normalizeCommandName}from"./extension-runtime-helpers.js";function normalizePreflightOverride(override){const run=typeof override==="function"?override:override.run;if(typeof run!=="function"){throw new TypeError("registerPreflight override requires a function handler")}const commands=[...new Set((typeof override==="function"?[]:override.commands??[]).map(command=>{if(typeof command!=="string"||command.trim().length===0){throw new TypeError("registerPreflight ownership.commands must contain non-empty command paths")}return normalizeCommandName(command)}))];return{run,...commands.length>0?{commands}:{}}}function collectPreflightCollisionWarnings(preflight){const warnings=[];for(let winnerIndex=1;winnerIndex<preflight.overrides.length;winnerIndex+=1){const winner=preflight.overrides[winnerIndex];for(const displaced of preflight.overrides.slice(0,winnerIndex)){if(winner.commands?.length&&displaced.commands?.length&&!displaced.commands.some(command=>winner.commands.includes(command))){continue}warnings.push(`extension_preflight_override_collision:${winner.layer}:${winner.name}:${displaced.layer}:${displaced.name}`)}}return warnings}export{collectPreflightCollisionWarnings,normalizePreflightOverride};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="bf5c3834-b388-507e-a13c-3beb5d096abb")}catch{}})();import{normalizeCommandName}from"./extension-runtime-helpers.js";function normalizePreflightOverride(override){const run=typeof override=="function"?override:override.run;if(typeof run!="function")throw new TypeError("registerPreflight override requires a function handler");const commands=[...new Set((typeof override=="function"?[]:override.commands??[]).map(command=>{if(typeof command!="string"||command.trim().length===0)throw new TypeError("registerPreflight ownership.commands must contain non-empty command paths");return normalizeCommandName(command)}))];return{run,...commands.length>0?{commands}:{}}}function collectPreflightCollisionWarnings(preflight){const warnings=[];for(let winnerIndex=1;winnerIndex<preflight.overrides.length;winnerIndex+=1){const winner=preflight.overrides[winnerIndex];for(const displaced of preflight.overrides.slice(0,winnerIndex))winner.commands?.length&&displaced.commands?.length&&!displaced.commands.some(command=>winner.commands.includes(command))||warnings.push(`extension_preflight_override_collision:${winner.layer}:${winner.name}:${displaced.layer}:${displaced.name}`)}return warnings}export{collectPreflightCollisionWarnings,normalizePreflightOverride};
 //# sourceMappingURL=preflight-ownership.js.map

package/dist/core/extensions/registration-contracts.js

@@ -1,2 +1,2 @@
-!(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]="7640f483-6c14-56f1-bccd-cec9ca88e6ea")}catch(e2){}})();import{describeExtensionLongFlagFailure,findExtensionFlagTokenFailure}from"./flag-definition-validation.js";import{flattenFlagListValue,isFlagDefaultValueCoercible,resolveFlagValueKind}from"./flag-value-types.js";import{KNOWN_ITEM_FIELD_TYPES,normalizeItemFieldType,suggestKnownItemFieldType}from"./item-field-types.js";import{asRegistrationRecord,assertOptionalBooleanField,assertOptionalFlagDefaultField,assertOptionalStringArrayField,assertOptionalStringField}from"./registration-validation.js";import{assertNonEmptyRegistrationString,normalizeRegistrationRecordList}from"./registration-values.js";const FLAG_DEFINITION_KEYS=new Set(["default","description","enabled","list","long","repeatable","required","short","type","value_name","value_type","visible"]);function normalizeFlagDefinitions(name,value){return normalizeRegistrationRecordList(name,value).map(record=>{if(record.repeatable===true){record.list=true}return record})}function normalizeCommandActionName(value){return value.trim().toLowerCase().replace(/[\s_]+/g,"-").replace(/[^a-z0-9-]/g,"-").replace(/-+/g,"-").replace(/^-+|-+$/g,"")}function resolveCommandDefinitionAction(commandPath,action){if(action===void 0){return commandPath.replace(/\s+/g,"-")}if(typeof action!=="string"||action.trim().length===0){throw new TypeError("registerCommand definition.action must be a non-empty string when provided")}const normalized=normalizeCommandActionName(action);if(normalized.length===0){throw new TypeError("registerCommand definition.action must contain alphanumeric characters")}return normalized}function normalizeCommandDefinitionArguments(value){if(value===void 0){return[]}if(!Array.isArray(value)){throw new TypeError("registerCommand definition.arguments must be an array when provided")}const normalized=[];for(const[index,entry]of value.entries()){const record=asRegistrationRecord(`registerCommand definition.arguments[${index}]`,entry);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);if(name.includes(" ")){throw new TypeError(`registerCommand definition.arguments[${index}].name must not contain spaces`)}const definition={name};if(record.required===true){definition.required=true}if(record.variadic===true){definition.variadic=true}if(typeof record.description==="string"){definition.description=record.description.trim()}normalized.push(definition)}const variadicIndexes=normalized.map((argument,index)=>argument.variadic?index:-1).filter(index=>index>=0);if(variadicIndexes.length>1){throw new TypeError("registerCommand definition.arguments supports at most one variadic argument")}if(variadicIndexes.length===1&&variadicIndexes[0]!==normalized.length-1){throw new TypeError("registerCommand definition.arguments variadic argument must be the final argument")}return normalized}function validateFlagDefinitions(flags){if(!Array.isArray(flags)){throw new TypeError("registerFlags flags requires an array of object definitions")}for(const[index,raw]of flags.entries()){const record=asRegistrationRecord(`registerFlags flags[${index}]`,raw);const unknownKeys=Object.keys(record).filter(key=>!FLAG_DEFINITION_KEYS.has(key)).sort((left,right)=>left.localeCompare(right));if(unknownKeys.length>0){throw new TypeError(`registerFlags flags[${index}] contains unknown field(s): ${unknownKeys.join(", ")}`)}const long=record.long;const short=record.short;if(long===void 0&&short===void 0){throw new TypeError(`registerFlags flags[${index}] requires at least one of long or short`)}assertOptionalStringField(`registerFlags flags[${index}].long`,long);assertOptionalStringField(`registerFlags flags[${index}].short`,short);const tokenFinding=findExtensionFlagTokenFailure(long,short);if(tokenFinding!==null){throw new TypeError(`registerFlags flags[${index}] ${describeExtensionLongFlagFailure(tokenFinding.token,tokenFinding.failure)}`)}assertOptionalStringField(`registerFlags flags[${index}].value_name`,record.value_name);assertOptionalStringField(`registerFlags flags[${index}].description`,record.description);assertOptionalBooleanField(`registerFlags flags[${index}].required`,record.required);assertOptionalBooleanField(`registerFlags flags[${index}].enabled`,record.enabled);assertOptionalBooleanField(`registerFlags flags[${index}].visible`,record.visible);assertOptionalBooleanField(`registerFlags flags[${index}].list`,record.list);assertOptionalBooleanField(`registerFlags flags[${index}].repeatable`,record.repeatable);if(record.list!==void 0&&record.repeatable!==void 0&&record.list!==record.repeatable){throw new TypeError(`registerFlags flags[${index}].list and repeatable must match when both are provided`)}assertOptionalFlagDefaultField(`registerFlags flags[${index}].default`,record.default);if(Array.isArray(record.default)&&record.list!==true&&record.repeatable!==true){throw new TypeError(`registerFlags flags[${index}].default cannot be an array unless list is true.`)}assertFlagValueTypeAndDefault(`registerFlags flags[${index}]`,record)}}function assertFlagValueTypeAndDefault(label,record){const declaredType=(typeof record.value_type==="string"?record.value_type:void 0)??(typeof record.type==="string"?record.type:void 0);if(declaredType===void 0){return}const kind=resolveFlagValueKind(declaredType);if(kind===null){throw new TypeError(`${label} value_type "${declaredType}" is not a known flag value type (expected one of: string, number, boolean).`)}if(record.default===void 0){return}const defaults=record.list===true||record.repeatable===true?flattenFlagListValue(record.default):[record.default];for(const[defaultIndex,defaultValue]of defaults.entries()){if(!isFlagDefaultValueCoercible(defaultValue,kind)){const suffix=defaults.length>1?`default[${defaultIndex}]`:"default";throw new TypeError(`${label}.${suffix} (${JSON.stringify(defaultValue)}) is not coercible to ${kind}.`)}}}function validateItemFieldDefinitions(fields){if(!Array.isArray(fields)){throw new TypeError("registerItemFields fields requires an array of object definitions")}for(const[index,raw]of fields.entries()){const record=asRegistrationRecord(`registerItemFields fields[${index}]`,raw);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}"?`:"";throw new TypeError(`registerItemFields fields[${index}].type "${fieldType}" is not a known field type (expected one of: ${KNOWN_ITEM_FIELD_TYPES.join(", ")}).${hint}`)}assertOptionalBooleanField(`registerItemFields fields[${index}].optional`,record.optional)}}function validateItemTypeCommandOptionPolicies(typeIndex,value){if(value===void 0){return}const label=`registerItemTypes types[${typeIndex}].command_option_policies`;if(!Array.isArray(value)){throw new TypeError(`${label} must be an array when provided`)}for(const[policyIndex,rawPolicy]of value.entries()){const at=`${label}[${policyIndex}]`;const policy=asRegistrationRecord(at,rawPolicy);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)}}function validateItemTypeOptions(typeIndex,value){if(value===void 0){return}const label=`registerItemTypes types[${typeIndex}].options`;if(!Array.isArray(value)){throw new TypeError(`${label} must be an array when provided`)}for(const[optionIndex,rawOption]of value.entries()){const at=`${label}[${optionIndex}]`;const option=asRegistrationRecord(at,rawOption);assertNonEmptyRegistrationString(`${at}.key`,option.key);assertOptionalStringArrayField(`${at}.values`,option.values);assertOptionalBooleanField(`${at}.required`,option.required);assertOptionalStringArrayField(`${at}.aliases`,option.aliases)}}function validateItemTypeDefinitions(types){if(!Array.isArray(types)){throw new TypeError("registerItemTypes types requires an array of object definitions")}for(const[typeIndex,raw]of types.entries()){const at=`registerItemTypes types[${typeIndex}]`;const record=asRegistrationRecord(at,raw);assertNonEmptyRegistrationString(`${at}.name`,record.name);assertOptionalStringField(`${at}.folder`,record.folder);assertOptionalStringArrayField(`${at}.aliases`,record.aliases);assertOptionalStringArrayField(`${at}.required_create_fields`,record.required_create_fields);assertOptionalStringArrayField(`${at}.required_create_repeatables`,record.required_create_repeatables);validateItemTypeCommandOptionPolicies(typeIndex,record.command_option_policies);validateItemTypeOptions(typeIndex,record.options)}}function validateMigrationDefinition(definition){const record=asRegistrationRecord("registerMigration definition",definition);if(record.id!==void 0&&typeof record.id!=="string"){throw new TypeError("registerMigration definition.id must be a string when provided")}if(record.description!==void 0&&typeof record.description!=="string"){throw new TypeError("registerMigration definition.description must be a string when provided")}if(record.status!==void 0&&typeof record.status!=="string"){throw new TypeError("registerMigration definition.status must be a string when provided")}assertOptionalBooleanField("registerMigration definition.mandatory",record.mandatory);if(record.run!==void 0&&typeof record.run!=="function"){throw new TypeError("registerMigration definition.run must be a function when provided")}}const PROJECT_PROFILE_DIMENSIONS=["types","statuses","fields","workflows","config","templates","packages"];const PROJECT_PROFILE_ENTRY_VALIDATORS={types:(at,entry)=>{if(entry.name!==void 0&&typeof entry.name!=="string"){throw new TypeError(`${at}.name must be a string when provided`)}},workflows:(at,entry)=>{if(typeof entry.type!=="string"){throw new TypeError(`${at}.type must be a string`)}if(!Array.isArray(entry.allowed_transitions)){throw new TypeError(`${at}.allowed_transitions must be an array`)}for(const[pairIndex,pair]of entry.allowed_transitions.entries()){if(!Array.isArray(pair)){throw new TypeError(`${at}.allowed_transitions[${pairIndex}] must be a [from, to] array`)}}},templates:(at,entry)=>{if(typeof entry.name!=="string"){throw new TypeError(`${at}.name must be a string`)}if(typeof entry.options!=="object"||entry.options===null||Array.isArray(entry.options)){throw new TypeError(`${at}.options must be an object`)}},packages:(at,entry)=>{if(typeof entry.spec!=="string"){throw new TypeError(`${at}.spec must be a string`)}}};function validateProjectProfileDefinition(profile){const record=asRegistrationRecord("registerProfile profile",profile);assertNonEmptyRegistrationString("registerProfile profile.name",record.name);assertNonEmptyRegistrationString("registerProfile profile.title",record.title);if(record.summary!==void 0&&typeof record.summary!=="string"){throw new TypeError("registerProfile profile.summary must be a string when provided")}for(const dimension of PROJECT_PROFILE_DIMENSIONS){const value=record[dimension];if(value===void 0){continue}if(!Array.isArray(value)){throw new TypeError(`registerProfile profile.${dimension} must be an array when provided`)}for(const[index,entry]of value.entries()){if(typeof entry!=="object"||entry===null||Array.isArray(entry)){throw new TypeError(`registerProfile profile.${dimension}[${index}] must be an object`)}PROJECT_PROFILE_ENTRY_VALIDATORS[dimension]?.(`registerProfile profile.${dimension}[${index}]`,entry)}}}function applyProjectProfileDefaults(profile){if(profile.summary===void 0){profile.summary=""}for(const dimension of PROJECT_PROFILE_DIMENSIONS){if(profile[dimension]===void 0){profile[dimension]=[]}}return profile}export{applyProjectProfileDefaults,assertFlagValueTypeAndDefault,normalizeCommandDefinitionArguments,normalizeFlagDefinitions,resolveCommandDefinitionAction,validateFlagDefinitions,validateItemFieldDefinitions,validateItemTypeDefinitions,validateMigrationDefinition,validateProjectProfileDefinition};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="bc1e888a-4274-5d8d-9077-89ca5341172c")}catch{}})();import{describeExtensionLongFlagFailure,findExtensionFlagTokenFailure}from"./flag-definition-validation.js";import{flattenFlagListValue,isFlagDefaultValueCoercible,resolveFlagValueKind}from"./flag-value-types.js";import{KNOWN_ITEM_FIELD_TYPES,normalizeItemFieldType,suggestKnownItemFieldType}from"./item-field-types.js";import{asRegistrationRecord,assertOptionalBooleanField,assertOptionalFlagDefaultField,assertOptionalStringArrayField,assertOptionalStringField}from"./registration-validation.js";import{assertNonEmptyRegistrationString,normalizeRegistrationRecordList}from"./registration-values.js";const FLAG_DEFINITION_KEYS=new Set(["default","description","enabled","list","long","repeatable","required","short","type","value_name","value_type","visible"]);function normalizeFlagDefinitions(name,value){return normalizeRegistrationRecordList(name,value).map(record=>(record.repeatable===!0&&(record.list=!0),record))}function normalizeCommandActionName(value){return value.trim().toLowerCase().replace(/[\s_]+/g,"-").replace(/[^a-z0-9-]/g,"-").replace(/-+/g,"-").replace(/^-+|-+$/g,"")}function resolveCommandDefinitionAction(commandPath,action){if(action===void 0)return commandPath.replace(/\s+/g,"-");if(typeof action!="string"||action.trim().length===0)throw new TypeError("registerCommand definition.action must be a non-empty string when provided");const normalized=normalizeCommandActionName(action);if(normalized.length===0)throw new TypeError("registerCommand definition.action must contain alphanumeric characters");return normalized}function normalizeCommandDefinitionArguments(value){if(value===void 0)return[];if(!Array.isArray(value))throw new TypeError("registerCommand definition.arguments must be an array when provided");const normalized=[];for(const[index,entry]of value.entries()){const record=asRegistrationRecord(`registerCommand definition.arguments[${index}]`,entry),name=assertNonEmptyRegistrationString(`registerCommand definition.arguments[${index}].name`,record.name);if(assertOptionalBooleanField(`registerCommand definition.arguments[${index}].required`,record.required),assertOptionalBooleanField(`registerCommand definition.arguments[${index}].variadic`,record.variadic),assertOptionalStringField(`registerCommand definition.arguments[${index}].description`,record.description),name.includes(" "))throw new TypeError(`registerCommand definition.arguments[${index}].name must not contain spaces`);const definition={name};record.required===!0&&(definition.required=!0),record.variadic===!0&&(definition.variadic=!0),typeof record.description=="string"&&(definition.description=record.description.trim()),normalized.push(definition)}const variadicIndexes=normalized.map((argument,index)=>argument.variadic?index:-1).filter(index=>index>=0);if(variadicIndexes.length>1)throw new TypeError("registerCommand definition.arguments supports at most one variadic argument");if(variadicIndexes.length===1&&variadicIndexes[0]!==normalized.length-1)throw new TypeError("registerCommand definition.arguments variadic argument must be the final argument");return normalized}function validateFlagDefinitions(flags){if(!Array.isArray(flags))throw new TypeError("registerFlags flags requires an array of object definitions");for(const[index,raw]of flags.entries()){const record=asRegistrationRecord(`registerFlags flags[${index}]`,raw),unknownKeys=Object.keys(record).filter(key=>!FLAG_DEFINITION_KEYS.has(key)).sort((left,right)=>left.localeCompare(right));if(unknownKeys.length>0)throw new TypeError(`registerFlags flags[${index}] contains unknown field(s): ${unknownKeys.join(", ")}`);const long=record.long,short=record.short;if(long===void 0&&short===void 0)throw new TypeError(`registerFlags flags[${index}] requires at least one of long or short`);assertOptionalStringField(`registerFlags flags[${index}].long`,long),assertOptionalStringField(`registerFlags flags[${index}].short`,short);const tokenFinding=findExtensionFlagTokenFailure(long,short);if(tokenFinding!==null)throw new TypeError(`registerFlags flags[${index}] ${describeExtensionLongFlagFailure(tokenFinding.token,tokenFinding.failure)}`);if(assertOptionalStringField(`registerFlags flags[${index}].value_name`,record.value_name),assertOptionalStringField(`registerFlags flags[${index}].description`,record.description),assertOptionalBooleanField(`registerFlags flags[${index}].required`,record.required),assertOptionalBooleanField(`registerFlags flags[${index}].enabled`,record.enabled),assertOptionalBooleanField(`registerFlags flags[${index}].visible`,record.visible),assertOptionalBooleanField(`registerFlags flags[${index}].list`,record.list),assertOptionalBooleanField(`registerFlags flags[${index}].repeatable`,record.repeatable),record.list!==void 0&&record.repeatable!==void 0&&record.list!==record.repeatable)throw new TypeError(`registerFlags flags[${index}].list and repeatable must match when both are provided`);if(assertOptionalFlagDefaultField(`registerFlags flags[${index}].default`,record.default),Array.isArray(record.default)&&record.list!==!0&&record.repeatable!==!0)throw new TypeError(`registerFlags flags[${index}].default cannot be an array unless list is true.`);assertFlagValueTypeAndDefault(`registerFlags flags[${index}]`,record)}}function assertFlagValueTypeAndDefault(label,record){const declaredType=(typeof record.value_type=="string"?record.value_type:void 0)??(typeof record.type=="string"?record.type:void 0);if(declaredType===void 0)return;const kind=resolveFlagValueKind(declaredType);if(kind===null)throw new TypeError(`${label} value_type "${declaredType}" is not a known flag value type (expected one of: string, number, boolean).`);if(record.default===void 0)return;const defaults=record.list===!0||record.repeatable===!0?flattenFlagListValue(record.default):[record.default];for(const[defaultIndex,defaultValue]of defaults.entries())if(!isFlagDefaultValueCoercible(defaultValue,kind)){const suffix=defaults.length>1?`default[${defaultIndex}]`:"default";throw new TypeError(`${label}.${suffix} (${JSON.stringify(defaultValue)}) is not coercible to ${kind}.`)}}function validateItemFieldDefinitions(fields){if(!Array.isArray(fields))throw new TypeError("registerItemFields fields requires an array of object definitions");for(const[index,raw]of fields.entries()){const record=asRegistrationRecord(`registerItemFields fields[${index}]`,raw);assertNonEmptyRegistrationString(`registerItemFields fields[${index}].name`,record.name);const fieldType=assertNonEmptyRegistrationString(`registerItemFields fields[${index}].type`,record.type);if(normalizeItemFieldType(fieldType)===null){const suggestion=suggestKnownItemFieldType(fieldType),hint=suggestion?` Did you mean "${suggestion}"?`:"";throw new TypeError(`registerItemFields fields[${index}].type "${fieldType}" is not a known field type (expected one of: ${KNOWN_ITEM_FIELD_TYPES.join(", ")}).${hint}`)}assertOptionalBooleanField(`registerItemFields fields[${index}].optional`,record.optional)}}function validateItemTypeCommandOptionPolicies(typeIndex,value){if(value===void 0)return;const label=`registerItemTypes types[${typeIndex}].command_option_policies`;if(!Array.isArray(value))throw new TypeError(`${label} must be an array when provided`);for(const[policyIndex,rawPolicy]of value.entries()){const at=`${label}[${policyIndex}]`,policy=asRegistrationRecord(at,rawPolicy);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)}}function validateItemTypeOptions(typeIndex,value){if(value===void 0)return;const label=`registerItemTypes types[${typeIndex}].options`;if(!Array.isArray(value))throw new TypeError(`${label} must be an array when provided`);for(const[optionIndex,rawOption]of value.entries()){const at=`${label}[${optionIndex}]`,option=asRegistrationRecord(at,rawOption);assertNonEmptyRegistrationString(`${at}.key`,option.key),assertOptionalStringArrayField(`${at}.values`,option.values),assertOptionalBooleanField(`${at}.required`,option.required),assertOptionalStringArrayField(`${at}.aliases`,option.aliases)}}function validateItemTypeDefinitions(types){if(!Array.isArray(types))throw new TypeError("registerItemTypes types requires an array of object definitions");for(const[typeIndex,raw]of types.entries()){const at=`registerItemTypes types[${typeIndex}]`,record=asRegistrationRecord(at,raw);assertNonEmptyRegistrationString(`${at}.name`,record.name),assertOptionalStringField(`${at}.folder`,record.folder),assertOptionalStringArrayField(`${at}.aliases`,record.aliases),assertOptionalStringArrayField(`${at}.required_create_fields`,record.required_create_fields),assertOptionalStringArrayField(`${at}.required_create_repeatables`,record.required_create_repeatables),validateItemTypeCommandOptionPolicies(typeIndex,record.command_option_policies),validateItemTypeOptions(typeIndex,record.options)}}function validateMigrationDefinition(definition){const record=asRegistrationRecord("registerMigration definition",definition);if(record.id!==void 0&&typeof record.id!="string")throw new TypeError("registerMigration definition.id must be a string when provided");if(record.description!==void 0&&typeof record.description!="string")throw new TypeError("registerMigration definition.description must be a string when provided");if(record.status!==void 0&&typeof record.status!="string")throw new TypeError("registerMigration definition.status must be a string when provided");if(assertOptionalBooleanField("registerMigration definition.mandatory",record.mandatory),record.run!==void 0&&typeof record.run!="function")throw new TypeError("registerMigration definition.run must be a function when provided")}const PROJECT_PROFILE_DIMENSIONS=["types","statuses","fields","workflows","config","templates","packages"],PROJECT_PROFILE_ENTRY_VALIDATORS={types:(at,entry)=>{if(entry.name!==void 0&&typeof entry.name!="string")throw new TypeError(`${at}.name must be a string when provided`)},workflows:(at,entry)=>{if(typeof entry.type!="string")throw new TypeError(`${at}.type must be a string`);if(!Array.isArray(entry.allowed_transitions))throw new TypeError(`${at}.allowed_transitions must be an array`);for(const[pairIndex,pair]of entry.allowed_transitions.entries())if(!Array.isArray(pair))throw new TypeError(`${at}.allowed_transitions[${pairIndex}] must be a [from, to] array`)},templates:(at,entry)=>{if(typeof entry.name!="string")throw new TypeError(`${at}.name must be a string`);if(typeof entry.options!="object"||entry.options===null||Array.isArray(entry.options))throw new TypeError(`${at}.options must be an object`)},packages:(at,entry)=>{if(typeof entry.spec!="string")throw new TypeError(`${at}.spec must be a string`)}};function validateProjectProfileDefinition(profile){const record=asRegistrationRecord("registerProfile profile",profile);if(assertNonEmptyRegistrationString("registerProfile profile.name",record.name),assertNonEmptyRegistrationString("registerProfile profile.title",record.title),record.summary!==void 0&&typeof record.summary!="string")throw new TypeError("registerProfile profile.summary must be a string when provided");for(const dimension of PROJECT_PROFILE_DIMENSIONS){const value=record[dimension];if(value!==void 0){if(!Array.isArray(value))throw new TypeError(`registerProfile profile.${dimension} must be an array when provided`);for(const[index,entry]of value.entries()){if(typeof entry!="object"||entry===null||Array.isArray(entry))throw new TypeError(`registerProfile profile.${dimension}[${index}] must be an object`);PROJECT_PROFILE_ENTRY_VALIDATORS[dimension]?.(`registerProfile profile.${dimension}[${index}]`,entry)}}}}function applyProjectProfileDefaults(profile){profile.summary===void 0&&(profile.summary="");for(const dimension of PROJECT_PROFILE_DIMENSIONS)profile[dimension]===void 0&&(profile[dimension]=[]);return profile}export{applyProjectProfileDefaults,assertFlagValueTypeAndDefault,normalizeCommandDefinitionArguments,normalizeFlagDefinitions,resolveCommandDefinitionAction,validateFlagDefinitions,validateItemFieldDefinitions,validateItemTypeDefinitions,validateMigrationDefinition,validateProjectProfileDefinition};
 //# sourceMappingURL=registration-contracts.js.map

package/dist/core/extensions/registration-validation.js

@@ -1,2 +1,2 @@
-!(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]="aade6230-a71b-5cbc-bc9d-022f20e521bd")}catch(e2){}})();function asRegistrationRecord(name,value){if(typeof value!=="object"||value===null||Array.isArray(value)){throw new TypeError(`${name} requires an object definition`)}return value}function assertOptionalBooleanField(name,value){if(value!==void 0&&typeof value!=="boolean"){throw new TypeError(`${name} must be a boolean when provided`)}}function assertOptionalStringField(name,value){if(value===void 0){return}if(typeof value!=="string"||value.trim().length===0){throw new TypeError(`${name} must be a non-empty string when provided`)}}function assertOptionalFlagDefaultField(name,value){if(value===void 0){return}const isScalar=candidate=>typeof candidate==="string"||typeof candidate==="number"||typeof candidate==="boolean";if(Array.isArray(value)){for(const[index,item]of value.entries()){if(!isScalar(item)){throw new TypeError(`${name}[${index}] must be a string, number, or boolean`)}}return}if(!isScalar(value)){throw new TypeError(`${name} must be a string, number, or boolean, or an array of these when provided`)}}function assertOptionalStringArrayField(name,value){if(value===void 0){return}if(!Array.isArray(value)){throw new TypeError(`${name} must be an array of non-empty strings when provided`)}for(const[index,entry]of value.entries()){if(typeof entry!=="string"||entry.trim().length===0){throw new TypeError(`${name}[${index}] must be a non-empty string`)}}}function normalizeOptionalStringArrayField(name,value){assertOptionalStringArrayField(name,value);if(!Array.isArray(value)){return[]}const normalized=[];const seen=new Set;for(const entry of value){const trimmed=entry.trim();if(trimmed.length===0||seen.has(trimmed)){continue}seen.add(trimmed);normalized.push(trimmed)}return normalized}export{asRegistrationRecord,assertOptionalBooleanField,assertOptionalFlagDefaultField,assertOptionalStringArrayField,assertOptionalStringField,normalizeOptionalStringArrayField};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="17ae377d-20c2-5e45-825a-48a79c6c7601")}catch{}})();function asRegistrationRecord(name,value){if(typeof value!="object"||value===null||Array.isArray(value))throw new TypeError(`${name} requires an object definition`);return value}function assertOptionalBooleanField(name,value){if(value!==void 0&&typeof value!="boolean")throw new TypeError(`${name} must be a boolean when provided`)}function assertOptionalStringField(name,value){if(value!==void 0&&(typeof value!="string"||value.trim().length===0))throw new TypeError(`${name} must be a non-empty string when provided`)}function assertOptionalFlagDefaultField(name,value){if(value===void 0)return;const isScalar=candidate=>typeof candidate=="string"||typeof candidate=="number"||typeof candidate=="boolean";if(Array.isArray(value)){for(const[index,item]of value.entries())if(!isScalar(item))throw new TypeError(`${name}[${index}] must be a string, number, or boolean`);return}if(!isScalar(value))throw new TypeError(`${name} must be a string, number, or boolean, or an array of these when provided`)}function assertOptionalStringArrayField(name,value){if(value!==void 0){if(!Array.isArray(value))throw new TypeError(`${name} must be an array of non-empty strings when provided`);for(const[index,entry]of value.entries())if(typeof entry!="string"||entry.trim().length===0)throw new TypeError(`${name}[${index}] must be a non-empty string`)}}function normalizeOptionalStringArrayField(name,value){if(assertOptionalStringArrayField(name,value),!Array.isArray(value))return[];const normalized=[],seen=new Set;for(const entry of value){const trimmed=entry.trim();trimmed.length===0||seen.has(trimmed)||(seen.add(trimmed),normalized.push(trimmed))}return normalized}export{asRegistrationRecord,assertOptionalBooleanField,assertOptionalFlagDefaultField,assertOptionalStringArrayField,assertOptionalStringField,normalizeOptionalStringArrayField};
 //# sourceMappingURL=registration-validation.js.map

package/dist/core/extensions/registration-values.js

@@ -1,2 +1,2 @@
-!(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]="483b4197-5498-568a-bcc4-abd6999a07cc")}catch(e2){}})();import{KNOWN_EXTENSION_SERVICE_NAMES}from"./extension-types.js";import{asRegistrationRecord,assertOptionalBooleanField,assertOptionalStringField}from"./registration-validation.js";import{normalizeCommandName}from"./extension-runtime-helpers.js";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`)}}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){return error instanceof Error?error[EXTENSION_REGISTRATION_TRACE_SYMBOL]:void 0}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"||typeof value==="symbol"){return value.toString()}if(typeof value==="object"){const record=value;const normalized={};for(const key of Object.keys(record).sort((left,right)=>left.localeCompare(right))){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}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))}function assertNonEmptyRegistrationString(name,value){if(typeof value!=="string"||value.trim().length===0){throw new TypeError(`${name} requires a non-empty string`)}return value.trim()}function assertRegistrationFunction(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 attachRuntimeDefinition(entry,runtimeDefinition){Object.defineProperty(entry,"runtime_definition",{value:runtimeDefinition,enumerable:false,writable:false,configurable:false});return entry}const ASSURANCE_PROVIDER_COST_CLASSES=new Set(["low","medium","high"]);const ASSURANCE_PROVIDER_VALUE_TYPES=new Set(["number","string_set"]);const ASSURANCE_PROVIDER_PARAMETER_TYPES=new Set(["string","number","boolean"]);function nonEmptyString(label,value){if(typeof value!=="string"||value.trim().length===0){throw new TypeError(`${label} requires a non-empty string`)}return value.trim()}function validateAssuranceProviderKey(providerId,key,definition){const label=`registerAssuranceMeasurementProvider provider.keys.${key}`;const record=asRegistrationRecord(label,definition);if(!ASSURANCE_PROVIDER_VALUE_TYPES.has(String(record.value_type))){throw new TypeError(`${label}.value_type must be number or string_set`)}assertOptionalStringField(`${label}.description`,record.description);if(record.parameters===void 0)return;const parameters=asRegistrationRecord(`${label}.parameters`,record.parameters);for(const[parameter,rawDefinition]of Object.entries(parameters)){const parameterLabel=`${label}.parameters.${parameter}`;nonEmptyString(`${parameterLabel}.name`,parameter);const parameterDefinition=asRegistrationRecord(parameterLabel,rawDefinition);if(!ASSURANCE_PROVIDER_PARAMETER_TYPES.has(String(parameterDefinition.type))){throw new TypeError(`${parameterLabel}.type must be string, number, or boolean`)}assertOptionalBooleanField(`${parameterLabel}.required`,parameterDefinition.required);assertOptionalStringField(`${parameterLabel}.description`,parameterDefinition.description)}if(Object.keys(parameters).length>50){throw new TypeError(`assurance provider ${providerId} key ${key} exceeds 50 parameters`)}}function validateAssuranceMeasurementProviderDefinition(provider){const record=asRegistrationRecord("registerAssuranceMeasurementProvider provider",provider);const id=nonEmptyString("registerAssuranceMeasurementProvider provider.id",record.id);if(!/^[a-z0-9][a-z0-9-]*$/u.test(id)){throw new TypeError("registerAssuranceMeasurementProvider provider.id must be a stable lowercase id")}if(!ASSURANCE_PROVIDER_COST_CLASSES.has(String(record.cost_class))){throw new TypeError("registerAssuranceMeasurementProvider provider.cost_class must be low, medium, or high")}if(typeof record.network!=="boolean"){throw new TypeError("registerAssuranceMeasurementProvider provider.network must be boolean")}const keys=asRegistrationRecord("registerAssuranceMeasurementProvider provider.keys",record.keys);if(Object.keys(keys).length===0){throw new TypeError("registerAssuranceMeasurementProvider provider.keys requires at least one key")}for(const[key,definition]of Object.entries(keys)){if(!/^[a-z0-9][a-z0-9-]*$/u.test(key)){throw new TypeError(`registerAssuranceMeasurementProvider provider key ${key} must be a stable lowercase id`)}validateAssuranceProviderKey(id,key,definition)}if(record.timeout_ms!==void 0&&(typeof record.timeout_ms!=="number"||!Number.isInteger(record.timeout_ms)||record.timeout_ms<1||record.timeout_ms>3e5)){throw new TypeError("registerAssuranceMeasurementProvider provider.timeout_ms must be an integer from 1 through 300000")}if(typeof record.resolve!=="function"){throw new TypeError("registerAssuranceMeasurementProvider provider.resolve requires a function handler")}}export{assertHookHandler,assertNonEmptyRegistrationString,assertRegistrationFunction,attachRuntimeDefinition,cloneRuntimeRegistrationValue,createRegistrationValidationError,extractRegistrationValidationTrace,isExtensionServiceName,isOutputRendererFormat,normalizeRegistrationName,normalizeRegistrationRecord,normalizeRegistrationRecordList,normalizeRuntimeRegistrationRecord,sanitizeRegistrationValue,toRegistrationCommandPath,validateAssuranceMeasurementProviderDefinition};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="355fe619-e6f3-51d9-b88c-0b57267c25be")}catch{}})();import{KNOWN_EXTENSION_SERVICE_NAMES}from"./extension-types.js";import{asRegistrationRecord,assertOptionalBooleanField,assertOptionalStringField}from"./registration-validation.js";import{normalizeCommandName}from"./extension-runtime-helpers.js";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`)}const EXTENSION_REGISTRATION_TRACE_SYMBOL=Symbol("extension_registration_trace");function createRegistrationValidationError(message,trace){const error=new TypeError(message);return Object.defineProperty(error,EXTENSION_REGISTRATION_TRACE_SYMBOL,{value:trace,enumerable:!1,configurable:!1,writable:!1}),error}function extractRegistrationValidationTrace(error){return error instanceof Error?error[EXTENSION_REGISTRATION_TRACE_SYMBOL]:void 0}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"||typeof value=="symbol")return value.toString();if(typeof value=="object"){const record=value,normalized={};for(const key of Object.keys(record).sort((left,right)=>left.localeCompare(right)))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,cloned={};for(const key of Object.keys(record).sort((left,right)=>left.localeCompare(right)))cloned[key]=cloneRuntimeRegistrationValue(record[key]);return cloned}return value}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))}function assertNonEmptyRegistrationString(name,value){if(typeof value!="string"||value.trim().length===0)throw new TypeError(`${name} requires a non-empty string`);return value.trim()}function assertRegistrationFunction(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 attachRuntimeDefinition(entry,runtimeDefinition){return Object.defineProperty(entry,"runtime_definition",{value:runtimeDefinition,enumerable:!1,writable:!1,configurable:!1}),entry}const ASSURANCE_PROVIDER_COST_CLASSES=new Set(["low","medium","high"]),ASSURANCE_PROVIDER_VALUE_TYPES=new Set(["number","string_set"]),ASSURANCE_PROVIDER_PARAMETER_TYPES=new Set(["string","number","boolean"]);function nonEmptyString(label,value){if(typeof value!="string"||value.trim().length===0)throw new TypeError(`${label} requires a non-empty string`);return value.trim()}function validateAssuranceProviderKey(providerId,key,definition){const label=`registerAssuranceMeasurementProvider provider.keys.${key}`,record=asRegistrationRecord(label,definition);if(!ASSURANCE_PROVIDER_VALUE_TYPES.has(String(record.value_type)))throw new TypeError(`${label}.value_type must be number or string_set`);if(assertOptionalStringField(`${label}.description`,record.description),record.parameters===void 0)return;const parameters=asRegistrationRecord(`${label}.parameters`,record.parameters);for(const[parameter,rawDefinition]of Object.entries(parameters)){const parameterLabel=`${label}.parameters.${parameter}`;nonEmptyString(`${parameterLabel}.name`,parameter);const parameterDefinition=asRegistrationRecord(parameterLabel,rawDefinition);if(!ASSURANCE_PROVIDER_PARAMETER_TYPES.has(String(parameterDefinition.type)))throw new TypeError(`${parameterLabel}.type must be string, number, or boolean`);assertOptionalBooleanField(`${parameterLabel}.required`,parameterDefinition.required),assertOptionalStringField(`${parameterLabel}.description`,parameterDefinition.description)}if(Object.keys(parameters).length>50)throw new TypeError(`assurance provider ${providerId} key ${key} exceeds 50 parameters`)}function validateAssuranceMeasurementProviderDefinition(provider){const record=asRegistrationRecord("registerAssuranceMeasurementProvider provider",provider),id=nonEmptyString("registerAssuranceMeasurementProvider provider.id",record.id);if(!/^[a-z0-9][a-z0-9-]*$/u.test(id))throw new TypeError("registerAssuranceMeasurementProvider provider.id must be a stable lowercase id");if(!ASSURANCE_PROVIDER_COST_CLASSES.has(String(record.cost_class)))throw new TypeError("registerAssuranceMeasurementProvider provider.cost_class must be low, medium, or high");if(typeof record.network!="boolean")throw new TypeError("registerAssuranceMeasurementProvider provider.network must be boolean");const keys=asRegistrationRecord("registerAssuranceMeasurementProvider provider.keys",record.keys);if(Object.keys(keys).length===0)throw new TypeError("registerAssuranceMeasurementProvider provider.keys requires at least one key");for(const[key,definition]of Object.entries(keys)){if(!/^[a-z0-9][a-z0-9-]*$/u.test(key))throw new TypeError(`registerAssuranceMeasurementProvider provider key ${key} must be a stable lowercase id`);validateAssuranceProviderKey(id,key,definition)}if(record.timeout_ms!==void 0&&(typeof record.timeout_ms!="number"||!Number.isInteger(record.timeout_ms)||record.timeout_ms<1||record.timeout_ms>3e5))throw new TypeError("registerAssuranceMeasurementProvider provider.timeout_ms must be an integer from 1 through 300000");if(typeof record.resolve!="function")throw new TypeError("registerAssuranceMeasurementProvider provider.resolve requires a function handler")}export{assertHookHandler,assertNonEmptyRegistrationString,assertRegistrationFunction,attachRuntimeDefinition,cloneRuntimeRegistrationValue,createRegistrationValidationError,extractRegistrationValidationTrace,isExtensionServiceName,isOutputRendererFormat,normalizeRegistrationName,normalizeRegistrationRecord,normalizeRegistrationRecordList,normalizeRuntimeRegistrationRecord,sanitizeRegistrationValue,toRegistrationCommandPath,validateAssuranceMeasurementProviderDefinition};
 //# sourceMappingURL=registration-values.js.map

package/dist/core/extensions/reserved-host-flags.js

@@ -1,2 +1,2 @@
-!(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]="09098e5c-d021-53ae-96b5-c56394c304da")}catch(e2){}})();const RESERVED_EXTENSION_HOST_FLAGS=Object.freeze([{flag:"--json"},{flag:"--lean"},{flag:"--token-accounting"},{flag:"--output-include",value_name:"fields"},{flag:"--output-limit",value_name:"count"},{flag:"--output-budget",value_name:"tokens"},{flag:"--output-format",value_name:"toon|json"},{flag:"--output-session",value_name:"state"},{flag:"--output-cursor",value_name:"cursor"},{flag:"--output-row-contract"},{flag:"--quiet"},{flag:"--no-changed-fields"},{flag:"--full-changed-fields"},{flag:"--id-only"},{flag:"--pm-path",aliases:["--path"]},{flag:"--no-extensions"},{flag:"--no-pager"},{flag:"--profile"},{flag:"--help"},{flag:"--author",value_name:"id"}]);const RESERVED_EXTENSION_HOST_FLAG_NAMES=new Set(RESERVED_EXTENSION_HOST_FLAGS.flatMap(definition=>[definition.flag,...definition.aliases??[]]));export{RESERVED_EXTENSION_HOST_FLAGS,RESERVED_EXTENSION_HOST_FLAG_NAMES};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="c24357cc-5dad-5cd7-aa89-cddd2945aab7")}catch{}})();const RESERVED_EXTENSION_HOST_FLAGS=Object.freeze([{flag:"--json"},{flag:"--lean"},{flag:"--token-accounting"},{flag:"--output-include",value_name:"fields"},{flag:"--output-limit",value_name:"count"},{flag:"--output-budget",value_name:"tokens"},{flag:"--output-format",value_name:"toon|json"},{flag:"--output-session",value_name:"state"},{flag:"--output-cursor",value_name:"cursor"},{flag:"--output-row-contract"},{flag:"--quiet"},{flag:"--no-changed-fields"},{flag:"--full-changed-fields"},{flag:"--id-only"},{flag:"--pm-path",aliases:["--path"]},{flag:"--no-extensions"},{flag:"--no-pager"},{flag:"--profile"},{flag:"--help"},{flag:"--author",value_name:"id"}]),RESERVED_EXTENSION_HOST_FLAG_NAMES=new Set(RESERVED_EXTENSION_HOST_FLAGS.flatMap(definition=>[definition.flag,...definition.aliases??[]]));export{RESERVED_EXTENSION_HOST_FLAGS,RESERVED_EXTENSION_HOST_FLAG_NAMES};
 //# sourceMappingURL=reserved-host-flags.js.map

package/dist/core/extensions/runtime-registrations.js

@@ -1,2 +1,2 @@
-!(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]="fdacd8ac-787a-5639-84d5-a32b6ce79d41")}catch(e2){}})();function normalizeRegistrationName(value){if(typeof value!=="string"){return null}const normalized=value.trim().toLowerCase();return normalized.length>0?normalized:null}function resolveRegisteredAssuranceMeasurementProvider(registrations,providerId){const normalizedId=normalizeRegistrationName(providerId);if(!registrations||!normalizedId)return null;return[...registrations.assurance_providers??[]].reverse().find(registration=>normalizeRegistrationName(registration.definition.id)===normalizedId)??null}function collectRegisteredItemFields(registrations){if(!registrations){return[]}const fields=[];for(const registration of registrations.item_fields){for(const field of registration.fields){fields.push(field)}}return fields}function resolveRegisteredSearchProvider(registrations,configuredProvider){const providerName=normalizeRegistrationName(configuredProvider);if(!registrations||!providerName){return null}const matched=[...registrations.search_providers].reverse().find(registration=>{const definitionName=normalizeRegistrationName(registration.runtime_definition?.name)??normalizeRegistrationName(registration.definition?.name);return definitionName===providerName});return matched??null}function resolveRegisteredVectorStoreAdapter(registrations,configuredAdapter){const adapterName=normalizeRegistrationName(configuredAdapter);if(!registrations||!adapterName){return null}const matched=[...registrations.vector_store_adapters].reverse().find(registration=>{const definitionName=normalizeRegistrationName(registration.runtime_definition?.name)??normalizeRegistrationName(registration.definition?.name);return definitionName===adapterName});return matched??null}function getMigrationRuntimeDefinition(migration){return migration.runtime_definition??migration.definition}export{collectRegisteredItemFields,getMigrationRuntimeDefinition,resolveRegisteredAssuranceMeasurementProvider,resolveRegisteredSearchProvider,resolveRegisteredVectorStoreAdapter};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="cb883ffc-c431-5bf9-a973-931a8a0a940c")}catch{}})();function normalizeRegistrationName(value){if(typeof value!="string")return null;const normalized=value.trim().toLowerCase();return normalized.length>0?normalized:null}function resolveRegisteredAssuranceMeasurementProvider(registrations,providerId){const normalizedId=normalizeRegistrationName(providerId);return!registrations||!normalizedId?null:[...registrations.assurance_providers??[]].reverse().find(registration=>normalizeRegistrationName(registration.definition.id)===normalizedId)??null}function collectRegisteredItemFields(registrations){if(!registrations)return[];const fields=[];for(const registration of registrations.item_fields)for(const field of registration.fields)fields.push(field);return fields}function resolveRegisteredSearchProvider(registrations,configuredProvider){const providerName=normalizeRegistrationName(configuredProvider);return!registrations||!providerName?null:[...registrations.search_providers].reverse().find(registration=>(normalizeRegistrationName(registration.runtime_definition?.name)??normalizeRegistrationName(registration.definition?.name))===providerName)??null}function resolveRegisteredVectorStoreAdapter(registrations,configuredAdapter){const adapterName=normalizeRegistrationName(configuredAdapter);return!registrations||!adapterName?null:[...registrations.vector_store_adapters].reverse().find(registration=>(normalizeRegistrationName(registration.runtime_definition?.name)??normalizeRegistrationName(registration.definition?.name))===adapterName)??null}function getMigrationRuntimeDefinition(migration){return migration.runtime_definition??migration.definition}export{collectRegisteredItemFields,getMigrationRuntimeDefinition,resolveRegisteredAssuranceMeasurementProvider,resolveRegisteredSearchProvider,resolveRegisteredVectorStoreAdapter};
 //# sourceMappingURL=runtime-registrations.js.map

package/dist/core/extensions/service-ownership.js

@@ -1,2 +1,2 @@
-!(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]="09c95125-68bd-512b-bb09-c9ef0b2f676e")}catch(e2){}})();function normalizeServiceOverrideOwnership(ownership){if(ownership===null||typeof ownership!=="object"||Array.isArray(ownership)){throw new TypeError("registerService ownership must be an object")}if(Reflect.ownKeys(ownership).some(key=>key!=="passThrough")){throw new TypeError("registerService ownership supports only passThrough")}if(ownership.passThrough!==void 0&&typeof ownership.passThrough!=="boolean"){throw new TypeError("registerService ownership.passThrough must be a boolean when provided")}return ownership.passThrough===true}export{normalizeServiceOverrideOwnership};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="45ff820c-32af-5bdb-a570-3059684129ce")}catch{}})();function normalizeServiceOverrideOwnership(ownership){if(ownership===null||typeof ownership!="object"||Array.isArray(ownership))throw new TypeError("registerService ownership must be an object");if(Reflect.ownKeys(ownership).some(key=>key!=="passThrough"))throw new TypeError("registerService ownership supports only passThrough");if(ownership.passThrough!==void 0&&typeof ownership.passThrough!="boolean")throw new TypeError("registerService ownership.passThrough must be a boolean when provided");return ownership.passThrough===!0}export{normalizeServiceOverrideOwnership};
 //# sourceMappingURL=service-ownership.js.map

package/dist/core/extensions/version-compat.js

@@ -1,2 +1,2 @@
-!(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]="d2feae50-9a1e-54fa-98a3-df529be63069")}catch(e2){}})();function formatVersionBoundValue(value){return typeof value==="string"?value:String(value)}function parseComparableVersion(value){const normalized=value.trim().replace(/^>=\s*/,"").replace(/^v/i,"");const release=normalized.split(/[+-]/,1)[0];if(!/^\d+(?:[.-]\d+)*$/.test(release)){return null}return release.split(/[.-]/).map(part=>Number(part))}function compareComparableVersions(currentVersion,otherVersion){const currentParts=parseComparableVersion(currentVersion);const otherParts=parseComparableVersion(otherVersion);if(!currentParts||!otherParts){return null}const width=Math.max(currentParts.length,otherParts.length);for(let index=0;index<width;index+=1){const current=currentParts[index]??0;const other=otherParts[index]??0;if(current>other){return 1}if(current<other){return-1}}return 0}function evaluatePmMinVersionBound(required,currentVersion){if(required===void 0||required===null){return{kind:"pm_min_version",status:"absent",allowed:true,required:"",current:currentVersion}}const declared=formatVersionBoundValue(required);if(typeof required!=="string"||declared.trim().length===0){return{kind:"pm_min_version",status:"invalid",allowed:false,required:declared,current:currentVersion}}if(!parseComparableVersion(declared)){return{kind:"pm_min_version",status:"invalid",allowed:false,required:declared,current:currentVersion}}if(currentVersion===null){return{kind:"pm_min_version",status:"unchecked",allowed:true,required:declared,current:null}}const comparison=compareComparableVersions(currentVersion,declared);if(comparison===null){return{kind:"pm_min_version",status:"unchecked",allowed:true,required:declared,current:currentVersion}}if(comparison<0){return{kind:"pm_min_version",status:"unmet",allowed:false,required:declared,current:currentVersion}}return{kind:"pm_min_version",status:"ok",allowed:true,required:declared,current:currentVersion}}function evaluatePmMaxVersionBound(required,currentVersion,exceededMode){if(required===void 0||required===null){return{kind:"pm_max_version",status:"absent",allowed:true,required:"",current:currentVersion}}const declared=formatVersionBoundValue(required);if(typeof required!=="string"||declared.trim().length===0){return{kind:"pm_max_version",status:"invalid",allowed:false,required:declared,current:currentVersion}}if(/^[<>=~^]/.test(declared.trim())||!parseComparableVersion(declared)){return{kind:"pm_max_version",status:"invalid",allowed:false,required:declared,current:currentVersion}}if(currentVersion===null){return{kind:"pm_max_version",status:"unchecked",allowed:true,required:declared,current:null}}const comparison=compareComparableVersions(currentVersion,declared);if(comparison===null){return{kind:"pm_max_version",status:"unchecked",allowed:true,required:declared,current:currentVersion}}if(comparison>0){if(exceededMode==="warn"){return{kind:"pm_max_version",status:"exceeded_warn",allowed:true,required:declared,current:currentVersion}}return{kind:"pm_max_version",status:"exceeded",allowed:false,required:declared,current:currentVersion}}return{kind:"pm_max_version",status:"ok",allowed:true,required:declared,current:currentVersion}}export{compareComparableVersions,evaluatePmMaxVersionBound,evaluatePmMinVersionBound,parseComparableVersion};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b5de5028-f981-599b-8d11-0fc7b07beda4")}catch{}})();function formatVersionBoundValue(value){return typeof value=="string"?value:String(value)}function parseComparableVersion(value){const release=value.trim().replace(/^>=\s*/,"").replace(/^v/i,"").split(/[+-]/,1)[0];return/^\d+(?:[.-]\d+)*$/.test(release)?release.split(/[.-]/).map(part=>Number(part)):null}function compareComparableVersions(currentVersion,otherVersion){const currentParts=parseComparableVersion(currentVersion),otherParts=parseComparableVersion(otherVersion);if(!currentParts||!otherParts)return null;const width=Math.max(currentParts.length,otherParts.length);for(let index=0;index<width;index+=1){const current=currentParts[index]??0,other=otherParts[index]??0;if(current>other)return 1;if(current<other)return-1}return 0}function evaluatePmMinVersionBound(required,currentVersion){if(required==null)return{kind:"pm_min_version",status:"absent",allowed:!0,required:"",current:currentVersion};const declared=formatVersionBoundValue(required);if(typeof required!="string"||declared.trim().length===0)return{kind:"pm_min_version",status:"invalid",allowed:!1,required:declared,current:currentVersion};if(!parseComparableVersion(declared))return{kind:"pm_min_version",status:"invalid",allowed:!1,required:declared,current:currentVersion};if(currentVersion===null)return{kind:"pm_min_version",status:"unchecked",allowed:!0,required:declared,current:null};const comparison=compareComparableVersions(currentVersion,declared);return comparison===null?{kind:"pm_min_version",status:"unchecked",allowed:!0,required:declared,current:currentVersion}:comparison<0?{kind:"pm_min_version",status:"unmet",allowed:!1,required:declared,current:currentVersion}:{kind:"pm_min_version",status:"ok",allowed:!0,required:declared,current:currentVersion}}function evaluatePmMaxVersionBound(required,currentVersion,exceededMode){if(required==null)return{kind:"pm_max_version",status:"absent",allowed:!0,required:"",current:currentVersion};const declared=formatVersionBoundValue(required);if(typeof required!="string"||declared.trim().length===0)return{kind:"pm_max_version",status:"invalid",allowed:!1,required:declared,current:currentVersion};if(/^[<>=~^]/.test(declared.trim())||!parseComparableVersion(declared))return{kind:"pm_max_version",status:"invalid",allowed:!1,required:declared,current:currentVersion};if(currentVersion===null)return{kind:"pm_max_version",status:"unchecked",allowed:!0,required:declared,current:null};const comparison=compareComparableVersions(currentVersion,declared);return comparison===null?{kind:"pm_max_version",status:"unchecked",allowed:!0,required:declared,current:currentVersion}:comparison>0?exceededMode==="warn"?{kind:"pm_max_version",status:"exceeded_warn",allowed:!0,required:declared,current:currentVersion}:{kind:"pm_max_version",status:"exceeded",allowed:!1,required:declared,current:currentVersion}:{kind:"pm_max_version",status:"ok",allowed:!0,required:declared,current:currentVersion}}export{compareComparableVersions,evaluatePmMaxVersionBound,evaluatePmMinVersionBound,parseComparableVersion};
 //# sourceMappingURL=version-compat.js.map

package/dist/core/fs/atomic-create.js

@@ -1,2 +1,2 @@
-!(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]="fcbdb4d9-ea0e-5944-98c3-4d1944d2641d")}catch(e2){}})();import{link,mkdir,mkdtemp,rm,writeFile}from"node:fs/promises";import path from"node:path";async function createFileAtomic(targetPath,contents){const parent=path.dirname(targetPath);await mkdir(parent,{recursive:true});const staging=await mkdtemp(path.join(parent,".pm-seed-"));const stagedFile=path.join(staging,"value");try{await writeFile(stagedFile,contents,"utf8");try{await link(stagedFile,targetPath);return true}catch(error){if(error.code==="EEXIST"){return false}throw error}}finally{await rm(staging,{recursive:true,force:true})}}export{createFileAtomic};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="71c2fed9-81e1-5723-8e34-e6327c07a130")}catch{}})();import{link,mkdir,mkdtemp,rm,writeFile}from"node:fs/promises";import path from"node:path";async function createFileAtomic(targetPath,contents){const parent=path.dirname(targetPath);await mkdir(parent,{recursive:!0});const staging=await mkdtemp(path.join(parent,".pm-seed-")),stagedFile=path.join(staging,"value");try{await writeFile(stagedFile,contents,"utf8");try{return await link(stagedFile,targetPath),!0}catch(error){if(error.code==="EEXIST")return!1;throw error}}finally{await rm(staging,{recursive:!0,force:!0})}}export{createFileAtomic};
 //# sourceMappingURL=atomic-create.js.map