@unbrained/pm-cli 2026.6.9 → 2026.6.10

package/dist/core/store/settings.js

@@ -1,13 +1,14 @@
 
-!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]="40eb6325-776d-5b33-887f-abbdee742b52")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="759b1285-3075-5bd2-a0d7-9eab54fc1093")}catch(e){}}();
 import { validateSettings } from "./settings-validator.js";
 import { runActiveOnReadHooks, runActiveOnWriteHooks } from "../extensions/index.js";
 import { GOVERNANCE_PRESET_DEFAULTS, SETTINGS_DEFAULTS } from "../shared/constants.js";
 import { readFileIfExists, writeFileAtomic } from "../fs/fs-utils.js";
-import { ensureRuntimeSchemaFileScaffold, loadRuntimeSchemaFromOptionalFiles, normalizeRuntimeSchemaSettings, } from "../schema/runtime-schema.js";
+import { DEFAULT_RUNTIME_SCHEMA_FILE_PATHS, ensureRuntimeSchemaFileScaffold, filePathForSchemaSection, loadRuntimeSchemaFromOptionalFiles, normalizeRuntimeSchemaSettings, } from "../schema/runtime-schema.js";
 import { getSettingsPath } from "./paths.js";
 import { orderObject, stableValueEquals } from "../shared/serialization.js";
 import { normalizeItemTypeDefinition } from "../item/item-type-definition.js";
+import { clearSettingsReadCache, collectSettingsReadCacheSignatures, getSettingsReadCacheEntry, setSettingsReadCacheEntry, settingsReadCacheSignaturesEqual, } from "./settings-read-cache.js";
 const SETTINGS_WRITE_OP = "settings:write";
 const SETTINGS_PERSIST_SOURCE_SYMBOL = Symbol("pm.settings.persist_source");
 const MAX_VECTOR_STORE_COLLECTION_NAME_LENGTH = 128;
@@ -183,6 +184,78 @@ function getSettingsPersistSourceSnapshot(settings) {
     }
     return candidate;
 }
+function cloneSettingsReadResult(result) {
+    const clonedSettings = structuredClone(result.settings);
+    const persistSource = getSettingsPersistSourceSnapshot(result.settings);
+    if (persistSource) {
+        attachSettingsPersistSourceSnapshot(clonedSettings, structuredClone(persistSource));
+    }
+    return {
+        settings: clonedSettings,
+        metadata: {
+            has_explicit_item_format: result.metadata.has_explicit_item_format,
+        },
+        warnings: [...result.warnings],
+    };
+}
+function resolveSettingsReadTrackedPaths(pmRoot, schema, settingsPath) {
+    const normalizedSchema = normalizeRuntimeSchemaSettings(schema);
+    return [
+        settingsPath,
+        filePathForSchemaSection(pmRoot, normalizedSchema.files.types, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.types),
+        filePathForSchemaSection(pmRoot, normalizedSchema.files.statuses, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.statuses),
+        filePathForSchemaSection(pmRoot, normalizedSchema.files.fields, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.fields),
+        filePathForSchemaSection(pmRoot, normalizedSchema.files.workflows, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.workflows),
+    ];
+}
+async function cacheSettingsReadResult(pmRoot, trackedPaths, result) {
+    const signatures = await collectSettingsReadCacheSignatures(trackedPaths);
+    setSettingsReadCacheEntry(pmRoot, {
+        tracked_paths: trackedPaths,
+        signatures,
+        value: cloneSettingsReadResult(result),
+    });
+}
+async function cacheSettingsReadResultSafe(pmRoot, trackedPaths, result) {
+    try {
+        await cacheSettingsReadResult(pmRoot, trackedPaths, result);
+    }
+    catch {
+        clearSettingsReadCache(pmRoot);
+    }
+}
+function findSettingsReadCacheSignature(signatures, targetPath) {
+    return signatures.find((signature) => signature.path === targetPath);
+}
+function selectedSettingsReadCacheSignaturesEqual(before, after, targetPaths) {
+    for (const targetPath of targetPaths) {
+        const beforeSignature = findSettingsReadCacheSignature(before, targetPath);
+        const afterSignature = findSettingsReadCacheSignature(after, targetPath);
+        if (!beforeSignature ||
+            !afterSignature ||
+            !settingsReadCacheSignaturesEqual([beforeSignature], [afterSignature])) {
+            return false;
+        }
+    }
+    return true;
+}
+async function cacheSettingsReadResultIfStable(pmRoot, trackedPaths, result, stableSignatures, stablePaths) {
+    try {
+        const currentSignatures = await collectSettingsReadCacheSignatures(trackedPaths);
+        if (!selectedSettingsReadCacheSignaturesEqual(stableSignatures, currentSignatures, stablePaths)) {
+            clearSettingsReadCache(pmRoot);
+            return;
+        }
+        setSettingsReadCacheEntry(pmRoot, {
+            tracked_paths: trackedPaths,
+            signatures: currentSignatures,
+            value: cloneSettingsReadResult(result),
+        });
+    }
+    catch {
+        clearSettingsReadCache(pmRoot);
+    }
+}
 function resolvePersistedFileBackedSchemaSections(settings, source) {
     const normalizedSchema = normalizeRuntimeSchemaSettings(settings.schema);
     const currentItemTypeDefinitions = normalizeItemTypeDefinitions(settings.item_types?.definitions);
@@ -348,11 +421,39 @@ function normalizeExtensionPolicyOverrides(overrides) {
     }
     return [...dedupedByName.values()].sort((left, right) => left.name.localeCompare(right.name));
 }
