@bleedingdev/modern-js-ultramodern-create 3.8.3-ultramodern.2

package/dist/cjs/ultramodern-workspace/module-federation.cjs

@@ -0,0 +1,77 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createAppModernConfig: ()=>config_cjs_namespaceObject.createAppModernConfig,
+    createBackendModuleFederationConfig: ()=>config_cjs_namespaceObject.createBackendModuleFederationConfig,
+    createBuildMarker: ()=>external_delivery_unit_cjs_namespaceObject.createBuildMarker,
+    createModuleFederationRemoteUrlHelpers: ()=>remote_refs_cjs_namespaceObject.createModuleFederationRemoteUrlHelpers,
+    createModuleFederationRemotesConfig: ()=>remote_refs_cjs_namespaceObject.createModuleFederationRemotesConfig,
+    createRemoteModuleFederationConfig: ()=>config_cjs_namespaceObject.createRemoteModuleFederationConfig,
+    createSharedModuleFederationConfig: ()=>shared_config_cjs_namespaceObject.createSharedModuleFederationConfig,
+    createShellModuleFederationConfig: ()=>config_cjs_namespaceObject.createShellModuleFederationConfig,
+    createUltramodernBuildArtifactJson: ()=>reexport_module_cjs_namespaceObject.createUltramodernBuildArtifactJson,
+    createUltramodernBuildModule: ()=>reexport_module_cjs_namespaceObject.createUltramodernBuildModule,
+    createUltramodernBuildReexportModule: ()=>reexport_module_cjs_namespaceObject.createUltramodernBuildReexportModule,
+    formatTsObjectLiteral: ()=>shared_config_cjs_namespaceObject.formatTsObjectLiteral
+});
+const external_delivery_unit_cjs_namespaceObject = require("./delivery-unit.cjs");
+const config_cjs_namespaceObject = require("./module-federation/config.cjs");
+const reexport_module_cjs_namespaceObject = require("./module-federation/reexport-module.cjs");
+const remote_refs_cjs_namespaceObject = require("./module-federation/remote-refs.cjs");
+const shared_config_cjs_namespaceObject = require("./module-federation/shared-config.cjs");
+exports.createAppModernConfig = __webpack_exports__.createAppModernConfig;
+exports.createBackendModuleFederationConfig = __webpack_exports__.createBackendModuleFederationConfig;
+exports.createBuildMarker = __webpack_exports__.createBuildMarker;
+exports.createModuleFederationRemoteUrlHelpers = __webpack_exports__.createModuleFederationRemoteUrlHelpers;
+exports.createModuleFederationRemotesConfig = __webpack_exports__.createModuleFederationRemotesConfig;
+exports.createRemoteModuleFederationConfig = __webpack_exports__.createRemoteModuleFederationConfig;
+exports.createSharedModuleFederationConfig = __webpack_exports__.createSharedModuleFederationConfig;
+exports.createShellModuleFederationConfig = __webpack_exports__.createShellModuleFederationConfig;
+exports.createUltramodernBuildArtifactJson = __webpack_exports__.createUltramodernBuildArtifactJson;
+exports.createUltramodernBuildModule = __webpack_exports__.createUltramodernBuildModule;
+exports.createUltramodernBuildReexportModule = __webpack_exports__.createUltramodernBuildReexportModule;
+exports.formatTsObjectLiteral = __webpack_exports__.formatTsObjectLiteral;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createAppModernConfig",
+    "createBackendModuleFederationConfig",
+    "createBuildMarker",
+    "createModuleFederationRemoteUrlHelpers",
+    "createModuleFederationRemotesConfig",
+    "createRemoteModuleFederationConfig",
+    "createSharedModuleFederationConfig",
+    "createShellModuleFederationConfig",
+    "createUltramodernBuildArtifactJson",
+    "createUltramodernBuildModule",
+    "createUltramodernBuildReexportModule",
+    "formatTsObjectLiteral"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/naming.cjs

