@bleedingdev/modern-js-runtime-extensions 3.8.3-ultramodern.2

package/dist/esm-node/rendererHead.mjs

@@ -0,0 +1,163 @@
+import "node:module";
+export * from "./helmetCompat.mjs";
+const MARKER_ATTRIBUTE = 'data-modern-helmet';
+const MARKER_PREFIX = `<template ${MARKER_ATTRIBUTE}="`;
+const MARKER_SUFFIX = '"></template>';
+const RECORD_ID_WIDTH = 12;
+const MARKER_LENGTH = MARKER_PREFIX.length + 1 + 36 + RECORD_ID_WIDTH + MARKER_SUFFIX.length;
+const HEAD_STATE = Symbol('modern.rendererHead');
+const getState = (context)=>{
+    const headContext = context;
+    let state = headContext[HEAD_STATE];
+    if (void 0 === state) {
+        state = {
+            publishedRecords: []
+        };
+        Object.defineProperty(headContext, HEAD_STATE, {
+            value: state
+        });
+    }
+    return state;
+};
+const formatId = (value)=>value.toString(36).padStart(RECORD_ID_WIDTH, '0');
+const createToken = (transaction)=>{
+    const token = `h${transaction.nonce}${formatId(transaction.nextRecordId)}`;
+    transaction.nextRecordId += 1;
+    return token;
+};
+const beginHeadRender = (context)=>{
+    const state = getState(context);
+    state.transaction = {
+        recordsByToken: new Map(),
+        committedRecords: [],
+        committedTokens: new Set(),
+        nextRecordId: 0,
+        nonce: globalThis.crypto.randomUUID(),
+        previousRecords: state.publishedRecords,
+        sealed: false
+    };
+    state.publish?.([]);
+};
+const collectHeadRecord = (context, createRecord, publish)=>{
+    const state = getState(context);
+    const transaction = state.transaction;
+    if (void 0 === transaction) return;
+    const hadPublisher = void 0 !== state.publish;
+    state.publish = (records)=>publish(records);
+    if (!hadPublisher) state.publish([]);
+    if (transaction.sealed) return null;
+    const token = createToken(transaction);
+    transaction.recordsByToken.set(token, createRecord());
+    return {
+        [MARKER_ATTRIBUTE]: token
+    };
+};
+const collectHeadState = (context, createRecord, derive, target)=>collectHeadRecord(context, createRecord, (records)=>{
+        target.helmet = derive(records);
+    });
+const consumeMarkers = (context, html)=>{
+    const transaction = getState(context).transaction;
+    if (void 0 === transaction) return html;
+    let cursor = 0;
+    let stripped = '';
+    while(cursor < html.length){
+        const start = html.indexOf(MARKER_PREFIX, cursor);
+        if (-1 === start) {
+            stripped += html.slice(cursor);
+            break;
+        }
+        const tokenStart = start + MARKER_PREFIX.length;
+        const end = html.indexOf(MARKER_SUFFIX, tokenStart);
+        if (-1 === end) {
+            stripped += html.slice(cursor);
+            break;
+        }
+        const token = html.slice(tokenStart, end);
+        if (transaction.recordsByToken.has(token)) {
+            stripped += html.slice(cursor, start);
+            if (!transaction.sealed && !transaction.committedTokens.has(token)) {
+                transaction.committedTokens.add(token);
+                transaction.committedRecords.push(transaction.recordsByToken.get(token));
+            }
+        } else stripped += html.slice(cursor, end + MARKER_SUFFIX.length);
+        cursor = end + MARKER_SUFFIX.length;
+    }
+    return stripped;
+};
+const rendererHead_publish = (context)=>{
+    const state = getState(context);
+    const records = state.transaction?.committedRecords ?? [];
+    state.publishedRecords = records;
+    state.publish?.(records);
+};
+const publishHeadRender = (context)=>{
+    const transaction = getState(context).transaction;
+    if (void 0 !== transaction) {
+        transaction.sealed = true;
+        rendererHead_publish(context);
+    }
+};
+const finishHeadRender = (context)=>{
+    const state = getState(context);
+    if (void 0 !== state.transaction) {
+        if (!state.transaction.sealed) rendererHead_publish(context);
+        state.transaction = void 0;
+    }
+};
+const completeHeadRender = (context, html)=>{
+    const stripped = consumeMarkers(context, html);
+    finishHeadRender(context);
+    return stripped;
+};
+const abortHeadRender = (context)=>{
+    const state = getState(context);
+    const transaction = state.transaction;
+    if (void 0 !== transaction) {
+        state.publishedRecords = transaction.previousRecords;
+        state.publish?.(transaction.previousRecords);
+        state.transaction = void 0;
+    }
+};
+const findCarryStart = (input)=>{
+    const windowStart = Math.max(0, input.length - MARKER_LENGTH + 1);
+    const markerStart = input.lastIndexOf(MARKER_PREFIX);
+    if (markerStart >= windowStart && input.length - markerStart < MARKER_LENGTH) return markerStart;
+    const maxPrefixLength = Math.min(MARKER_PREFIX.length - 1, input.length);
+    for(let length = maxPrefixLength; length > 0; length -= 1)if (MARKER_PREFIX.startsWith(input.slice(-length))) return input.length - length;
+    return input.length;
+};
+const createHeadChunkProcessor = (context)=>{
+    let carry = '';
+    return {
+        push (chunk) {
+            const input = carry + chunk;
+            const carryStart = findCarryStart(input);
+            const output = consumeMarkers(context, input.slice(0, carryStart));
+            carry = input.slice(carryStart);
+            return output;
+        },
+        finish (chunk = '') {
+            const output = completeHeadRender(context, carry + chunk);
+            carry = '';
+            return output;
+        }
+    };
+};
+const createWebHeadMarkerStripper = (context)=>{
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const processor = createHeadChunkProcessor(context);
+    return new TransformStream({
+        transform (chunk, controller) {
+            const output = processor.push(decoder.decode(chunk, {
+                stream: true
+            }));
+            if (output) controller.enqueue(encoder.encode(output));
+        },
+        flush (controller) {
+            const output = processor.finish(decoder.decode());
+            if (output) controller.enqueue(encoder.encode(output));
+        }
+    });
+};
+export { abortHeadRender, beginHeadRender, collectHeadRecord, collectHeadState, completeHeadRender, createHeadChunkProcessor, createWebHeadMarkerStripper, finishHeadRender, publishHeadRender };

