@bleedingdev/modern-js-prod-server 3.2.0-ultramodern.0

package/dist/cjs/libs/render/utils.js

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    injectServerData: ()=>injectServerData,
+    injectServerDataStream: ()=>injectServerDataStream
+});
+const node_namespaceObject = require("@modern-js/runtime-utils/node");
+const external_stream_namespaceObject = require("stream");
+const SERVER_DATA_MARKUP = (payload)=>`<script type="application/json" id="__MODERN_SERVER_DATA__">${payload}</script>`;
+const injectIntoHead = (content, payload)=>{
+    const scriptTag = SERVER_DATA_MARKUP(payload);
+    if (content.includes('</head>')) return content.replace('</head>', `${scriptTag}</head>`);
+    return `${scriptTag}${content}`;
+};
+const injectServerData = (content, context, options)=>{
+    const serverData = (0, node_namespaceObject.sanitizeSSRPayload)(context.serverData, {
+        unsafeHeaders: options?.unsafeHeaders,
+        treatRootAsHeaders: true
+    }).payload;
+    return injectIntoHead(content, JSON.stringify(serverData));
+};
+const injectServerDataStream = (content, context, options)=>{
+    const serverData = (0, node_namespaceObject.sanitizeSSRPayload)(context.serverData, {
+        unsafeHeaders: options?.unsafeHeaders,
+        treatRootAsHeaders: true
+    }).payload;
+    const payload = JSON.stringify(serverData);
+    let buffer = '';
+    const injector = new external_stream_namespaceObject.Transform({
+        transform (chunk, _encoding, callback) {
+            buffer += chunk.toString();
+            callback();
+        },
+        flush (callback) {
+            this.push(injectIntoHead(buffer, payload));
+            callback();
+        }
+    });
+    return content.pipe(injector);
+};
+exports.injectServerData = __webpack_exports__.injectServerData;
+exports.injectServerDataStream = __webpack_exports__.injectServerDataStream;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "injectServerData",
+    "injectServerDataStream"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/libs/runtimeFallbackWorkerLane.js

@@ -0,0 +1,167 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    DEFAULT_RUNTIME_FALLBACK_WORKER_TIMEOUT_MS: ()=>DEFAULT_RUNTIME_FALLBACK_WORKER_TIMEOUT_MS,
+    persistRuntimeFallbackContractGateInWorker: ()=>persistRuntimeFallbackContractGateInWorker
+});
+const external_node_worker_threads_namespaceObject = require("node:worker_threads");
+const DEFAULT_RUNTIME_FALLBACK_WORKER_TIMEOUT_MS = 250;
+const WORKER_SCRIPT = `
+const { parentPort, workerData } = require('node:worker_threads');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const isRecord = value => typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const main = async () => {
+  const now = Date.now();
+  const snapshotPath = String(workerData.snapshotPath || '');
+  const gateName = String(workerData.gateName || 'runtime-mf-fallback-health');
+  const failureHoldMsRaw = Number(workerData.failureHoldMs);
+  const failureHoldMs = Number.isFinite(failureHoldMsRaw) && failureHoldMsRaw > 0
+    ? Math.floor(failureHoldMsRaw)
+    : 300000;
+  const schemaVersionRaw = Number(workerData.schemaVersion);
+  const schemaVersion = Number.isFinite(schemaVersionRaw) ? schemaVersionRaw : 1;
+  const payload = isRecord(workerData.payload) ? workerData.payload : {};
+
+  let snapshot = {
+    schemaVersion,
+    updatedAt: now,
+    gates: {},
+  };
+
+  try {
+    const raw = await fs.readFile(snapshotPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (isRecord(parsed)) {
+      snapshot = {
+        schemaVersion: typeof parsed.schemaVersion === 'number' ? parsed.schemaVersion : schemaVersion,
+        updatedAt: typeof parsed.updatedAt === 'number' ? parsed.updatedAt : now,
+        gates: isRecord(parsed.gates) ? parsed.gates : {},
+      };
+    }
+  } catch (_error) {
+    // start from empty snapshot when file does not exist or cannot be parsed
+  }
+
+  const reason = typeof payload.reason === 'string' ? payload.reason : 'runtime_fallback';
+  const phase = typeof payload.phase === 'string' ? payload.phase : 'unknown';
+  const appName = typeof payload.appName === 'string' ? payload.appName : 'unknown';
+  const entry = typeof payload.entry === 'string' ? payload.entry : undefined;
+
+  snapshot.schemaVersion = schemaVersion;
+  snapshot.updatedAt = now;
+  snapshot.gates = isRecord(snapshot.gates) ? snapshot.gates : {};
+  snapshot.gates[gateName] = {
+    passed: false,
+    reason: \`runtime_fallback:\${reason} phase=\${phase} app=\${appName}\${entry ? \` entry=\${entry}\` : ''}\`,
+    updatedAt: now,
+    expiresAt: now + failureHoldMs,
+    source: 'runtime-mf-fallback-signal',
+    metadata: payload,
+  };
+
+  await fs.mkdir(path.dirname(snapshotPath), { recursive: true });
+  await fs.writeFile(snapshotPath, JSON.stringify(snapshot, null, 2) + '\\n');
+
+  return {
+    ok: true,
+  };
+};
+
+main()
+  .then(result => {
+    parentPort.postMessage(result);
+  })
+  .catch(error => {
+    parentPort.postMessage({
+      ok: false,
+      error: error && error.message ? error.message : String(error),
+    });
+  });
+`;
+const normalizeErrorMessage = (error)=>{
+    if (error instanceof Error) return error.message;
+    return String(error);
+};
+const persistRuntimeFallbackContractGateInWorker = async (payload, config)=>{
+    if (!config.enabled) return {
+        ok: false,
+        error: 'worker_lane_disabled'
+    };
+    return new Promise((resolve)=>{
+        let settled = false;
+        const worker = new external_node_worker_threads_namespaceObject.Worker(WORKER_SCRIPT, {
+            eval: true,
+            workerData: payload
+        });
+        const finish = (result)=>{
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeoutId);
+            worker.terminate().catch(()=>{});
+            resolve(result);
+        };
+        const timeoutId = setTimeout(()=>{
+            finish({
+                ok: false,
+                error: 'worker_lane_timeout'
+            });
+        }, Math.max(25, config.timeoutMs));
+        worker.once('message', (message)=>{
+            if (message && 'object' == typeof message && true === message.ok) return void finish({
+                ok: true
+            });
+            finish({
+                ok: false,
+                error: message && 'object' == typeof message && 'error' in message ? String(message.error || 'worker_error') : 'worker_error'
+            });
+        });
+        worker.once('error', (error)=>{
+            finish({
+                ok: false,
+                error: normalizeErrorMessage(error)
+            });
+        });
+        worker.once('exit', (code)=>{
+            if (settled || 0 === code) return;
+            finish({
+                ok: false,
+                error: `worker_lane_exit_${String(code)}`
+            });
+        });
+    });
+};
+exports.DEFAULT_RUNTIME_FALLBACK_WORKER_TIMEOUT_MS = __webpack_exports__.DEFAULT_RUNTIME_FALLBACK_WORKER_TIMEOUT_MS;
+exports.persistRuntimeFallbackContractGateInWorker = __webpack_exports__.persistRuntimeFallbackContractGateInWorker;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_RUNTIME_FALLBACK_WORKER_TIMEOUT_MS",
+    "persistRuntimeFallbackContractGateInWorker"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/libs/telemetry.js

