@bleedingdev/modern-js-server-runtime-extensions 0.0.0-trusted-publisher-bootstrap

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,67 @@
+# @modern-js/server-runtime-extensions
+
+Fork-owned ultramodern.js server runtime extensions. This package hosts the
+server-side fork features that previously lived inside the upstream-owned
+`@modern-js/server-core` sources, so the fork diff against upstream Modern.js
+stays small:
+
+- **Telemetry pipeline** — `TelemetryRegistry`, OTLP / VictoriaMetrics
+  exporters, SLO alerts, telemetry-aware metrics wrapping and the
+  `injectTelemetryPlugin()` server plugin (runtime status + runtime fallback
+  signal endpoints).
+- **Contract-gate canary autopilot** — `TelemetryCanaryOrchestrator`,
+  `ContractGateAutopilot` and the file/HTTP contract-gate snapshot stores.
+- **Module federation runtime helpers** — remote CSS collection for SSR
+  (`collectDirectRemoteModuleFederationCss`, `injectModuleFederationCssPlugin()`)
+  and MF asset cache-header policies (`resolveMfAssetCacheHeaders`,
+  `injectMfAssetCacheHeadersPlugin()`).
+
+## Registration
+
+None of these plugins are part of the bare `@modern-js/server-core` default
+plugin chain. `@modern-js/prod-server` registers them in its plugin assembly
+(`applyPlugins`), which is also the assembly used by the dev server
+(`@modern-js/server` via `@modern-js/app-tools`), so production and dev behave
+identically:
+
+- `injectTelemetryPlugin()` — no-op unless `server.telemetry` is configured.
+  The runtime-fallback-signal endpoint is opt-in
+  (`canary.autopilot.runtimeFallbackSignal.enabled: true`) and requires an
+  auth token (`auth.expectedValue` / `auth.expectedValueEnv`); the
+  `/_modern/runtime/status` endpoint returns a bare health probe unless the
+  caller authenticates with that token.
+- `injectModuleFederationCssPlugin()` — no-op unless the dist directory
+  contains an `mf-manifest.json` host manifest. Must be registered after
+  `injectResourcePlugin()` so the request-scoped server manifest exists. In
+  production the remote CSS collection is cached with a 30s TTL (configurable
+  via the plugin's `remoteCssCacheTtlMs` option) instead of being pinned at
+  boot.
+- `injectMfAssetCacheHeadersPlugin()` — applies the ADR-0002 MF cache-header
+  policy to `mf-manifest.json`/`mf-stats.json` (`no-store`) and
+  `remoteEntry*.js` (revalidate, or `immutable` when version-pinned via
+  `?mfv=`) responses served by the static middleware.
+
+## Environment variables
+
+The environment variables consumed by this package at runtime are parsed in a
+single typed pass by `parseServerRuntimeExtensionsEnv()` in `src/env.ts`:
+
+| Variable | Default | Description |
+| --- | --- | --- |
+| `MODERN_ENV` | _unset_ | Deployment environment name (also drives `.env.{MODERN_ENV}` loading in the server bootstrap). First candidate for the telemetry `environment` label. |
+| `NODE_ENV` | _unset_ | Standard Node.js environment name. Second candidate for the telemetry `environment` label; the final fallback is `development`. |
+| `MODERN_CONTRACT_GATES_FILE` | `.modern/contract-gates.json` (resolved against the app directory) | Path of the contract-gate snapshot file used by the canary autopilot and the runtime fallback signal endpoint when `server.telemetry.canary.autopilot.gateSnapshotPath` is not configured. |
+
+Exporter endpoints and the module federation remote manifest timeout are
+configured through `server.telemetry.exporters.*.endpoint` and plugin options
+only; their defaults (`http://127.0.0.1:4318/v1/logs`,
+`http://127.0.0.1:8428/api/v1/import/prometheus`, `1500`ms) are hard-coded,
+matching the pre-extraction server-core behavior.
+`MODERN_TELEMETRY_OTLP_ENDPOINT` / `MODERN_TELEMETRY_VICTORIA_ENDPOINT` are
+read only at config time by `@modern-js/app-tools` (`baseline.ts`), not at
+server runtime.
+
+One dynamic indirection cannot be statically parsed:
+`server.telemetry.canary.autopilot.runtimeFallbackSignal.auth.expectedValueEnv`
+names an arbitrary environment variable that holds the expected runtime-signal
+auth token; it is read when the auth config is normalized.

package/dist/cjs/contractGateAutopilot.js

@@ -0,0 +1,162 @@
+"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__, {
+    ContractGateAutopilot: ()=>ContractGateAutopilot
+});
+const external_contractGateSnapshotStore_js_namespaceObject = require("./contractGateSnapshotStore.js");
+const DEFAULT_POLL_INTERVAL_MS = 15000;
+const DEFAULT_GATE_STALE_AFTER_MS = 600000;
+class ContractGateAutopilot {
+    async start() {
+        await this.syncOnce();
+        if (this.poller) return;
+        this.poller = setInterval(()=>{
+            this.syncOnce();
+        }, this.pollIntervalMs);
+        if ('function' == typeof this.poller.unref) this.poller.unref();
+    }
+    stop() {
+        if (this.poller) {
+            clearInterval(this.poller);
+            this.poller = void 0;
+        }
+    }
+    async syncOnce() {
+        const snapshot = await this.loadSnapshot();
+        if (!snapshot) return 0;
+        const gates = this.normalizeSnapshot(snapshot);
+        let updatedCount = 0;
+        for (const gate of gates){
+            this.orchestrator.addRequiredContractGate(gate.name);
+            const fingerprint = `${gate.passed ? '1' : '0'}:${gate.reason || ''}`;
+            if (this.appliedGateFingerprints.get(gate.name) !== fingerprint) {
+                this.orchestrator.setContractGate(gate.name, gate.passed, gate.reason);
+                this.appliedGateFingerprints.set(gate.name, fingerprint);
+                updatedCount += 1;
+                this.logger?.info?.(`[telemetry.canary.autopilot] gate=${gate.name} passed=${String(gate.passed)} reason=${gate.reason || 'none'}`);
+            }
+        }
+        return updatedCount;
+    }
+    async loadSnapshot() {
+        try {
+            const snapshot = await this.gateSnapshotStore.readSnapshot();
+            if (!snapshot) return;
+            const fingerprint = JSON.stringify(snapshot);
+            if (fingerprint === this.lastSnapshotFingerprint) return;
+            this.lastSnapshotFingerprint = fingerprint;
+            return snapshot;
+        } catch (error) {
+            const source = this.gateSnapshotPath || this.gateSnapshotStore.name || 'stateStore';
+            this.logger?.warn?.(`[telemetry.canary.autopilot] failed to load gate snapshot ${source}: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+    }
+    normalizeSnapshot(snapshot) {
+        const now = Date.now();
+        const output = [];
+        const gates = snapshot.gates;
+        if (!gates || 'object' != typeof gates) return output;
+        for (const [name, value] of Object.entries(gates)){
+            const normalizedName = name.trim();
+            if (!normalizedName) continue;
+            const gate = this.normalizeGateValue(value, snapshot.updatedAt, now);
+            if (!gate) continue;
+            if ('number' == typeof gate.expiresAt && Number.isFinite(gate.expiresAt) && gate.expiresAt > 0 && now >= gate.expiresAt) {
+                output.push({
+                    name: normalizedName,
+                    passed: true,
+                    reason: void 0,
+                    updatedAt: gate.updatedAt,
+                    expiresAt: gate.expiresAt
+                });
+                continue;
+            }
+            const isStale = this.gateStaleAfterMs > 0 && now - gate.updatedAt > this.gateStaleAfterMs;
+            if (isStale) {
+                output.push({
+                    name: normalizedName,
+                    passed: false,
+                    reason: gate.reason || 'Gate snapshot is stale',
+                    updatedAt: gate.updatedAt
+                });
+                continue;
+            }
+            output.push({
+                name: normalizedName,
+                passed: gate.passed,
+                reason: gate.reason,
+                updatedAt: gate.updatedAt
+            });
+        }
+        return output;
+    }
+    normalizeGateValue(value, snapshotUpdatedAt, now) {
+        if ('boolean' == typeof value) return {
+            passed: value,
+            updatedAt: this.normalizeUpdatedAt(snapshotUpdatedAt, now)
+        };
+        if (!value || 'object' != typeof value) return;
+        const hasPassed = 'boolean' == typeof value.passed;
+        const passed = true === value.passed;
+        let reason = 'string' == typeof value.reason && value.reason.trim().length > 0 ? value.reason : void 0;
+        if (!hasPassed) reason = reason || 'Gate snapshot record is missing "passed" boolean';
+        return {
+            passed,
+            reason,
+            updatedAt: this.normalizeUpdatedAt(value.updatedAt ?? snapshotUpdatedAt, now),
+            expiresAt: this.normalizeExpiresAt(value.expiresAt)
+        };
+    }
+    normalizeUpdatedAt(value, fallback) {
+        if ('number' == typeof value && Number.isFinite(value) && value > 0) return value;
+        return fallback;
+    }
+    normalizeExpiresAt(value) {
+        if ('number' == typeof value && Number.isFinite(value) && value > 0) return value;
+    }
+    constructor(options){
+        this.appliedGateFingerprints = new Map();
+        this.orchestrator = options.orchestrator;
+        if (!options.gateSnapshotStore && !options.gateSnapshotPath) throw new Error('ContractGateAutopilot requires gateSnapshotPath or gateSnapshotStore');
+        this.gateSnapshotPath = options.gateSnapshotPath;
+        this.gateSnapshotStore = options.gateSnapshotStore || (0, external_contractGateSnapshotStore_js_namespaceObject.createFileContractGateSnapshotStore)(options.gateSnapshotPath);
+        this.pollIntervalMs = Math.max(250, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+        this.gateStaleAfterMs = Math.max(0, options.gateStaleAfterMs ?? DEFAULT_GATE_STALE_AFTER_MS);
+        this.logger = options.logger;
+    }
+}
+exports.ContractGateAutopilot = __webpack_exports__.ContractGateAutopilot;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ContractGateAutopilot"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/contractGateSnapshotStore.js

@@ -0,0 +1,253 @@
+"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__, {
+    CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION: ()=>CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION,
+    DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH: ()=>DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH,
+    createFileContractGateSnapshotStore: ()=>createFileContractGateSnapshotStore,
+    createHttpContractGateSnapshotStore: ()=>createHttpContractGateSnapshotStore,
+    resolveContractGateSnapshotPath: ()=>resolveContractGateSnapshotPath,
+    resolveContractGateSnapshotStore: ()=>resolveContractGateSnapshotStore
+});
+const external_node_module_namespaceObject = require("node:module");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_fs_namespaceObject = require("fs");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_env_js_namespaceObject = require("./env.js");
+const CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION = 1;
+const DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH = '.modern/contract-gates.json';
+const DEFAULT_HTTP_STORE_TIMEOUT_MS = 5000;
+const BUILTIN_HTTP_STATE_STORE_MODULES = new Set([
+    'http',
+    '@modern-js/server-core/http',
+    '@modern-js/server-core/contract-gate-http-store',
+    '@modern-js/server-runtime-extensions/http',
+    '@modern-js/server-runtime-extensions/contract-gate-http-store'
+]);
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const normalizeSnapshot = (snapshot)=>{
+    if (!isRecord(snapshot)) return;
+    const schemaVersion = 'number' == typeof snapshot.schemaVersion ? snapshot.schemaVersion : CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION;
+    const updatedAt = 'number' == typeof snapshot.updatedAt ? snapshot.updatedAt : Date.now();
+    const gates = isRecord(snapshot.gates) ? snapshot.gates : {};
+    return {
+        schemaVersion,
+        updatedAt,
+        gates
+    };
+};
+const normalizeHttpStoreOptions = (options)=>{
+    const endpoint = 'string' == typeof options?.endpoint ? options.endpoint.trim() : '';
+    if (!endpoint) throw new Error('[telemetry.canary.autopilot] HTTP stateStore requires options.endpoint');
+    const readMethod = 'string' == typeof options?.readMethod && options.readMethod.trim() ? options.readMethod.trim().toUpperCase() : 'GET';
+    const writeMethod = 'string' == typeof options?.writeMethod && options.writeMethod.trim() ? options.writeMethod.trim().toUpperCase() : 'PUT';
+    const timeoutMsRaw = Number(options?.timeoutMs);
+    const timeoutMs = Number.isFinite(timeoutMsRaw) && timeoutMsRaw > 0 ? Math.floor(timeoutMsRaw) : DEFAULT_HTTP_STORE_TIMEOUT_MS;
+    const headersRaw = options?.headers;
+    const headers = {};
+    if (headersRaw && 'object' == typeof headersRaw && !Array.isArray(headersRaw)) Object.entries(headersRaw).forEach(([key, value])=>{
+        if ('string' == typeof key && key.trim().length > 0 && null != value) headers[key] = String(value);
+    });
+    return {
+        endpoint,
+        readMethod,
+        writeMethod,
+        headers,
+        timeoutMs
+    };
+};
+const withTimeoutAbort = (timeoutMs)=>{
+    const controller = new AbortController();
+    const timer = setTimeout(()=>controller.abort(), timeoutMs);
+    return {
+        signal: controller.signal,
+        clear: ()=>clearTimeout(timer)
+    };
+};
+const createHttpContractGateSnapshotStore = (options)=>{
+    const normalized = normalizeHttpStoreOptions(options);
+    const endpoint = normalized.endpoint;
+    return {
+        name: `http:${endpoint}`,
+        async readSnapshot () {
+            const { signal, clear } = withTimeoutAbort(normalized.timeoutMs || 5000);
+            try {
+                const response = await fetch(endpoint, {
+                    method: normalized.readMethod || 'GET',
+                    headers: {
+                        accept: 'application/json',
+                        ...normalized.headers || {}
+                    },
+                    signal
+                });
+                if (404 === response.status) return;
+                if (!response.ok) throw new Error(`HTTP stateStore read failed with status ${String(response.status)}`);
+                const payload = await response.json();
+                return normalizeSnapshot(payload);
+            } finally{
+                clear();
+            }
+        },
+        async writeSnapshot (snapshot) {
+            const body = JSON.stringify(normalizeSnapshot(snapshot) || {
+                schemaVersion: CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION,
+                updatedAt: Date.now(),
+                gates: {}
+            });
+            const { signal, clear } = withTimeoutAbort(normalized.timeoutMs || 5000);
+            try {
+                const response = await fetch(endpoint, {
+                    method: normalized.writeMethod || 'PUT',
+                    headers: {
+                        'content-type': 'application/json',
+                        ...normalized.headers || {}
+                    },
+                    body,
+                    signal
+                });
+                if (!response.ok) throw new Error(`HTTP stateStore write failed with status ${String(response.status)}`);
+            } finally{
+                clear();
+            }
+        }
+    };
+};
+const tryResolveBuiltinSnapshotStore = (input)=>{
+    const moduleName = input.stateStore.module.trim();
+    if (!BUILTIN_HTTP_STATE_STORE_MODULES.has(moduleName)) return;
+    return createHttpContractGateSnapshotStore(input.stateStore.options || {});
+};
+const pickStoreFactory = (mod)=>{
+    if ('function' == typeof mod) return mod;
+    if ('function' == typeof mod.createContractGateSnapshotStore) return mod.createContractGateSnapshotStore;
+    if ('function' == typeof mod.default) return mod.default;
+    if (mod.default && 'object' == typeof mod.default && 'function' == typeof mod.default.createContractGateSnapshotStore) return mod.default.createContractGateSnapshotStore;
+};
+const ensureStoreShape = (store, modulePath)=>{
+    if (!store || 'object' != typeof store || 'function' != typeof store.readSnapshot || 'function' != typeof store.writeSnapshot) throw new Error(`Invalid contract gate snapshot store from "${modulePath}". Expected { readSnapshot(), writeSnapshot() }.`);
+};
+const resolveStoreModulePath = (appDirectory, modulePath)=>{
+    const normalized = modulePath.trim();
+    if (!normalized) throw new Error('Contract gate snapshot stateStore.module must be non-empty');
+    if (external_path_default().isAbsolute(normalized)) return normalized;
+    if (normalized.startsWith('.')) return external_path_default().resolve(appDirectory, normalized);
+    const appRequire = (0, external_node_module_namespaceObject.createRequire)(external_path_default().join(appDirectory, 'package.json'));
+    try {
+        return appRequire.resolve(normalized);
+    } catch (_error) {
+        return normalized;
+    }
+};
+const resolveContractGateSnapshotPath = (appDirectory, configuredPath)=>{
+    const rawPath = configuredPath || (0, external_env_js_namespaceObject.parseServerRuntimeExtensionsEnv)().contractGatesFile || DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH;
+    if (external_path_default().isAbsolute(rawPath)) return rawPath;
+    return external_path_default().resolve(appDirectory, rawPath);
+};
+const createFileContractGateSnapshotStore = (gateSnapshotPath)=>{
+    const resolvedPath = external_path_default().resolve(gateSnapshotPath);
+    return {
+        name: `file:${resolvedPath}`,
+        async readSnapshot () {
+            if (!await utils_namespaceObject.fs.pathExists(resolvedPath)) return;
+            try {
+                const raw = await external_fs_namespaceObject.promises.readFile(resolvedPath, 'utf8');
+                return normalizeSnapshot(JSON.parse(raw));
+            } catch (_error) {
+                return;
+            }
+        },
+        async writeSnapshot (snapshot) {
+            const normalized = normalizeSnapshot(snapshot) || {
+                schemaVersion: CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION,
+                updatedAt: Date.now(),
+                gates: {}
+            };
+            await external_fs_namespaceObject.promises.mkdir(external_path_default().dirname(resolvedPath), {
+                recursive: true
+            });
+            await external_fs_namespaceObject.promises.writeFile(resolvedPath, `${JSON.stringify(normalized, null, 2)}\n`);
+        }
+    };
+};
+const resolveContractGateSnapshotStore = async (input)=>{
+    const { appDirectory, gateSnapshotPath, stateStore, logger } = input;
+    if (!stateStore?.module) return createFileContractGateSnapshotStore(gateSnapshotPath);
+    const builtinStore = tryResolveBuiltinSnapshotStore({
+        stateStore
+    });
+    if (builtinStore) {
+        logger?.info?.(`[telemetry.canary.autopilot] using built-in contract gate snapshot store "${builtinStore.name}"`);
+        return builtinStore;
+    }
+    const modulePath = resolveStoreModulePath(appDirectory, stateStore.module);
+    let mod;
+    try {
+        mod = require(modulePath);
+    } catch (error) {
+        throw new Error(`[telemetry.canary.autopilot] Failed to load stateStore.module "${stateStore.module}" (${modulePath}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const factory = pickStoreFactory(mod);
+    if (!factory) throw new Error(`[telemetry.canary.autopilot] stateStore.module "${stateStore.module}" does not export createContractGateSnapshotStore()`);
+    const store = await factory({
+        appDirectory,
+        gateSnapshotPath,
+        options: stateStore.options,
+        logger
+    });
+    ensureStoreShape(store, modulePath);
+    logger?.info?.(`[telemetry.canary.autopilot] using contract gate snapshot store "${store.name || modulePath}"`);
+    return store;
+};
+exports.CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION = __webpack_exports__.CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION;
+exports.DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH = __webpack_exports__.DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH;
+exports.createFileContractGateSnapshotStore = __webpack_exports__.createFileContractGateSnapshotStore;
+exports.createHttpContractGateSnapshotStore = __webpack_exports__.createHttpContractGateSnapshotStore;
+exports.resolveContractGateSnapshotPath = __webpack_exports__.resolveContractGateSnapshotPath;
+exports.resolveContractGateSnapshotStore = __webpack_exports__.resolveContractGateSnapshotStore;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION",
+    "DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH",
+    "createFileContractGateSnapshotStore",
+    "createHttpContractGateSnapshotStore",
+    "resolveContractGateSnapshotPath",
+    "resolveContractGateSnapshotStore"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/env.js

@@ -0,0 +1,58 @@
+"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__);
+const DEFAULT_ENVIRONMENT_NAME = 'development';
+const readString = (value)=>{
+    if ('string' != typeof value) return;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+};
+const parseServerRuntimeExtensionsEnv = (env = process.env)=>{
+    const modernEnv = readString(env.MODERN_ENV);
+    const nodeEnv = readString(env.NODE_ENV);
+    return {
+        modernEnv,
+        nodeEnv,
+        environmentName: modernEnv || nodeEnv || DEFAULT_ENVIRONMENT_NAME,
+        contractGatesFile: readString(env.MODERN_CONTRACT_GATES_FILE)
+    };
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    DEFAULT_ENVIRONMENT_NAME: DEFAULT_ENVIRONMENT_NAME,
+    parseServerRuntimeExtensionsEnv: parseServerRuntimeExtensionsEnv
+});
+exports.DEFAULT_ENVIRONMENT_NAME = __webpack_exports__.DEFAULT_ENVIRONMENT_NAME;
+exports.parseServerRuntimeExtensionsEnv = __webpack_exports__.parseServerRuntimeExtensionsEnv;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_ENVIRONMENT_NAME",
+    "parseServerRuntimeExtensionsEnv"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});