package/dist/esm-node/rscHtmlStream.mjs

@@ -0,0 +1,87 @@
+import "node:module";
+const encoder = new TextEncoder();
+const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
+const closingTagsPrefixPattern = /(?:<\/body>\s*(?:<\/html>\s*|<\/h(?:t(?:m(?:l>?)?)?)?|<\/?|<)?|<\/b(?:o(?:d(?:y>?)?)?)?|<\/?|<[^>]*)$/i;
+const RSC_HTML_CLOSING_TAIL_LIMIT = 8192;
+function injectRSCPayload(rscStream, { injectClosingTags = true } = {}) {
+    const decoder = new TextDecoder();
+    let retainedTail = '';
+    let committedClosingBody = false;
+    let committedHtmlClose = false;
+    let committedProbe = '';
+    let flightPromise;
+    const startFlight = (controller)=>{
+        if (!flightPromise) {
+            flightPromise = writeRSCStream(rscStream, controller);
+            flightPromise.catch((error)=>controller.error(error));
+        }
+        return flightPromise;
+    };
+    const enqueueHtml = (value, controller)=>{
+        if (value) controller.enqueue(encoder.encode(value));
+    };
+    const processHtml = async (value, controller)=>{
+        if (!value) return;
+        if (committedClosingBody) {
+            const probe = committedProbe + value;
+            committedHtmlClose ||= /<\/html>/i.test(probe);
+            committedProbe = probe.slice(-6);
+            enqueueHtml(value, controller);
+            return;
+        }
+        const html = retainedTail + value;
+        retainedTail = '';
+        const suffix = html.match(closingTagsPrefixPattern)?.[0] ?? '';
+        const prefix = suffix ? html.slice(0, -suffix.length) : html;
+        enqueueHtml(prefix, controller);
+        if (!suffix) return void startFlight(controller);
+        if (suffix.length <= RSC_HTML_CLOSING_TAIL_LIMIT) {
+            retainedTail = suffix;
+            return;
+        }
+        await startFlight(controller);
+        if (/<\/body>/i.test(suffix)) {
+            committedClosingBody = true;
+            committedHtmlClose = /<\/html>/i.test(suffix);
+            committedProbe = suffix.slice(-6);
+        }
+        enqueueHtml(suffix, controller);
+    };
+    return new TransformStream({
+        async transform (chunk, controller) {
+            await processHtml(decoder.decode(chunk, {
+                stream: true
+            }), controller);
+        },
+        async flush (controller) {
+            await processHtml(decoder.decode(), controller);
+            await startFlight(controller);
+            const retainedClosingTags = closingTagsPattern.test(retainedTail);
+            enqueueHtml(retainedTail, controller);
+            if (!injectClosingTags) return;
+            if (committedClosingBody) {
+                if (!committedHtmlClose) enqueueHtml('</html>', controller);
+            } else if (!retainedClosingTags) enqueueHtml('</body></html>', controller);
+        }
+    });
+}
+async function writeRSCStream(rscStream, controller) {
+    const decoder = new TextDecoder('utf-8', {
+        fatal: true
+    });
+    for await (const chunk of rscStream)try {
+        writeChunk(JSON.stringify(decoder.decode(chunk, {
+            stream: true
+        })), controller);
+    } catch  {
+        const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
+        writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller);
+    }
+    const remaining = decoder.decode();
+    if (remaining) writeChunk(JSON.stringify(remaining), controller);
+}
+function writeChunk(chunk, controller) {
+    const script = `(self.__FLIGHT_DATA||=[]).push(${chunk})`;
+    controller.enqueue(encoder.encode(`<script>${script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1')}</script>`));
+}
+export { RSC_HTML_CLOSING_TAIL_LIMIT, injectRSCPayload };