@@ -0,0 +1,155 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    assertUniqueTailwindPrefixes: ()=>assertUniqueTailwindPrefixes,
+    createRspackChunkLoadingGlobal: ()=>createRspackChunkLoadingGlobal,
+    createRspackUniqueName: ()=>createRspackUniqueName,
+    createTw: ()=>createTw,
+    normalizePath: ()=>normalizePath,
+    packageName: ()=>naming_packageName,
+    relativeRootFor: ()=>relativeRootFor,
+    tailwindPrefixForApp: ()=>tailwindPrefixForApp,
+    toCamelCase: ()=>toCamelCase,
+    toEnvSegment: ()=>toEnvSegment,
+    toKebabCase: ()=>toKebabCase,
+    toPackageScope: ()=>toPackageScope,
+    toPascalCase: ()=>toPascalCase
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const TAILWIND_PREFIX_DIGIT_WORDS = [
+    'zero',
+    'one',
+    'two',
+    'three',
+    'four',
+    'five',
+    'six',
+    'seven',
+    'eight',
+    'nine'
+];
+function normalizePath(filePath) {
+    return filePath.split(external_node_path_default().sep).join('/');
+}
+function toPackageScope(packageName) {
+    const normalized = packageName.replace(/^@/, '').replace(/[\\/]+/g, '-').toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^[._-]+|[._-]+$/g, '').replace(/-{2,}/g, '-');
+    return normalized || 'ultramodern-superapp';
+}
+function toKebabCase(value) {
+    const normalized = value.trim().replace(/([a-z0-9])([A-Z])/g, '$1-$2').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/[._]+/g, '-').toLowerCase().replace(/-+/g, '-').replace(/^-+|-+$/g, '');
+    return normalized;
+}
+function toCamelCase(value) {
+    const pascal = toPascalCase(value);
+    return `${pascal.charAt(0).toLowerCase()}${pascal.slice(1)}`;
+}
+function toEnvSegment(value) {
+    return toKebabCase(value).replace(/-/g, '_').toUpperCase();
+}
+function createRspackUniqueName(app) {
+    return app.mfName;
+}
+function createRspackChunkLoadingGlobal(app) {
+    return `__ULTRAMODERN_${toEnvSegment(app.mfName)}_LOADED_CHUNKS__`;
+}
+function naming_packageName(scope, suffix) {
+    return `@${scope}/${suffix}`;
+}
+function relativeRootFor(packageDir) {
+    return normalizePath(external_node_path_default().relative(packageDir, '.') || '.');
+}
+function createTailwindPrefix(raw) {
+    const normalized = raw.toLowerCase().replace(/[^a-z0-9]/gu, '');
+    if (!normalized) throw new Error(`Cannot derive a Tailwind prefix from ${raw}`);
+    return normalized.replace(/[0-9]/gu, (digit)=>TAILWIND_PREFIX_DIGIT_WORDS[Number(digit)]);
+}
+function tailwindPrefixForApp(app) {
+    if ('shell' === app.kind) return 'shell-super-app' === app.id ? 'shell' : createTailwindPrefix(app.id);
+    return createTailwindPrefix(app.domain ?? app.id);
+}
+function assertUniqueTailwindPrefixes(apps) {
+    const seen = new Map();
+    const entries = apps.map((app)=>[
+            app.id,
+            tailwindPrefixForApp(app)
+        ]);
+    for (const [id, prefix] of entries){
+        const previous = seen.get(prefix);
+        if (previous) throw new Error(`Tailwind prefix ${prefix} for ${id} collides with ${previous}`);
+        seen.set(prefix, id);
+    }
+}
+function createTw(prefix) {
+    return (classList)=>classList.split(/\s+/u).filter(Boolean).map((candidate)=>`${prefix}:${candidate.replace(/\[&&\]:/gu, '')}`).join(' ');
+}
+function toPascalCase(value) {
+    return value.split(/[-_]+/).filter(Boolean).map((part)=>`${part.charAt(0).toUpperCase()}${part.slice(1)}`).join('');
+}
+exports.assertUniqueTailwindPrefixes = __webpack_exports__.assertUniqueTailwindPrefixes;
+exports.createRspackChunkLoadingGlobal = __webpack_exports__.createRspackChunkLoadingGlobal;
+exports.createRspackUniqueName = __webpack_exports__.createRspackUniqueName;
+exports.createTw = __webpack_exports__.createTw;
+exports.normalizePath = __webpack_exports__.normalizePath;
+exports.packageName = __webpack_exports__.packageName;
+exports.relativeRootFor = __webpack_exports__.relativeRootFor;
+exports.tailwindPrefixForApp = __webpack_exports__.tailwindPrefixForApp;
+exports.toCamelCase = __webpack_exports__.toCamelCase;
+exports.toEnvSegment = __webpack_exports__.toEnvSegment;
+exports.toKebabCase = __webpack_exports__.toKebabCase;
+exports.toPackageScope = __webpack_exports__.toPackageScope;
+exports.toPascalCase = __webpack_exports__.toPascalCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assertUniqueTailwindPrefixes",
+    "createRspackChunkLoadingGlobal",
+    "createRspackUniqueName",
+    "createTw",
+    "normalizePath",
+    "packageName",
+    "relativeRootFor",
+    "tailwindPrefixForApp",
+    "toCamelCase",
+    "toEnvSegment",
+    "toKebabCase",
+    "toPackageScope",
+    "toPascalCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/overlay-baseline-guard.cjs

