@bleedingdev/modern-js-renderer-octane 0.0.0-stage → 3.9.3-ultramodern.1

package/dist/cjs/typecheck.js

@@ -0,0 +1,615 @@
+"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__, {
+    checkOctaneProject: ()=>checkOctaneProject,
+    formatOctaneDiagnostic: ()=>formatOctaneDiagnostic,
+    runOctaneTypecheck: ()=>runOctaneTypecheck
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const language_core_namespaceObject = require("@volar/language-core");
+const external_jsonc_parser_namespaceObject = require("jsonc-parser");
+const volar_namespaceObject = require("octane/compiler/volar");
+const external_typescript_namespaceObject = require("typescript");
+const fs_namespaceObject = require("typescript/unstable/fs");
+const sync_namespaceObject = require("typescript/unstable/sync");
+const nativeExtension = /\.tsrx$/u;
+const projectedExtension = /\.tsrx\.tsx$/u;
+function typecheck_location(source, pos) {
+    const prefix = source.slice(0, pos);
+    const lines = prefix.split(/\r\n|\r|\n/u);
+    return {
+        line: lines.length,
+        column: (lines.at(-1)?.length ?? 0) + 1
+    };
+}
+function readFile(file) {
+    try {
+        return external_node_fs_default().readFileSync(file, 'utf8');
+    } catch (error) {
+        if (error instanceof Error && 'code' in error && ('ENOENT' === error.code || 'ENOTDIR' === error.code)) return;
+        throw error;
+    }
+}
+function projectConfig(source, fileName, discovery, roots) {
+    const errors = [];
+    const config = (0, external_jsonc_parser_namespaceObject.parseTree)(source.replace(/^\uFEFF/u, ' '), errors, {
+        allowTrailingComma: true
+    });
+    if (errors.length || !config || 'object' !== config.type) return;
+    const edits = [];
+    const additions = [];
+    for (const field of [
+        'files',
+        'include',
+        'exclude'
+    ]){
+        const array = (0, external_jsonc_parser_namespaceObject.findNodeAtLocation)(config, [
+            field
+        ]);
+        if (roots) {
+            const content = JSON.stringify('files' === field ? roots : []);
+            if (array) {
+                if ('array' === array.type && (array.children ?? []).every((node)=>'string' === node.type)) edits.push({
+                    offset: array.offset,
+                    length: array.length,
+                    content
+                });
+            } else additions.push(`${JSON.stringify(field)}:${content}`);
+            continue;
+        }
+        if (array?.type === 'array') for (const node of array.children ?? []){
+            const file = (0, external_jsonc_parser_namespaceObject.getNodeValue)(node);
+            if ('string' != typeof file) continue;
+            const projected = 'files' === field || 'complete' === discovery ? nativeExtension.test(file) ? `${file}.tsx` : file : 'native' === discovery && /[.*?]/u.test(file.replaceAll('\\', '/').split('/').at(-1) ?? '') ? `${file.endsWith('/**') ? `${file}/*` : file}.tsx` : file;
+            if (projected !== file) edits.push({
+                offset: node.offset,
+                length: node.length,
+                content: JSON.stringify(projected)
+            });
+        }
+    }
+    if (additions.length) edits.push({
+        offset: config.offset + 1,
+        length: 0,
+        content: `${additions.join(',')}${config.children?.length ? ',' : ''}`
+    });
+    if (!edits.length) return;
+    const mappings = [];
+    let sourceOffset = 0;
+    let code = '';
+    for (const edit of edits.sort((left, right)=>left.offset - right.offset)){
+        const unchanged = source.slice(sourceOffset, edit.offset);
+        mappings.push({
+            sourceOffsets: [
+                sourceOffset
+            ],
+            generatedOffsets: [
+                code.length
+            ],
+            lengths: [
+                unchanged.length
+            ],
+            data: {
+                verification: true
+            }
+        });
+        code += unchanged;
+        mappings.push({
+            sourceOffsets: [
+                edit.offset
+            ],
+            generatedOffsets: [
+                code.length
+            ],
+            lengths: [
+                edit.length
+            ],
+            generatedLengths: [
+                edit.content.length
+            ],
+            data: {
+                verification: true
+            }
+        });
+        code += edit.content;
+        sourceOffset = edit.offset + edit.length;
+    }
+    mappings.push({
+        sourceOffsets: [
+            sourceOffset
+        ],
+        generatedOffsets: [
+            code.length
+        ],
+        lengths: [
+            source.length - sourceOffset
+        ],
+        data: {
+            verification: true
+        }
+    });
+    code += source.slice(sourceOffset);
+    return {
+        source,
+        fileName,
+        code,
+        map: new language_core_namespaceObject.SourceMap(mappings)
+    };
+}
+function diagnosticText(diagnostic) {
+    return [
+        diagnostic.text,
+        ...diagnostic.messageChain?.map(diagnosticText) ?? []
+    ].join('\n');
+}
+function checkOctaneProject(options) {
+    if ('7.0.2' !== external_typescript_namespaceObject.version) throw new Error(`Octane typechecking requires TypeScript 7.0.2; found ${external_typescript_namespaceObject.version}`);
+    const cwd = external_node_path_default().resolve(options.cwd ?? process.cwd());
+    let project = external_node_path_default().resolve(cwd, options.project);
+    if (external_node_fs_default().existsSync(project) && external_node_fs_default().statSync(project).isDirectory()) project = external_node_path_default().join(project, 'tsconfig.json');
+    if (!external_node_fs_default().existsSync(project)) throw new Error(`Cannot find project ${project}`);
+    if (options.compilerOptions?.noEmit === false || options.compilerOptions?.noCheck === true || options.compilerOptions?.skipLibCheck === true || options.compilerOptions?.skipDefaultLibCheck === true) throw new Error('Octane typechecking requires noEmit, full checking, and library checking');
+    const effectiveConfig = external_node_path_default().join(external_node_path_default().dirname(project), `.octane-typecheck-${(0, external_node_crypto_namespaceObject.randomUUID)()}.json`);
+    const authoredConfig = (0, external_jsonc_parser_namespaceObject.parse)((readFile(project) ?? '').replace(/^\uFEFF/u, ' '), [], {
+        allowTrailingComma: true
+    });
+    const effectiveOptions = {
+        extends: project,
+        ...Array.isArray(authoredConfig?.references) ? {
+            references: authoredConfig.references
+        } : {},
+        compilerOptions: {
+            ...options.compilerOptions,
+            noEmit: true,
+            noCheck: false,
+            skipLibCheck: false,
+            skipDefaultLibCheck: false
+        }
+    };
+    const virtual = (0, fs_namespaceObject.createVirtualFileSystem)({
+        [effectiveConfig]: JSON.stringify(effectiveOptions)
+    });
+    const projections = new Map();
+    const configurations = new Map();
+    const configFiles = new Set([
+        project
+    ]);
+    const referencedConfigs = new Set([
+        project
+    ]);
+    const referenceRoots = new Map();
+    let discovery = 'ordinary';
+    function authoredName(file) {
+        if (!projectedExtension.test(file)) return file;
+        const authored = file.slice(0, -4);
+        if (!external_node_fs_default().existsSync(authored)) return file;
+        if (external_node_fs_default().existsSync(file)) throw new Error(`Octane projection collision: ${authored} conflicts with physical ${file}`);
+        return authored;
+    }
+    function projection(file) {
+        const fileName = authoredName(file);
+        if (fileName === file) return;
+        const known = projections.get(file);
+        if (known) return known;
+        const source = readFile(fileName);
+        if (void 0 === source) return;
+        let compiled;
+        try {
+            compiled = (0, volar_namespaceObject.compileToVolarMappings)(source, fileName, {
+                loose: true
+            });
+        } catch (error) {
+            if (!(error instanceof SyntaxError)) throw error;
+            compiled = {
+                code: 'export {};',
+                mappings: [],
+                diagnostics: [],
+                errors: [
+                    {
+                        name: error.name,
+                        message: error.message,
+                        fileName,
+                        type: 'fatal',
+                        ...'pos' in error && 'number' == typeof error.pos ? {
+                            pos: error.pos
+                        } : {},
+                        ...'end' in error && 'number' == typeof error.end ? {
+                            end: error.end
+                        } : {}
+                    }
+                ]
+            };
+        }
+        const result = {
+            ...compiled,
+            source,
+            fileName,
+            map: new language_core_namespaceObject.SourceMap(compiled.mappings)
+        };
+        projections.set(file, result);
+        virtual.writeFile?.(file, compiled.code);
+        return result;
+    }
+    const overlay = {
+        readFile (file) {
+            const content = virtual.readFile?.(file);
+            if (void 0 !== content) return content;
+            const compiled = projection(file);
+            if (compiled) return compiled.code;
+            if (file.endsWith('.json')) {
+                const source = readFile(file);
+                if (void 0 !== source) {
+                    if (!configFiles.has(file) && ('complete' === discovery || 'package.json' === external_node_path_default().basename(file))) return source;
+                    configFiles.add(file);
+                    const configData = (0, external_jsonc_parser_namespaceObject.parse)(source.replace(/^\uFEFF/u, ' '), [], {
+                        allowTrailingComma: true
+                    });
+                    for (const reference of referencedConfigs.has(file) && Array.isArray(configData?.references) ? configData.references : []){
+                        if ('string' != typeof reference?.path) continue;
+                        const target = external_node_path_default().resolve(external_node_path_default().dirname(file), reference.path);
+                        const referenceFile = target.endsWith('.json') ? target : external_node_path_default().join(target, 'tsconfig.json');
+                        configFiles.add(referenceFile);
+                        referencedConfigs.add(referenceFile);
+                    }
+                    const roots = 'complete' === discovery ? referenceRoots.get(file) : void 0;
+                    const config = projectConfig(source, file, discovery, roots ? [
+                        ...roots
+                    ] : void 0);
+                    if (config) configurations.set(file, config);
+                    else configurations.delete(file);
+                    return config?.code ?? source;
+                }
+            }
+        },
+        fileExists (file) {
+            if (virtual.fileExists?.(file)) return true;
+            if (authoredName(file) !== file) return true;
+        },
+        directoryExists (directory) {
+            return virtual.directoryExists?.(directory) || void 0;
+        },
+        getAccessibleEntries (directory) {
+            const files = new Set(virtual.getAccessibleEntries?.(directory)?.files);
+            const directories = new Set(virtual.getAccessibleEntries?.(directory)?.directories);
+            try {
+                for (const entry of external_node_fs_default().readdirSync(directory, {
+                    withFileTypes: true
+                })){
+                    let isDirectory = entry.isDirectory();
+                    if (entry.isSymbolicLink()) try {
+                        isDirectory = external_node_fs_default().statSync(external_node_path_default().join(directory, entry.name)).isDirectory();
+                    } catch (error) {
+                        if (error instanceof Error && 'code' in error && ('ENOENT' === error.code || 'ENOTDIR' === error.code)) continue;
+                        throw error;
+                    }
+                    if (isDirectory) directories.add(entry.name);
+                    else {
+                        files.add(entry.name);
+                        if (nativeExtension.test(entry.name)) {
+                            const projected = external_node_path_default().join(directory, `${entry.name}.tsx`);
+                            authoredName(projected);
+                            files.add(`${entry.name}.tsx`);
+                        }
+                    }
+                }
+            } catch (error) {
+                if (!(error instanceof Error && 'code' in error && ('ENOENT' === error.code || 'ENOTDIR' === error.code))) throw error;
+            }
+            return {
+                files: [
+                    ...files
+                ].filter((file)=>'ordinary' !== discovery || authoredName(external_node_path_default().join(directory, file)) === external_node_path_default().join(directory, file)).sort(),
+                directories: [
+                    ...directories
+                ].sort()
+            };
+        },
+        realpath (file) {
+            const authored = authoredName(file);
+            if (authored !== file) try {
+                return `${external_node_fs_default().realpathSync(authored)}.tsx`;
+            } catch  {
+                return;
+            }
+            return virtual.fileExists?.(file) ? file : void 0;
+        }
+    };
+    const roots = new Set();
+    for (const mode of [
+        'ordinary',
+        'native'
+    ]){
+        discovery = mode;
+        const parser = new sync_namespaceObject.API({
+            cwd,
+            fs: overlay
+        });
+        try {
+            for (const file of parser.parseConfigFile(effectiveConfig).fileNames)if ('ordinary' === mode || authoredName(file) !== file) roots.add(file);
+            const parsedReferences = new Set([
+                project
+            ]);
+            for (const reference of referencedConfigs){
+                if (parsedReferences.has(reference)) continue;
+                parsedReferences.add(reference);
+                const selected = referenceRoots.get(reference) ?? new Set();
+                referenceRoots.set(reference, selected);
+                for (const file of parser.parseConfigFile(reference).fileNames)if ('ordinary' === mode || authoredName(file) !== file) selected.add(file);
+            }
+        } finally{
+            parser.close();
+        }
+    }
+    discovery = 'complete';
+    virtual.writeFile?.(effectiveConfig, JSON.stringify({
+        ...effectiveOptions,
+        files: [
+            ...roots
+        ],
+        include: [],
+        exclude: []
+    }));
+    const api = new sync_namespaceObject.API({
+        cwd,
+        fs: overlay
+    });
+    try {
+        const snapshot = api.updateSnapshot({
+            openProjects: [
+                effectiveConfig
+            ],
+            openFiles: [
+                ...roots
+            ]
+        });
+        const program = snapshot.getProject(effectiveConfig)?.program;
+        if (!program) throw new Error(`Native TypeScript did not load project ${project}`);
+        function remap(diagnostic) {
+            const relatedInformation = diagnostic.relatedInformation?.flatMap((info)=>{
+                const mapped = remap(info);
+                return mapped ? [
+                    mapped
+                ] : [];
+            });
+            const text = diagnosticText(diagnostic);
+            const compiled = diagnostic.fileName ? projections.get(diagnostic.fileName) ?? configurations.get(diagnostic.fileName) : void 0;
+            let pos = diagnostic.pos;
+            let end = diagnostic.end;
+            let origin = "typescript";
+            let message = text;
+            if (compiled) {
+                const ranges = compiled.map.toSourceRange(pos, end, true, (info)=>(0, language_core_namespaceObject.shouldReportDiagnostics)(info, void 0, diagnostic.code));
+                const range = ranges.next().value;
+                if (range) [pos, end] = range;
+                else {
+                    if (!compiled.map.toSourceRange(pos, end, true).next().done) return;
+                    origin = 'projection';
+                    message = `Cannot map native TS${diagnostic.code} at generated offsets ${pos}-${end}: ${text}`;
+                    pos = 0;
+                    end = 0;
+                }
+            }
+            const fileName = compiled?.fileName ?? (diagnostic.fileName === effectiveConfig ? void 0 : diagnostic.fileName);
+            const source = compiled?.source ?? (fileName ? readFile(fileName) : void 0);
+            return {
+                ...fileName ? {
+                    fileName
+                } : {},
+                pos,
+                end,
+                ...void 0 !== source ? typecheck_location(source, pos) : {},
+                code: diagnostic.code,
+                category: 'projection' === origin || 1 === diagnostic.category ? 'error' : 0 === diagnostic.category ? 'warning' : 'message',
+                text: message,
+                origin,
+                ...relatedInformation?.length ? {
+                    relatedInformation
+                } : {}
+            };
+        }
+        const diagnostics = [
+            ...program.getConfigFileParsingDiagnostics(),
+            ...program.getProgramDiagnostics(),
+            ...program.getGlobalDiagnostics(),
+            ...program.getSyntacticDiagnostics(),
+            ...program.getBindDiagnostics(),
+            ...program.getSemanticDiagnostics()
+        ].flatMap((diagnostic)=>{
+            const mapped = remap(diagnostic);
+            return mapped ? [
+                mapped
+            ] : [];
+        });
+        const nativeFiles = program.getSourceFileNames();
+        for (const file of nativeFiles){
+            const compiled = projections.get(file);
+            if (compiled) {
+                for (const diagnostic of compiled.diagnostics)diagnostics.push({
+                    fileName: compiled.fileName,
+                    pos: diagnostic.start.offset,
+                    end: diagnostic.end.offset,
+                    ...typecheck_location(compiled.source, diagnostic.start.offset),
+                    code: diagnostic.code,
+                    category: 'error' === diagnostic.severity ? 'error' : 'warning' === diagnostic.severity ? 'warning' : 'message',
+                    text: diagnostic.message,
+                    origin: 'octane'
+                });
+                for (const error of compiled.errors){
+                    const pos = error.pos ?? 0;
+                    diagnostics.push({
+                        fileName: compiled.fileName,
+                        pos,
+                        end: error.end ?? pos,
+                        ...typecheck_location(compiled.source, pos),
+                        code: 'OCTANE_PARSE',
+                        category: 'error',
+                        text: error.message,
+                        origin: 'octane'
+                    });
+                }
+            }
+        }
+        const unique = new Map(diagnostics.map((diagnostic)=>[
+                JSON.stringify(diagnostic),
+                diagnostic
+            ]));
+        return {
+            compilerVersion: external_typescript_namespaceObject.version,
+            files: [
+                ...new Set(nativeFiles.map((file)=>projections.get(file)?.fileName ?? file))
+            ].sort(),
+            diagnostics: [
+                ...unique.values()
+            ].sort((left, right)=>(left.fileName ?? '').localeCompare(right.fileName ?? '') || left.pos - right.pos || String(left.code).localeCompare(String(right.code)))
+        };
+    } finally{
+        api.close();
+    }
+}
+function formatOctaneDiagnostic(diagnostic, cwd = process.cwd()) {
+    const file = diagnostic.fileName ? `${external_node_path_default().relative(cwd, diagnostic.fileName)}(${diagnostic.line ?? 1},${diagnostic.column ?? 1}): ` : '';
+    const code = 'number' == typeof diagnostic.code ? `TS${diagnostic.code}` : diagnostic.code;
+    const related = diagnostic.relatedInformation?.map((info)=>`  ${formatOctaneDiagnostic(info, cwd)}`).join('\n');
+    return `${file}${diagnostic.category} ${code}: ${diagnostic.text}${related ? `\n${related}` : ''}`;
+}
+const booleanOptions = new Set([
+    'strict',
+    'isolatedModules',
+    'verbatimModuleSyntax',
+    'allowImportingTsExtensions',
+    'allowJs',
+    'esModuleInterop',
+    'noUncheckedIndexedAccess',
+    'exactOptionalPropertyTypes',
+    'noImplicitOverride',
+    'noFallthroughCasesInSwitch',
+    'noPropertyAccessFromIndexSignature',
+    'noImplicitReturns',
+    'resolveJsonModule',
+    'strictNullChecks',
+    'strictFunctionTypes',
+    'strictBindCallApply',
+    'strictPropertyInitialization',
+    'noImplicitAny',
+    'noImplicitThis',
+    'useUnknownInCatchVariables',
+    'alwaysStrict'
+]);
+const stringOptions = new Set([
+    'target',
+    'module',
+    'moduleResolution',
+    'moduleDetection',
+    'jsx',
+    'jsxImportSource'
+]);
+function runOctaneTypecheck(argv, io = {}) {
+    const stdout = io.stdout ?? ((text)=>process.stdout.write(text));
+    const stderr = io.stderr ?? ((text)=>process.stderr.write(text));
+    try {
+        let project = 'tsconfig.json';
+        let listFiles = false;
+        const compilerOptions = {};
+        for(let index = 0; index < argv.length; index++){
+            const argument = argv[index];
+            if ('--version' === argument || '-v' === argument) {
+                stdout(`Version ${external_typescript_namespaceObject.version}\n`);
+                return 0;
+            }
+            if ('--help' === argument || '-h' === argument) {
+                stdout('octane-tsc --project <tsconfig.json> [--noEmit] [--strict]\n');
+                return 0;
+            }
+            if ('--project' === argument || '-p' === argument) {
+                const value = argv[++index];
+                if (!value || value.startsWith('-')) throw new Error('--project requires a configuration path');
+                project = value;
+                continue;
+            }
+            if (!argument?.startsWith('--')) throw new Error(`Unsupported Octane typecheck argument ${argument}`);
+            const name = argument.slice(2);
+            if (booleanOptions.has(name) || [
+                'noEmit',
+                'noCheck',
+                'skipLibCheck',
+                'skipDefaultLibCheck',
+                'pretty',
+                'listFiles',
+                'explainFiles'
+            ].includes(name)) {
+                const explicit = argv[index + 1];
+                const value = 'true' === explicit || 'false' === explicit ? 'true' === argv[++index] : true;
+                if ('noEmit' === name && !value || ('noCheck' === name || 'skipLibCheck' === name || 'skipDefaultLibCheck' === name) && value) throw new Error(`--${name} ${value} is incompatible with full Octane typechecking`);
+                if ('listFiles' === name || 'explainFiles' === name) listFiles ||= value;
+                else if ('pretty' !== name) compilerOptions[name] = value;
+            } else if (stringOptions.has(name) || 'lib' === name || 'types' === name) {
+                const value = argv[++index];
+                if (!value || value.startsWith('-')) throw new Error(`--${name} requires a value`);
+                compilerOptions[name] = 'lib' === name || 'types' === name ? value.split(',') : value;
+            } else throw new Error(`Unsupported Octane typecheck option --${name}`);
+        }
+        const cwd = external_node_path_default().resolve(io.cwd ?? process.cwd());
+        const result = checkOctaneProject({
+            project,
+            cwd,
+            compilerOptions
+        });
+        for (const diagnostic of result.diagnostics)stdout(`${formatOctaneDiagnostic(diagnostic, cwd)}\n`);
+        if (listFiles) for (const file of result.files)stdout(`${file}\n`);
+        return result.diagnostics.some((diagnostic)=>'error' === diagnostic.category) ? 1 : 0;
+    } catch (error) {
+        stderr(`${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+}
+exports.checkOctaneProject = __webpack_exports__.checkOctaneProject;
+exports.formatOctaneDiagnostic = __webpack_exports__.formatOctaneDiagnostic;
+exports.runOctaneTypecheck = __webpack_exports__.runOctaneTypecheck;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "checkOctaneProject",
+    "formatOctaneDiagnostic",
+    "runOctaneTypecheck"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/bootstrap.mjs

@@ -0,0 +1,24 @@
+import { readDocumentBootstrap } from "@modern-js/renderer-core/document";
+import { readRendererIdentity } from "@modern-js/renderer-core/identity";
+function assertNativeHydrationBuildId(value) {
+    if ('string' != typeof value || 0 === value.trim().length) throw new Error('An Octane document requires its native client compilation identity.');
+}
+function assertOctaneIdentity(identity) {
+    readRendererIdentity(identity, identity);
+    if ('octane' !== identity.renderer) throw new Error('An Octane application requires an Octane renderer identity.');
+}
+function readOctaneDocumentBootstrap(document, expectedIdentity, expectedNativeHydrationBuildId) {
+    assertOctaneIdentity(expectedIdentity);
+    const { identity, documentId, hydrating, nativeHydrationBuildId } = readDocumentBootstrap(document, expectedIdentity, [
+        'nativeHydrationBuildId'
+    ]);
+    assertNativeHydrationBuildId(nativeHydrationBuildId);
+    if (void 0 !== expectedNativeHydrationBuildId && nativeHydrationBuildId !== expectedNativeHydrationBuildId) throw new Error('Octane hydration bytes belong to a different native client compilation.');
+    return Object.freeze({
+        identity,
+        documentId,
+        hydrating,
+        nativeHydrationBuildId
+    });
+}
+export { assertNativeHydrationBuildId, assertOctaneIdentity, readOctaneDocumentBootstrap };