package/dist/esm-node/safeFailure.mjs

@@ -0,0 +1,79 @@
+import "node:module";
+const SAFE_FAILURE_MESSAGES = {
+    500: 'Internal Server Error',
+    503: 'Service Unavailable'
+};
+const SAFE_FAILURE_CODES = {
+    500: 'INTERNAL_SERVER_ERROR',
+    503: 'SERVICE_UNAVAILABLE'
+};
+const readErrorProperty = (error, key)=>{
+    if ('object' != typeof error || null === error) return;
+    try {
+        return error[key];
+    } catch  {
+        return;
+    }
+};
+const normalizeFailureStatus = (value)=>'number' == typeof value && Number.isInteger(value) && value >= 400 && value <= 599 ? value : void 0;
+const normalizeDelaySeconds = (value)=>{
+    if ('number' == typeof value) {
+        const seconds = Math.ceil(value);
+        return Number.isFinite(value) && value >= 0 && Number.isSafeInteger(seconds) ? String(seconds) : void 0;
+    }
+    if ('string' == typeof value) {
+        const trimmed = value.trim();
+        if (!/^\d+$/u.test(trimmed)) return;
+        const seconds = Number(trimmed);
+        return Number.isSafeInteger(seconds) ? String(seconds) : void 0;
+    }
+};
+const normalizeHttpDate = (value)=>{
+    try {
+        if (value instanceof Date) {
+            const timestamp = Date.prototype.getTime.call(value);
+            return Number.isFinite(timestamp) ? new Date(timestamp).toUTCString() : void 0;
+        }
+        if ('string' == typeof value) {
+            const trimmed = value.trim();
+            const timestamp = Date.parse(trimmed);
+            if (Number.isFinite(timestamp)) {
+                const canonical = new Date(timestamp).toUTCString();
+                return canonical === trimmed ? canonical : void 0;
+            }
+        }
+    } catch  {}
+};
+const normalizeRetryAfter = (value)=>normalizeDelaySeconds(value) ?? normalizeHttpDate(value);
+const getSafeFailureStatus = (error)=>normalizeFailureStatus(readErrorProperty(error, 'status')) ?? normalizeFailureStatus(readErrorProperty(error, 'statusCode')) ?? 500;
+const createSafeFailureHttpResult = (error)=>{
+    const status = getSafeFailureStatus(error);
+    const retryAfterMs = readErrorProperty(error, 'retryAfterMs');
+    const retryAfter = 503 === status ? normalizeRetryAfter(readErrorProperty(error, 'retryAfter')) ?? normalizeRetryAfter(readErrorProperty(error, 'retryAfterSeconds')) ?? normalizeRetryAfter('number' == typeof retryAfterMs ? retryAfterMs / 1000 : void 0) : void 0;
+    return {
+        status,
+        body: {
+            success: false,
+            error: {
+                code: SAFE_FAILURE_CODES[status] ?? 'REQUEST_FAILED',
+                message: SAFE_FAILURE_MESSAGES[status] ?? 'Request failed',
+                status
+            }
+        },
+        headers: {
+            'content-type': 'application/json; charset=utf-8',
+            ...void 0 === retryAfter ? {} : {
+                'Retry-After': retryAfter
+            }
+        }
+    };
+};
+const createSafeJsonFailureResponse = (error)=>{
+    const result = createSafeFailureHttpResult(error);
+    return new Response(JSON.stringify(result.body), {
+        status: result.status,
+        headers: result.headers
+    });
+};
+const createSafeFailureResponse = createSafeJsonFailureResponse;
+export { createSafeFailureHttpResult, createSafeFailureResponse, createSafeJsonFailureResponse, getSafeFailureStatus };

