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

package/dist/cjs/index.js

@@ -0,0 +1,247 @@
+"use strict";
+var __webpack_modules__ = {
+    "./constants" (module) {
+        module.exports = require("./constants.js");
+    },
+    "./context" (module) {
+        module.exports = require("./context.js");
+    },
+    "./helper" (module) {
+        module.exports = require("./helper.js");
+    },
+    "./plugins" (module) {
+        module.exports = require("./plugins/index.js");
+    },
+    "./serverBase" (module) {
+        module.exports = require("./serverBase.js");
+    },
+    "./types/config" (module) {
+        module.exports = require("./types/config/index.js");
+    },
+    "./types/plugins" (module) {
+        module.exports = require("./types/plugins/index.js");
+    },
+    "./types/render" (module) {
+        module.exports = require("./types/render.js");
+    },
+    "./types/requestHandler" (module) {
+        module.exports = require("./types/requestHandler.js");
+    },
+    "./utils" (module) {
+        module.exports = require("./utils/index.js");
+    },
+    "./utils/publicDir" (module) {
+        module.exports = require("./utils/publicDir.js");
+    },
+    hono (module) {
+        module.exports = require("hono");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+        AGGRED_DIR: ()=>_constants__rspack_import_1.AGGRED_DIR,
+        ErrorDigest: ()=>_utils__rspack_import_10.ErrorDigest,
+        Hono: ()=>hono__rspack_import_0.Hono,
+        createErrorHtml: ()=>_utils__rspack_import_10.createErrorHtml,
+        createServerBase: ()=>_serverBase__rspack_import_5.createServerBase,
+        getLoaderCtx: ()=>_helper__rspack_import_3.getLoaderCtx,
+        getPublicDirConfig: ()=>_utils_publicDir__rspack_import_11.getPublicDirConfig,
+        getPublicDirPatterns: ()=>_utils_publicDir__rspack_import_11.getPublicDirPatterns,
+        getPublicDirRoutePrefixes: ()=>_utils_publicDir__rspack_import_11.getPublicDirRoutePrefixes,
+        normalizePublicDir: ()=>_utils_publicDir__rspack_import_11.normalizePublicDir,
+        normalizePublicDirPath: ()=>_utils_publicDir__rspack_import_11.normalizePublicDirPath,
+        onError: ()=>_utils__rspack_import_10.onError,
+        resolvePublicDirPaths: ()=>_utils_publicDir__rspack_import_11.resolvePublicDirPaths,
+        run: ()=>_context__rspack_import_2.run,
+        useHonoContext: ()=>_context__rspack_import_2.useHonoContext
+    });
+    var hono__rspack_import_0 = __webpack_require__("hono");
+    var _constants__rspack_import_1 = __webpack_require__("./constants");
+    var _context__rspack_import_2 = __webpack_require__("./context");
+    var _helper__rspack_import_3 = __webpack_require__("./helper");
+    var _plugins__rspack_import_4 = __webpack_require__("./plugins");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _plugins__rspack_import_4)if ([
+        "Hono",
+        "createErrorHtml",
+        "useHonoContext",
+        "normalizePublicDir",
+        "createServerBase",
+        "resolvePublicDirPaths",
+        "default",
+        "normalizePublicDirPath",
+        "onError",
+        "ErrorDigest",
+        "getPublicDirConfig",
+        "getPublicDirPatterns",
+        "getPublicDirRoutePrefixes",
+        "getLoaderCtx",
+        "run",
+        "AGGRED_DIR"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_plugins__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _serverBase__rspack_import_5 = __webpack_require__("./serverBase");
+    var _types_config__rspack_import_6 = __webpack_require__("./types/config");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types_config__rspack_import_6)if ([
+        "Hono",
+        "createErrorHtml",
+        "useHonoContext",
+        "normalizePublicDir",
+        "createServerBase",
+        "resolvePublicDirPaths",
+        "default",
+        "normalizePublicDirPath",
+        "onError",
+        "ErrorDigest",
+        "getPublicDirConfig",
+        "getPublicDirPatterns",
+        "getPublicDirRoutePrefixes",
+        "getLoaderCtx",
+        "run",
+        "AGGRED_DIR"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types_config__rspack_import_6[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _types_plugins__rspack_import_7 = __webpack_require__("./types/plugins");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types_plugins__rspack_import_7)if ([
+        "Hono",
+        "createErrorHtml",
+        "useHonoContext",
+        "normalizePublicDir",
+        "createServerBase",
+        "resolvePublicDirPaths",
+        "default",
+        "normalizePublicDirPath",
+        "onError",
+        "ErrorDigest",
+        "getPublicDirConfig",
+        "getPublicDirPatterns",
+        "getPublicDirRoutePrefixes",
+        "getLoaderCtx",
+        "run",
+        "AGGRED_DIR"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types_plugins__rspack_import_7[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _types_render__rspack_import_8 = __webpack_require__("./types/render");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types_render__rspack_import_8)if ([
+        "Hono",
+        "createErrorHtml",
+        "useHonoContext",
+        "normalizePublicDir",
+        "createServerBase",
+        "resolvePublicDirPaths",
+        "default",
+        "normalizePublicDirPath",
+        "onError",
+        "ErrorDigest",
+        "getPublicDirConfig",
+        "getPublicDirPatterns",
+        "getPublicDirRoutePrefixes",
+        "getLoaderCtx",
+        "run",
+        "AGGRED_DIR"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types_render__rspack_import_8[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _types_requestHandler__rspack_import_9 = __webpack_require__("./types/requestHandler");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types_requestHandler__rspack_import_9)if ([
+        "Hono",
+        "createErrorHtml",
+        "useHonoContext",
+        "normalizePublicDir",
+        "createServerBase",
+        "resolvePublicDirPaths",
+        "default",
+        "normalizePublicDirPath",
+        "onError",
+        "ErrorDigest",
+        "getPublicDirConfig",
+        "getPublicDirPatterns",
+        "getPublicDirRoutePrefixes",
+        "getLoaderCtx",
+        "run",
+        "AGGRED_DIR"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types_requestHandler__rspack_import_9[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _utils__rspack_import_10 = __webpack_require__("./utils");
+    var _utils_publicDir__rspack_import_11 = __webpack_require__("./utils/publicDir");
+})();
+exports.AGGRED_DIR = __webpack_exports__.AGGRED_DIR;
+exports.ErrorDigest = __webpack_exports__.ErrorDigest;
+exports.Hono = __webpack_exports__.Hono;
+exports.createErrorHtml = __webpack_exports__.createErrorHtml;
+exports.createServerBase = __webpack_exports__.createServerBase;
+exports.getLoaderCtx = __webpack_exports__.getLoaderCtx;
+exports.getPublicDirConfig = __webpack_exports__.getPublicDirConfig;
+exports.getPublicDirPatterns = __webpack_exports__.getPublicDirPatterns;
+exports.getPublicDirRoutePrefixes = __webpack_exports__.getPublicDirRoutePrefixes;
+exports.normalizePublicDir = __webpack_exports__.normalizePublicDir;
+exports.normalizePublicDirPath = __webpack_exports__.normalizePublicDirPath;
+exports.onError = __webpack_exports__.onError;
+exports.resolvePublicDirPaths = __webpack_exports__.resolvePublicDirPaths;
+exports.run = __webpack_exports__.run;
+exports.useHonoContext = __webpack_exports__.useHonoContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AGGRED_DIR",
+    "ErrorDigest",
+    "Hono",
+    "createErrorHtml",
+    "createServerBase",
+    "getLoaderCtx",
+    "getPublicDirConfig",
+    "getPublicDirPatterns",
+    "getPublicDirRoutePrefixes",
+    "normalizePublicDir",
+    "normalizePublicDirPath",
+    "onError",
+    "resolvePublicDirPaths",
+    "run",
+    "useHonoContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/compat/hooks.js

@@ -0,0 +1,80 @@
+"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__, {
+    getHookRunners: ()=>getHookRunners,
+    handleSetupResult: ()=>handleSetupResult,
+    transformHookRunner: ()=>transformHookRunner
+});
+function getHookRunners(context) {
+    const { hooks } = context;
+    return {
+        config: (params)=>hooks.modifyConfig.call(params),
+        prepare: ()=>hooks.onPrepare.call(),
+        reset: (params)=>hooks.onReset.call(params),
+        fallback: (input)=>hooks.fallback.call(input),
+        prepareWebServer: (input)=>hooks.prepareWebServer.call(input),
+        prepareApiServer: (input)=>hooks.prepareApiServer.call(input),
+        afterMatch: (ctx)=>hooks.afterMatch.call(ctx),
+        afterRender: (ctx)=>hooks.afterRender.call(ctx),
+        afterStreamingRender: (ctx)=>hooks.afterStreamingRender.call(ctx)
+    };
+}
+function transformHookRunner(hookRunnerName) {
+    switch(hookRunnerName){
+        case 'config':
+            return 'modifyConfig';
+        case 'prepare':
+            return 'onPrepare';
+        case 'reset':
+            return 'onReset';
+        default:
+            return hookRunnerName;
+    }
+}
+function handleSetupResult(setupResult, api) {
+    if (!setupResult) return;
+    Object.keys(setupResult).forEach((key)=>{
+        const fn = setupResult[key];
+        if ('function' == typeof fn) {
+            const newAPI = transformHookRunner(key);
+            if (api[newAPI]) api[newAPI]((...params)=>{
+                const res = fn(...params);
+                return res;
+            });
+        }
+    });
+}
+exports.getHookRunners = __webpack_exports__.getHookRunners;
+exports.handleSetupResult = __webpack_exports__.handleSetupResult;
+exports.transformHookRunner = __webpack_exports__.transformHookRunner;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getHookRunners",
+    "handleSetupResult",
+    "transformHookRunner"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/compat/index.js

@@ -0,0 +1,64 @@
+"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__, {
+    compatPlugin: ()=>compatPlugin,
+    handleSetupResult: ()=>external_hooks_js_namespaceObject.handleSetupResult
+});
+const plugin_namespaceObject = require("@modern-js/plugin");
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const compatPlugin = ()=>({
+        name: '@modern-js/server-compat',
+        registryHooks: {
+            fallback: (0, plugin_namespaceObject.createAsyncHook)(),
+            prepareWebServer: (0, plugin_namespaceObject.createAsyncPipelineHook)(),
+            prepareApiServer: (0, plugin_namespaceObject.createAsyncPipelineHook)(),
+            afterMatch: (0, plugin_namespaceObject.createAsyncPipelineHook)(),
+            afterRender: (0, plugin_namespaceObject.createAsyncPipelineHook)(),
+            afterStreamingRender: (0, plugin_namespaceObject.createAsyncPipelineHook)()
+        },
+        _registryApi: (getServerContext, updateServerContext)=>{
+            const getInternalContext = ()=>getServerContext()._internalContext;
+            return {
+                useConfigContext: ()=>getInternalContext().config,
+                useAppContext: ()=>{
+                    const { _internalContext, ...serverContext } = getServerContext();
+                    return serverContext;
+                },
+                setAppContext: (context)=>updateServerContext(context),
+                useHookRunners: ()=>(0, external_hooks_js_namespaceObject.getHookRunners)(getInternalContext())
+            };
+        },
+        setup: ()=>{}
+    });
+exports.compatPlugin = __webpack_exports__.compatPlugin;
+exports.handleSetupResult = __webpack_exports__.handleSetupResult;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "compatPlugin",
+    "handleSetupResult"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/contractGateAutopilot.js

@@ -0,0 +1,158 @@
+"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__, {
+    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
+});