@@ -0,0 +1,87 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT: ()=>server_core_namespaceObject.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT,
+    DEFAULT_RUNTIME_STATUS_ENDPOINT: ()=>server_core_namespaceObject.DEFAULT_RUNTIME_STATUS_ENDPOINT,
+    TelemetryCanaryOrchestrator: ()=>server_core_namespaceObject.TelemetryCanaryOrchestrator,
+    TelemetryRegistry: ()=>server_core_namespaceObject.TelemetryRegistry,
+    TelemetryStartupHealthError: ()=>server_core_namespaceObject.TelemetryStartupHealthError,
+    createOtlpTelemetryExporter: ()=>server_core_namespaceObject.createOtlpTelemetryExporter,
+    createRuntimeFallbackSignalRuntimeState: ()=>server_core_namespaceObject.createRuntimeFallbackSignalRuntimeState,
+    createRuntimeSignalError: ()=>server_core_namespaceObject.createRuntimeSignalError,
+    createTelemetryAwareMetrics: ()=>server_core_namespaceObject.createTelemetryAwareMetrics,
+    createVictoriaMetricsTelemetryExporter: ()=>server_core_namespaceObject.createVictoriaMetricsTelemetryExporter,
+    enforceRuntimeFallbackSignalAuthToken: ()=>server_core_namespaceObject.enforceRuntimeFallbackSignalAuthToken,
+    enforceRuntimeFallbackSignalTrustPolicy: ()=>server_core_namespaceObject.enforceRuntimeFallbackSignalTrustPolicy,
+    getRuntimeSignalErrorStatusCode: ()=>server_core_namespaceObject.getRuntimeSignalErrorStatusCode,
+    hasEnabledTelemetryExporters: ()=>server_core_namespaceObject.hasEnabledTelemetryExporters,
+    normalizeRuntimeFallbackSignalAuthConfig: ()=>server_core_namespaceObject.normalizeRuntimeFallbackSignalAuthConfig,
+    normalizeRuntimeFallbackTrustPolicy: ()=>server_core_namespaceObject.normalizeRuntimeFallbackTrustPolicy,
+    parseRuntimeFallbackSignalPayloadFromRawBody: ()=>server_core_namespaceObject.parseRuntimeFallbackSignalPayloadFromRawBody,
+    resolveRuntimeFallbackSignalEndpoint: ()=>server_core_namespaceObject.resolveRuntimeFallbackSignalEndpoint
+});
+const server_core_namespaceObject = require("@modern-js/server-core");
+exports.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = __webpack_exports__.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT;
+exports.DEFAULT_RUNTIME_STATUS_ENDPOINT = __webpack_exports__.DEFAULT_RUNTIME_STATUS_ENDPOINT;
+exports.TelemetryCanaryOrchestrator = __webpack_exports__.TelemetryCanaryOrchestrator;
+exports.TelemetryRegistry = __webpack_exports__.TelemetryRegistry;
+exports.TelemetryStartupHealthError = __webpack_exports__.TelemetryStartupHealthError;
+exports.createOtlpTelemetryExporter = __webpack_exports__.createOtlpTelemetryExporter;
+exports.createRuntimeFallbackSignalRuntimeState = __webpack_exports__.createRuntimeFallbackSignalRuntimeState;
+exports.createRuntimeSignalError = __webpack_exports__.createRuntimeSignalError;
+exports.createTelemetryAwareMetrics = __webpack_exports__.createTelemetryAwareMetrics;
+exports.createVictoriaMetricsTelemetryExporter = __webpack_exports__.createVictoriaMetricsTelemetryExporter;
+exports.enforceRuntimeFallbackSignalAuthToken = __webpack_exports__.enforceRuntimeFallbackSignalAuthToken;
+exports.enforceRuntimeFallbackSignalTrustPolicy = __webpack_exports__.enforceRuntimeFallbackSignalTrustPolicy;
+exports.getRuntimeSignalErrorStatusCode = __webpack_exports__.getRuntimeSignalErrorStatusCode;
+exports.hasEnabledTelemetryExporters = __webpack_exports__.hasEnabledTelemetryExporters;
+exports.normalizeRuntimeFallbackSignalAuthConfig = __webpack_exports__.normalizeRuntimeFallbackSignalAuthConfig;
+exports.normalizeRuntimeFallbackTrustPolicy = __webpack_exports__.normalizeRuntimeFallbackTrustPolicy;
+exports.parseRuntimeFallbackSignalPayloadFromRawBody = __webpack_exports__.parseRuntimeFallbackSignalPayloadFromRawBody;
+exports.resolveRuntimeFallbackSignalEndpoint = __webpack_exports__.resolveRuntimeFallbackSignalEndpoint;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+    "DEFAULT_RUNTIME_STATUS_ENDPOINT",
+    "TelemetryCanaryOrchestrator",
+    "TelemetryRegistry",
+    "TelemetryStartupHealthError",
+    "createOtlpTelemetryExporter",
+    "createRuntimeFallbackSignalRuntimeState",
+    "createRuntimeSignalError",
+    "createTelemetryAwareMetrics",
+    "createVictoriaMetricsTelemetryExporter",
+    "enforceRuntimeFallbackSignalAuthToken",
+    "enforceRuntimeFallbackSignalTrustPolicy",
+    "getRuntimeSignalErrorStatusCode",
+    "hasEnabledTelemetryExporters",
+    "normalizeRuntimeFallbackSignalAuthConfig",
+    "normalizeRuntimeFallbackTrustPolicy",
+    "parseRuntimeFallbackSignalPayloadFromRawBody",
+    "resolveRuntimeFallbackSignalEndpoint"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/netlify.js