package/dist/esm-node/shellStream.mjs

@@ -0,0 +1,39 @@
+import "node:module";
+import { abortHeadRender, createHeadChunkProcessor } from "./rendererHead.mjs";
+const MISSING_SHELL_MARKER_ERROR = 'React SSR stream ended before the shell marker';
+const createConservingWebShellStream = (source, context, marker, onMissingMarker)=>{
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const headProcessor = createHeadChunkProcessor(context);
+    let markerCarry = '';
+    let markerFound = false;
+    const observeMarker = (chunk)=>{
+        if (markerFound) return;
+        const candidate = markerCarry + chunk;
+        markerFound = candidate.includes(marker);
+        markerCarry = markerFound ? '' : candidate.slice(-(marker.length - 1));
+    };
+    return source.pipeThrough(new TransformStream({
+        transform (chunk, controller) {
+            const decoded = decoder.decode(chunk, {
+                stream: true
+            });
+            observeMarker(decoded);
+            const output = headProcessor.push(decoded);
+            if (output) controller.enqueue(encoder.encode(output));
+        },
+        flush (controller) {
+            const decoded = decoder.decode();
+            observeMarker(decoded);
+            if (!markerFound) {
+                abortHeadRender(context);
+                const error = new Error(MISSING_SHELL_MARKER_ERROR);
+                onMissingMarker?.(error);
+                throw error;
+            }
+            const output = headProcessor.finish(decoded);
+            if (output) controller.enqueue(encoder.encode(output));
+        }
+    }));
+};
+export { createConservingWebShellStream };

package/dist/types/helmetCompat.d.ts