@@ -0,0 +1,408 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    BASELINE_DEPENDENCY_PINS: ()=>BASELINE_DEPENDENCY_PINS,
+    OverlayBaselineRelaxationError: ()=>OverlayBaselineRelaxationError,
+    assertOverlayPreservedBaseline: ()=>assertOverlayPreservedBaseline,
+    captureOverlayBaselineSnapshot: ()=>captureOverlayBaselineSnapshot
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const external_types_cjs_namespaceObject = require("./types.cjs");
+const external_versions_cjs_namespaceObject = require("./versions.cjs");
+const BASELINE_DEPENDENCY_PINS = Object.freeze({
+    react: external_versions_cjs_namespaceObject.REACT_VERSION,
+    'react-dom': external_versions_cjs_namespaceObject.REACT_DOM_VERSION,
+    '@tanstack/react-router': external_versions_cjs_namespaceObject.TANSTACK_ROUTER_VERSION,
+    '@tanstack/router-core': external_versions_cjs_namespaceObject.TANSTACK_ROUTER_CORE_VERSION,
+    effect: external_versions_cjs_namespaceObject.EFFECT_VERSION,
+    tailwindcss: external_versions_cjs_namespaceObject.TAILWIND_VERSION
+});
+const FORBIDDEN_SHELL_ARTIFACT_SEGMENTS = [
+    'api',
+    'server',
+    'backend-federation.config.ts'
+];
+const IGNORED_WALK_DIRECTORIES = new Set([
+    '.git',
+    '.nx',
+    '.output',
+    'coverage',
+    'dist',
+    'dist-cloudflare',
+    'node_modules'
+]);
+class OverlayBaselineRelaxationError extends Error {
+    constructor(generator, violations){
+        super([
+            `UltraModern CodeSmith overlay relaxed the Platform Baseline: ${generator}`,
+            ...violations.map((violation)=>`  - ${violation.path}: ${violation.detail}`)
+        ].join('\n')), this.code = 'ULTRAMODERN_OVERLAY_BASELINE_RELAXATION';
+        this.name = 'OverlayBaselineRelaxationError';
+        this.generator = generator;
+        this.violations = violations;
+    }
+}
+function walkFiles(root, predicate) {
+    const matches = [];
+    const queue = [
+        root
+    ];
+    while(queue.length > 0){
+        const current = queue.shift();
+        let entries;
+        try {
+            entries = external_node_fs_default().readdirSync(current, {
+                withFileTypes: true
+            });
+        } catch  {
+            continue;
+        }
+        for (const entry of entries){
+            const absolute = external_node_path_default().join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (!IGNORED_WALK_DIRECTORIES.has(entry.name)) queue.push(absolute);
+                continue;
+            }
+            const relative = external_node_path_default().relative(root, absolute).split(external_node_path_default().sep).join('/');
+            if (predicate(relative)) matches.push(relative);
+        }
+    }
+    return matches.sort();
+}
+function isPackageManifest(relativePath) {
+    return 'package.json' === relativePath || relativePath.endsWith('/package.json');
+}
+const DEPENDENCY_SECTIONS = [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies'
+];
+function readPackageJson(workspaceRoot, packageJsonRelativePath) {
+    const parsed = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().join(workspaceRoot, packageJsonRelativePath), 'utf-8'));
+    return (0, external_types_cjs_namespaceObject.isRecord)(parsed) ? parsed : {};
+}
+function dependencyEntries(parsed) {
+    const entries = [];
+    for (const section of DEPENDENCY_SECTIONS){
+        const group = parsed[section];
+        if ((0, external_types_cjs_namespaceObject.isRecord)(group)) {
+            for (const [name, value] of Object.entries(group))if ('string' == typeof value) entries.push({
+                section,
+                name,
+                value
+            });
+        }
+    }
+    return entries;
+}
+function baselineDependencyFromKey(key) {
+    const candidate = key.trim().split('>').at(-1) ?? '';
+    return Object.keys(BASELINE_DEPENDENCY_PINS).find((dependency)=>candidate === dependency || candidate.startsWith(`${dependency}@`));
+}
+function collectPolicyEntries(value, prefix, entries) {
+    if (!(0, external_types_cjs_namespaceObject.isRecord)(value)) return;
+    for (const [key, child] of Object.entries(value)){
+        const childPath = '' === prefix ? key : `${prefix}.${key}`;
+        const dependency = baselineDependencyFromKey(key);
+        if (void 0 !== dependency && 'string' == typeof child) entries.push({
+            path: childPath,
+            dependency,
+            value: child
+        });
+        if ((0, external_types_cjs_namespaceObject.isRecord)(child)) collectPolicyEntries(child, childPath, entries);
+    }
+}
+function policyRoots(parsed) {
+    const pnpm = (0, external_types_cjs_namespaceObject.isRecord)(parsed.pnpm) ? parsed.pnpm : void 0;
+    return [
+        [
+            'overrides',
+            parsed.overrides
+        ],
+        [
+            'resolutions',
+            parsed.resolutions
+        ],
+        [
+            'pnpm.overrides',
+            pnpm?.overrides
+        ],
+        [
+            'catalog',
+            parsed.catalog
+        ],
+        [
+            'catalogs',
+            parsed.catalogs
+        ],
+        [
+            'pnpm.catalog',
+            pnpm?.catalog
+        ],
+        [
+            'pnpm.catalogs',
+            pnpm?.catalogs
+        ]
+    ];
+}
+function baselinePolicyEntries(parsed) {
+    const entries = [];
+    for (const [prefix, value] of policyRoots(parsed))if (void 0 !== value) collectPolicyEntries(value, prefix, entries);
+    return entries;
+}
+function readPnpmWorkspaceYaml(workspaceRoot) {
+    try {
+        const parsed = utils_namespaceObject.yaml.load(external_node_fs_default().readFileSync(external_node_path_default().join(workspaceRoot, 'pnpm-workspace.yaml'), 'utf-8'));
+        return (0, external_types_cjs_namespaceObject.isRecord)(parsed) ? parsed : {};
+    } catch  {
+        return {};
+    }
+}
+function collectCatalogValues(parsed) {
+    const values = new Map();
+    const collect = (value, prefix)=>{
+        if (!(0, external_types_cjs_namespaceObject.isRecord)(value)) return;
+        for (const [key, child] of Object.entries(value)){
+            const childPath = '' === prefix ? key : `${prefix}.${key}`;
+            if ('string' == typeof child) {
+                values.set(key, child);
+                values.set(childPath, child);
+            } else collect(child, childPath);
+        }
+    };
+    for (const [prefix, value] of policyRoots(parsed).filter(([prefix])=>/catalog/u.test(prefix)))collect(value ?? {}, prefix);
+    return values;
+}
+function resolveCatalogReference(value, catalogValues) {
+    if (!value.startsWith('catalog:')) return value;
+    return catalogValues.get(value.slice(8)) ?? value;
+}
+function parseNpmAlias(value) {
+    if (!value.startsWith('npm:')) return;
+    const target = value.slice(4);
+    const separator = target.startsWith('@') ? target.indexOf('@', 1) : target.indexOf('@');
+    if (-1 === separator) return {
+        name: target,
+        range: void 0
+    };
+    return {
+        name: target.slice(0, separator),
+        range: target.slice(separator + 1)
+    };
+}
+function baselineSpecMatches(value, dependency) {
+    const expected = BASELINE_DEPENDENCY_PINS[dependency];
+    if (value === expected) return true;
+    const alias = parseNpmAlias(value);
+    return alias?.name === dependency && alias.range === expected;
+}
+function baselinePinsFromParsed(parsed) {
+    const pins = {};
+    for (const section of DEPENDENCY_SECTIONS){
+        const group = parsed[section];
+        if ((0, external_types_cjs_namespaceObject.isRecord)(group)) for (const dependency of Object.keys(BASELINE_DEPENDENCY_PINS)){
+            const value = group[dependency];
+            if ('string' == typeof value) pins[`${section}.${dependency}`] = value;
+        }
+    }
+    return pins;
+}
+function readBaselinePins(workspaceRoot, packageJsonRelativePath) {
+    return baselinePinsFromParsed(readPackageJson(workspaceRoot, packageJsonRelativePath));
+}
+function captureOverlayBaselineSnapshot(workspaceRoot, shellPackageDirectories) {
+    const baselinePinsByManifest = {};
+    const baselinePolicyPinsByManifest = {};
+    for (const manifest of walkFiles(workspaceRoot, isPackageManifest)){
+        const parsed = readPackageJson(workspaceRoot, manifest);
+        baselinePinsByManifest[manifest] = readBaselinePins(workspaceRoot, manifest);
+        baselinePolicyPinsByManifest[manifest] = Object.fromEntries(baselinePolicyEntries(parsed).map((entry)=>[
+                entry.path,
+                entry.value
+            ]));
+    }
+    const shellFiles = new Set();
+    for (const shellDir of shellPackageDirectories){
+        const absolute = external_node_path_default().join(workspaceRoot, shellDir);
+        if (external_node_fs_default().existsSync(absolute)) for (const file of walkFiles(absolute, ()=>true))shellFiles.add(`${shellDir}/${file}`);
+    }
+    return {
+        baselinePinsByManifest,
+        baselinePolicyPinsByManifest,
+        baselineWorkspacePolicyPins: Object.fromEntries(baselinePolicyEntries(readPnpmWorkspaceYaml(workspaceRoot)).map((entry)=>[
+                entry.path,
+                entry.value
+            ])),
+        shellPackageDirectories,
+        shellFiles
+    };
+}
+function collectPolicyViolations(parsed, beforePolicyPins, displayPath) {
+    const violations = [];
+    const currentPolicyEntries = baselinePolicyEntries(parsed);
+    const currentPolicyPins = Object.fromEntries(currentPolicyEntries.map((entry)=>[
+            entry.path,
+            entry.value
+        ]));
+    for (const [policyPath, previous] of Object.entries(beforePolicyPins)){
+        if (Object.hasOwn(currentPolicyPins, policyPath)) continue;
+        const dependency = baselineDependencyFromKey(policyPath.split('.').at(-1) ?? '') ?? policyPath.split('.').at(-1) ?? policyPath;
+        const expected = BASELINE_DEPENDENCY_PINS[dependency];
+        if (void 0 !== expected) violations.push({
+            kind: 'baseline-version-relaxation',
+            path: `${displayPath}#${policyPath}`,
+            detail: `overlay removed baseline policy "${policyPath}" from "${previous}"; Platform Baseline pin is "${expected}"`
+        });
+    }
+    const catalogValues = collectCatalogValues(parsed);
+    for (const entry of currentPolicyEntries){
+        const resolvedVersion = resolveCatalogReference(entry.value, catalogValues);
+        const expected = BASELINE_DEPENDENCY_PINS[entry.dependency];
+        if (!baselineSpecMatches(resolvedVersion, entry.dependency)) violations.push({
+            kind: 'baseline-version-relaxation',
+            path: `${displayPath}#${entry.path}`,
+            detail: `overlay policy "${entry.path}" pins baseline dependency "${entry.dependency}" at "${entry.value}"; Platform Baseline pin is "${expected}"`
+        });
+    }
+    return violations;
+}
+function collectVersionViolations(workspaceRoot, snapshot) {
+    const violations = [];
+    const manifests = new Set([
+        ...walkFiles(workspaceRoot, isPackageManifest),
+        ...Object.keys(snapshot.baselinePinsByManifest)
+    ]);
+    for (const manifest of manifests){
+        let parsed;
+        try {
+            parsed = readPackageJson(workspaceRoot, manifest);
+        } catch  {
+            parsed = {};
+        }
+        const pins = baselinePinsFromParsed(parsed);
+        const before = snapshot.baselinePinsByManifest[manifest] ?? {};
+        for (const key of Object.keys(before)){
+            if (Object.hasOwn(pins, key)) continue;
+            const separator = key.indexOf('.');
+            const section = key.slice(0, separator);
+            const dependency = key.slice(separator + 1);
+            const expected = BASELINE_DEPENDENCY_PINS[dependency];
+            violations.push({
+                kind: 'baseline-version-relaxation',
+                path: manifest,
+                detail: `overlay removed baseline dependency "${dependency}" from ${section}; Platform Baseline pin is "${expected}"`
+            });
+        }
+        const catalogValues = collectCatalogValues(parsed);
+        for (const [key, version] of Object.entries(pins)){
+            const dependency = key.slice(key.indexOf('.') + 1);
+            const expected = BASELINE_DEPENDENCY_PINS[dependency];
+            const previous = before[key];
+            const resolvedVersion = resolveCatalogReference(version, catalogValues);
+            const matches = baselineSpecMatches(resolvedVersion, dependency);
+            if (void 0 !== previous || matches) {
+                if (void 0 !== previous && version !== previous && !matches) violations.push({
+                    kind: 'baseline-version-relaxation',
+                    path: manifest,
+                    detail: `overlay changed baseline dependency "${dependency}" from "${previous}" to "${version}"; Platform Baseline pin is "${expected}"`
+                });
+            } else violations.push({
+                kind: 'baseline-version-relaxation',
+                path: manifest,
+                detail: `overlay added baseline dependency "${dependency}" at "${version}"; Platform Baseline pin is "${expected}"`
+            });
+        }
+        for (const entry of dependencyEntries(parsed)){
+            const alias = parseNpmAlias(entry.value);
+            if (void 0 === alias) continue;
+            const expected = BASELINE_DEPENDENCY_PINS[alias.name];
+            if (void 0 !== expected && alias.range !== expected) violations.push({
+                kind: 'baseline-version-relaxation',
+                path: manifest,
+                detail: `overlay alias "${entry.name}" resolves to baseline dependency "${alias.name}" at "${entry.value}"; Platform Baseline pin is "${expected}"`
+            });
+        }
+        violations.push(...collectPolicyViolations(parsed, snapshot.baselinePolicyPinsByManifest?.[manifest] ?? {}, manifest));
+    }
+    violations.push(...collectPolicyViolations(readPnpmWorkspaceYaml(workspaceRoot), snapshot.baselineWorkspacePolicyPins ?? {}, 'pnpm-workspace.yaml'));
+    return violations;
+}
+function collectForbiddenShellArtifactViolations(workspaceRoot, snapshot) {
+    const violations = [];
+    for (const shellDir of snapshot.shellPackageDirectories){
+        const absolute = external_node_path_default().join(workspaceRoot, shellDir);
+        if (external_node_fs_default().existsSync(absolute)) for (const file of walkFiles(absolute, ()=>true)){
+            const relative = `${shellDir}/${file}`;
+            if (snapshot.shellFiles.has(relative)) continue;
+            const segments = file.split('/');
+            const forbidden = FORBIDDEN_SHELL_ARTIFACT_SEGMENTS.find((segment)=>segments.includes(segment) || file === segment);
+            if (forbidden) violations.push({
+                kind: 'forbidden-shell-artifact',
+                path: relative,
+                detail: `overlay introduced a forbidden thin-shell artifact class "${forbidden}" into shell package ${shellDir}`
+            });
+        }
+    }
+    return violations;
+}
+function assertOverlayPreservedBaseline(options) {
+    const violations = [
+        ...collectVersionViolations(options.workspaceRoot, options.snapshot),
+        ...collectForbiddenShellArtifactViolations(options.workspaceRoot, options.snapshot)
+    ];
+    if (violations.length > 0) throw new OverlayBaselineRelaxationError(options.generator, violations);
+}
+exports.BASELINE_DEPENDENCY_PINS = __webpack_exports__.BASELINE_DEPENDENCY_PINS;
+exports.OverlayBaselineRelaxationError = __webpack_exports__.OverlayBaselineRelaxationError;
+exports.assertOverlayPreservedBaseline = __webpack_exports__.assertOverlayPreservedBaseline;
+exports.captureOverlayBaselineSnapshot = __webpack_exports__.captureOverlayBaselineSnapshot;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BASELINE_DEPENDENCY_PINS",
+    "OverlayBaselineRelaxationError",
+    "assertOverlayPreservedBaseline",
+    "captureOverlayBaselineSnapshot"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});