@@ -0,0 +1,56 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    createNetlifyFunction: ()=>createNetlifyFunction
+});
+const server_core_namespaceObject = require("@modern-js/server-core");
+const node_namespaceObject = require("@modern-js/server-core/node");
+const external_apply_js_namespaceObject = require("./apply.js");
+const createNetlifyFunction = async (options)=>{
+    await (0, node_namespaceObject.loadServerEnv)(options);
+    const serverBaseOptions = options;
+    const serverCliConfig = (0, node_namespaceObject.loadServerCliConfig)(options.pwd, options.config);
+    if (serverCliConfig) options.config = serverCliConfig;
+    const serverRuntimeConfig = await (0, node_namespaceObject.loadServerRuntimeConfig)(options.serverConfigPath);
+    if (serverRuntimeConfig) {
+        serverBaseOptions.serverConfig = serverRuntimeConfig;
+        serverBaseOptions.plugins = [
+            ...serverRuntimeConfig.plugins || [],
+            ...options.plugins || []
+        ];
+    }
+    const server = (0, server_core_namespaceObject.createServerBase)(serverBaseOptions);
+    await (0, external_apply_js_namespaceObject.applyPlugins)(server, options);
+    await server.init();
+    return (request, context)=>server.handle(request, context);
+};
+exports.createNetlifyFunction = __webpack_exports__.createNetlifyFunction;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNetlifyFunction"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});