@@ -0,0 +1,75 @@
+type HeadTag = Record<string, unknown>;
+type PriorityTagName = 'link' | 'meta' | 'script';
+type ElementFactory<Element> = {
+    createElement: (...args: never[]) => Element;
+};
+type ReactAdapter<Element, Child> = ElementFactory<Element> & {
+    Children: {
+        forEach: (children: Child | undefined, visit: (child: unknown) => void) => void;
+        toArray: (children: Child | undefined) => unknown[];
+    };
+    Fragment: unknown;
+    isValidElement: (value: unknown) => boolean;
+};
+type HeadDatum<Element> = {
+    toComponent: () => Element[];
+    toString: () => string;
+};
+type HeadAttributeDatum = {
+    toComponent: () => Record<string, unknown>;
+    toString: () => string;
+};
+type MarkerProps = Record<'data-modern-helmet', string>;
+export type HelmetCompatProps<Child = unknown> = {
+    base?: object;
+    bodyAttributes?: object;
+    children?: Child;
+    defaultTitle?: string;
+    htmlAttributes?: object;
+    link?: object[];
+    meta?: object[];
+    noscript?: object[];
+    prioritizeSeoTags?: boolean;
+    script?: object[];
+    style?: object[];
+    title?: unknown;
+    titleAttributes?: object;
+    titleTemplate?: string;
+};
+export type HelmetCompatRecord = {
+    base: HeadTag[];
+    bodyAttributes?: HeadTag;
+    defaultTitle?: string;
+    htmlAttributes?: HeadTag;
+    link: HeadTag[];
+    meta: HeadTag[];
+    noscript: HeadTag[];
+    prioritizeSeoTags: boolean;
+    script: HeadTag[];
+    style: HeadTag[];
+    title?: string;
+    titleAttributes: HeadTag;
+    titleTemplate?: string;
+};
+export type HelmetCompatState<Element> = {
+    base: HeadDatum<Element>;
+    bodyAttributes: HeadAttributeDatum;
+    htmlAttributes: HeadAttributeDatum;
+    link: HeadDatum<Element>;
+    meta: HeadDatum<Element>;
+    noscript: HeadDatum<Element>;
+    priority: HeadDatum<Element>;
+    script: HeadDatum<Element>;
+    style: HeadDatum<Element>;
+    title: HeadDatum<Element>;
+};
+export declare const renderHeadMarker: <Element>(react: ElementFactory<Element>, marker: MarkerProps | null | undefined) => Element | null;
+export declare const markPriorityHeadRecord: (record: object, prioritize: boolean | undefined) => void;
+export declare const isPriorityHeadTag: (tag: object) => boolean;
+export declare const headTagsToComponents: <Element>(react: ElementFactory<Element>, tagName: string, tags: HeadTag[]) => Element[];
+export declare const headTitleToComponent: <Element>(react: ElementFactory<Element>, title: string | undefined, attributes: HeadTag) => Element[];
+export declare const createPriorityHeadDatum: <Element, RecordType>(react: ElementFactory<Element>, records: RecordType[], dedupe: (tagName: PriorityTagName, records: RecordType[]) => HeadTag[]) => HeadDatum<Element>;
+export declare const createHelmetRecord: <Element, Child>(reactValue: ReactAdapter<Element, Child>, props: HelmetCompatProps<Child>) => HelmetCompatRecord;
+export declare const deriveHelmetServerState: <Element>(react: ElementFactory<Element>, records: HelmetCompatRecord[]) => HelmetCompatState<Element>;
+export declare const collectImmediateHelmetState: <Element>(react: ElementFactory<Element>, context: object, record: HelmetCompatRecord) => HelmetCompatState<Element>;
+export {};

package/dist/types/html.d.ts

@@ -0,0 +1,2 @@
+export declare const isSafeHtmlAttributeName: (name: string) => boolean;
+export declare const escapeHtmlAttribute: (value: unknown) => string;

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './html';
+export * from './navigationWarmup';
+export * from './rendererHead';
+export * from './shellStream';

package/dist/types/navigationWarmup.d.ts

@@ -0,0 +1,8 @@
+type ChunkLoaderIdentity = object;
+/**
+ * Namespaces route warmups by the identities that give a chunk id meaning.
+ * Weak maps ensure a retired app context or bundler runtime is not retained by
+ * the shared prefetch cache. The public path is the final, value-based scope.
+ */
+export declare function getNavigationWarmupCacheKey(runtimeContext: object, chunkLoader: ChunkLoaderIdentity, publicPath: string, warmupKey: string): string;
+export {};

package/dist/types/node.d.ts

@@ -0,0 +1,11 @@
+import { Transform } from 'node:stream';
+export * from './rendererHead';
+export declare const createNodeHeadMarkerStripper: (context: object, terminalMarker?: string) => Transform;
+export declare const createOnceErrorReporter: (onError?: (error: unknown) => void) => ((error: unknown) => void);
+export declare const pipeNodeHeadStream: (options: {
+    source: NodeJS.ReadWriteStream;
+    destination: NodeJS.ReadWriteStream;
+    context: object;
+    terminalMarker?: string;
+    onError?: (error: Error) => void;
+}) => void;

package/dist/types/rendererHead.d.ts

@@ -0,0 +1,17 @@
+declare const MARKER_ATTRIBUTE = "data-modern-helmet";
+export type RendererHeadMarkerProps = Record<typeof MARKER_ATTRIBUTE, string>;
+export * from './helmetCompat';
+export declare const beginHeadRender: (context: object) => void;
+export declare const collectHeadRecord: <RecordType>(context: object, createRecord: () => RecordType, publish: (records: RecordType[]) => void) => RendererHeadMarkerProps | null | undefined;
+export declare const collectHeadState: <RecordType, StateType>(context: object, createRecord: () => RecordType, derive: (records: RecordType[]) => StateType, target: {
+    helmet?: StateType;
+}) => RendererHeadMarkerProps | null | undefined;
+export declare const publishHeadRender: (context: object) => void;
+export declare const finishHeadRender: (context: object) => void;
+export declare const completeHeadRender: (context: object, html: string) => string;
+export declare const abortHeadRender: (context: object) => void;
+export declare const createHeadChunkProcessor: (context: object) => {
+    push(chunk: string): string;
+    finish(chunk?: string): string;
+};
+export declare const createWebHeadMarkerStripper: (context: object) => TransformStream<Uint8Array, Uint8Array>;