+function normalizePmMaxVersionExceededModeValue(value) {
+    return value === "block" || value === "warn" ? value : undefined;
+}
+/**
+ * Preserve a configured `pm_max_version_exceeded_mode` (string mode or per-layer
+ * override object) through settings normalization. Unset/invalid values are
+ * omitted so existing settings.json files round-trip byte-identically and the
+ * loader applies its safe default ("block").
+ */
+function normalizePmMaxVersionExceededModeSetting(value) {
+    if (typeof value === "string") {
+        return normalizePmMaxVersionExceededModeValue(value);
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const global = normalizePmMaxVersionExceededModeValue(value.global);
+        const project = normalizePmMaxVersionExceededModeValue(value.project);
+        if (global === undefined && project === undefined) {
+            return undefined;
+        }
+        return {
+            ...(global !== undefined ? { global } : {}),
+            ...(project !== undefined ? { project } : {}),
+        };
+    }
+    return undefined;
+}
 function normalizeExtensionPolicySettings(policy) {
     const defaults = SETTINGS_DEFAULTS.extensions.policy;
+    const pmMaxVersionExceededMode = normalizePmMaxVersionExceededModeSetting(policy?.pm_max_version_exceeded_mode);
     return {
         mode: normalizeExtensionPolicyMode(policy?.mode),
         trust_mode: normalizeExtensionTrustMode(policy?.trust_mode),
+        ...(pmMaxVersionExceededMode !== undefined ? { pm_max_version_exceeded_mode: pmMaxVersionExceededMode } : {}),
         require_provenance: policy?.require_provenance === true,
         trusted_extensions: normalizeLowerStringList(policy?.trusted_extensions ?? defaults.trusted_extensions),
         default_sandbox_profile: normalizeExtensionSandboxProfile(policy?.default_sandbox_profile),
@@ -653,6 +754,7 @@ export function serializeSettings(settings, options = {}) {
     ordered.extensions.policy = orderObject((ordered.extensions.policy ?? {}), [
         "mode",
         "trust_mode",
+        "pm_max_version_exceeded_mode",
         "require_provenance",
         "trusted_extensions",
         "default_sandbox_profile",
@@ -718,29 +820,53 @@ export function serializeSettings(settings, options = {}) {
 }
 export async function readSettingsWithMetadata(pmRoot) {
     const settingsPath = getSettingsPath(pmRoot);
-    const raw = await readFileIfExists(settingsPath);
-    if (raw === null) {
-        return buildFallbackSettingsReadResult();
-    }
+    let trackedPathsForFailure = [settingsPath];
     await runActiveOnReadHooks({
         path: settingsPath,
         scope: "project",
     });
+    const cachedResult = getSettingsReadCacheEntry(pmRoot);
+    if (cachedResult) {
+        const currentSignatures = await collectSettingsReadCacheSignatures(cachedResult.tracked_paths);
+        if (settingsReadCacheSignaturesEqual(currentSignatures, cachedResult.signatures)) {
+            return cloneSettingsReadResult(cachedResult.value);
+        }
+    }
+    const settingsOnlySignatures = await collectSettingsReadCacheSignatures([settingsPath]);
+    const raw = await readFileIfExists(settingsPath);
+    if (raw === null) {
+        const fallback = buildFallbackSettingsReadResult();
+        await cacheSettingsReadResultIfStable(pmRoot, [settingsPath], fallback, settingsOnlySignatures, [settingsPath]);
+        return fallback;
+    }
+    const settingsSignaturesAfterRead = await collectSettingsReadCacheSignatures([settingsPath]);
+    if (!settingsReadCacheSignaturesEqual(settingsOnlySignatures, settingsSignaturesAfterRead)) {
+        clearSettingsReadCache(pmRoot);
+        return readSettingsWithMetadata(pmRoot);
+    }
     let parsed;
     try {
         parsed = JSON.parse(raw);
     }
     catch {
-        return buildFallbackSettingsReadResult("settings_read_invalid_json");
+        const fallback = buildFallbackSettingsReadResult("settings_read_invalid_json");
+        await cacheSettingsReadResultIfStable(pmRoot, [settingsPath], fallback, settingsSignaturesAfterRead, [settingsPath]);
+        return fallback;
     }
     const validated = validateSettings(parsed);
     if (!validated.success) {
-        return buildFallbackSettingsReadResult("settings_read_invalid_schema");
+        const fallback = buildFallbackSettingsReadResult("settings_read_invalid_schema");
+        await cacheSettingsReadResultIfStable(pmRoot, [settingsPath], fallback, settingsSignaturesAfterRead, [settingsPath]);
+        return fallback;
     }
     try {
         const mergedSettings = mergeSettings(validated.data);
+        const trackedPaths = resolveSettingsReadTrackedPaths(pmRoot, mergedSettings.schema, settingsPath);
+        trackedPathsForFailure = trackedPaths;
+        const signaturesBeforeSchemaLoad = await collectSettingsReadCacheSignatures(trackedPaths);
         const schemaScaffold = await ensureRuntimeSchemaFileScaffold(pmRoot, mergedSettings.schema);
         const loadedSchemaSections = await loadRuntimeSchemaFromOptionalFiles(pmRoot, mergedSettings.schema);
+        const signaturesAfterSchemaLoad = await collectSettingsReadCacheSignatures(trackedPaths);
         const settings = {
             ...mergedSettings,
             item_types: {
@@ -752,7 +878,7 @@ export async function readSettingsWithMetadata(pmRoot) {
             schema: loadedSchemaSections.schema,
         };
         attachSettingsPersistSourceSnapshot(settings, buildSettingsPersistSourceSnapshot(validated.data, settings));
-        return {
+        const result = {
             settings,
             metadata: {
                 has_explicit_item_format: hasExplicitItemFormat(parsed),
@@ -765,9 +891,28 @@ export async function readSettingsWithMetadata(pmRoot) {
                 ...loadedSchemaSections.warnings,
             ],
         };
+        if (schemaScaffold.created_paths.length === 0) {
+            if (!settingsReadCacheSignaturesEqual(signaturesBeforeSchemaLoad, signaturesAfterSchemaLoad)) {
+                clearSettingsReadCache(pmRoot);
+            }
+            else {
+                setSettingsReadCacheEntry(pmRoot, {
+                    tracked_paths: trackedPaths,
+                    signatures: signaturesAfterSchemaLoad,
+                    value: cloneSettingsReadResult(result),
+                });
+            }
+        }
+        else {
+            // Bootstrap warnings are intentionally one-shot and should not be replayed from cache.
+            clearSettingsReadCache(pmRoot);
+        }
+        return result;
     }
     catch {
-        return buildFallbackSettingsReadResult("settings_read_merge_failed");
+        const fallback = buildFallbackSettingsReadResult("settings_read_merge_failed");
+        await cacheSettingsReadResultSafe(pmRoot, trackedPathsForFailure, fallback);
+        return fallback;
     }
 }
 export async function readSettings(pmRoot) {
@@ -778,11 +923,16 @@ export async function writeSettings(pmRoot, settings, op = SETTINGS_WRITE_OP) {
     await writeFileAtomic(settingsPath, serializeSettings(settings, {
         persist_source: getSettingsPersistSourceSnapshot(settings),
     }));
-    await runActiveOnWriteHooks({
-        path: settingsPath,
-        scope: "project",
-        op,
-    });
+    try {
+        await runActiveOnWriteHooks({
+            path: settingsPath,
+            scope: "project",
+            op,
+        });
+    }
+    finally {
+        clearSettingsReadCache(pmRoot);
+    }
 }
 //# sourceMappingURL=settings.js.map
-//# debugId=40eb6325-776d-5b33-887f-abbdee742b52
+//# debugId=759b1285-3075-5bd2-a0d7-9eab54fc1093