package/dist/types/rscHtmlStream.d.ts

@@ -0,0 +1,4 @@
+export declare const RSC_HTML_CLOSING_TAIL_LIMIT: number;
+export declare function injectRSCPayload(rscStream: ReadableStream<Uint8Array>, { injectClosingTags }?: {
+    injectClosingTags?: boolean;
+}): TransformStream<Uint8Array, Uint8Array>;

package/dist/types/safeFailure.d.ts

@@ -0,0 +1,17 @@
+export type SafeFailureEnvelope = {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        status: number;
+    };
+};
+export type SafeFailureHttpResult = {
+    status: number;
+    body: SafeFailureEnvelope;
+    headers: Record<string, string>;
+};
+export declare const getSafeFailureStatus: (error: unknown) => number;
+export declare const createSafeFailureHttpResult: (error: unknown) => SafeFailureHttpResult;
+export declare const createSafeJsonFailureResponse: (error: unknown) => Response;
+export declare const createSafeFailureResponse: typeof createSafeJsonFailureResponse;

package/dist/types/shellStream.d.ts

@@ -0,0 +1 @@
+export declare const createConservingWebShellStream: (source: ReadableStream<Uint8Array>, context: object, marker: string, onMissingMarker?: (error: Error) => void) => ReadableStream<Uint8Array>;

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@bleedingdev/modern-js-runtime-extensions",
+  "description": "Fork-owned UltraModern.js runtime transaction, streaming, and safe failure primitives.",
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/runtime/runtime-extensions"
+  },
+  "license": "MIT",
+  "version": "3.8.3-ultramodern.2",
+  "engines": {
+    "node": ">=26.7.0"
+  },
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "node": {
+        "import": "./dist/esm-node/index.mjs",
+        "require": "./dist/cjs/index.js"
+      },
+      "default": "./dist/esm/index.mjs"
+    },
+    "./node": {
+      "types": "./dist/types/node.d.ts",
+      "node": {
+        "import": "./dist/esm-node/node.mjs",
+        "require": "./dist/cjs/node.js"
+      },
+      "default": "./dist/esm-node/node.mjs"
+    },
+    "./rsc-html-stream": {
+      "types": "./dist/types/rscHtmlStream.d.ts",
+      "node": {
+        "import": "./dist/esm-node/rscHtmlStream.mjs",
+        "require": "./dist/cjs/rscHtmlStream.js"
+      },
+      "default": "./dist/esm-node/rscHtmlStream.mjs"
+    },
+    "./safe-failure": {
+      "types": "./dist/types/safeFailure.d.ts",
+      "node": {
+        "import": "./dist/esm-node/safeFailure.mjs",
+        "require": "./dist/cjs/safeFailure.js"
+      },
+      "default": "./dist/esm/safeFailure.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types/index.d.ts",
+        "./src/index.ts"
+      ],
+      "node": [
+        "./dist/types/node.d.ts",
+        "./src/node.ts"
+      ],
+      "rsc-html-stream": [
+        "./dist/types/rscHtmlStream.d.ts",
+        "./src/rscHtmlStream.ts"
+      ],
+      "safe-failure": [
+        "./dist/types/safeFailure.d.ts",
+        "./src/safeFailure.ts"
+      ]
+    }
+  },
+  "devDependencies": {
+    "@rslib/core": "0.23.2",
+    "@scripts/rstest-config": "2.66.0",
+    "@types/node": "^26.2.0",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "typescript": "^7.0.2"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "rslib build --watch",
+    "build": "rslib build",
+    "test": "rstest"
+  }
+}

package/rslib.config.mts

@@ -0,0 +1,4 @@
+import { rslibConfig } from '@modern-js/rslib';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig(rslibConfig);

package/rstest.config.mts

@@ -0,0 +1,7 @@
+import { withTestPreset } from '@scripts/rstest-config';
+
+export default withTestPreset({
+  root: __dirname,
+  testEnvironment: 'node',
+  globals: true,
+});