noteconnection 1.7.0 → 1.9.0

package/dist/src/frontend/mobile_budget_runtime.js

@@ -0,0 +1,33 @@
+(function attachMobileBudgetRuntime(root) {
+    'use strict';
+
+    // This is the intentionally tiny browser projection of config/mobile-budget.v1.json.
+    // The Node/Rust contract remains the source of truth; contract tests reject drift.
+    if (!root || root.NoteConnectionMobileBudget) {
+        return;
+    }
+
+    root.NoteConnectionMobileBudget = Object.freeze({
+        schemaVersion: 1,
+        profiles: Object.freeze({
+            'mobile-low': Object.freeze({
+                artifactCompressedBytes: 25 * 1024 * 1024,
+                maxResidentBytes: 256 * 1024 * 1024,
+                maxDeviceRamBytes: 4 * 1024 * 1024 * 1024
+            }),
+            'mobile-standard': Object.freeze({
+                artifactCompressedBytes: 35 * 1024 * 1024,
+                maxResidentBytes: 384 * 1024 * 1024,
+                maxDeviceRamBytes: 8 * 1024 * 1024 * 1024
+            })
+        }),
+        runtime: Object.freeze({
+            maxDocuments: 5000,
+            maxDocumentBytes: 16 * 1024 * 1024,
+            maxTotalInputBytes: 64 * 1024 * 1024,
+            maxEdges: 250000,
+            maxDepth: 64,
+            maxProjectionBytes: 48 * 1024 * 1024
+        })
+    });
+}(typeof globalThis !== 'undefined' ? globalThis : this));

package/dist/src/frontend/mobile_exact_analyzer.js

@@ -0,0 +1,393 @@
+(function attachMobileExactAnalyzer(root, factory) {
+    const api = factory();
+    if (typeof module === 'object' && module.exports) {
+        module.exports = api;
+    }
+    if (root) {
+        root.NoteConnectionMobileExactAnalyzer = api;
+    }
+}(typeof globalThis !== 'undefined' ? globalThis : this, function createAnalyzerApi() {
+    'use strict';
+
+    const MAX_NODES = 50000;
+    const MAX_EDGES = 250000;
+    const MAX_QUERY_LENGTH = 256;
+    const MAX_MATCHES = 50;
+    const MAX_NEIGHBORS = 64;
+    const MAX_PATH_DEPTH = 8;
+    const MAX_VISITED_NODES = 10000;
+    const PROJECTION_VERSION = 1;
+
+    function normalizeLookupKey(value) {
+        const text = String(value || '').trim();
+        const normalizedText = typeof text.normalize === 'function'
+            ? text.normalize('NFC')
+            : text;
+        return normalizedText.toLowerCase();
+    }
+
+    function classifyEdgeType(edgeType) {
+        const normalized = String(edgeType || '').trim().toLowerCase();
+        if (normalized.startsWith('explicit-') || normalized === 'tagged' || normalized === 'sequence') {
+            return 'explicit';
+        }
+        if (
+            normalized.includes('inferred')
+            || normalized.includes('keyword')
+            || normalized.includes('vector')
+            || normalized.includes('statistical')
+            || normalized.includes('similarity')
+        ) {
+            return 'inferred';
+        }
+        return 'runtime';
+    }
+
+    function normalizeEdgeKinds(value) {
+        if (!Array.isArray(value)) {
+            return null;
+        }
+        const allowed = new Set(['explicit', 'inferred', 'runtime']);
+        const kinds = value.map((kind) => String(kind || '').trim().toLowerCase()).filter((kind) => allowed.has(kind));
+        return kinds.length > 0 ? new Set(kinds) : null;
+    }
+
+    function boundedPositiveInteger(value, fallback, ceiling) {
+        const parsed = Number.parseInt(String(value || ''), 10);
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            return fallback;
+        }
+        return Math.min(parsed, ceiling);
+    }
+
+    function readEndpointId(value) {
+        if (typeof value === 'string') {
+            return value.trim();
+        }
+        if (value && typeof value === 'object' && typeof value.id === 'string') {
+            return value.id.trim();
+        }
+        return '';
+    }
+
+    function projectNode(rawNode) {
+        if (!rawNode || typeof rawNode !== 'object') {
+            throw new Error('Mobile exact index requires every node to be an object.');
+        }
+        const id = typeof rawNode.id === 'string' ? rawNode.id.trim() : '';
+        if (!id) {
+            throw new Error('Mobile exact index requires every node to have a non-empty id.');
+        }
+        const metadata = rawNode.metadata && typeof rawNode.metadata === 'object'
+            ? rawNode.metadata
+            : {};
+        const tags = Array.isArray(metadata.tags)
+            ? metadata.tags.map((tag) => String(tag || '').trim()).filter(Boolean)
+            : [];
+        const identityAliases = Array.isArray(rawNode.identityAliases)
+            ? rawNode.identityAliases.map((alias) => String(alias || '').trim()).filter(Boolean)
+            : [];
+
+        return Object.freeze({
+            id,
+            canonicalId: typeof rawNode.canonicalId === 'string' ? rawNode.canonicalId.trim() : '',
+            label: typeof rawNode.label === 'string' && rawNode.label.trim()
+                ? rawNode.label.trim()
+                : id,
+            clusterId: typeof rawNode.clusterId === 'string' ? rawNode.clusterId : '',
+            inDegree: Number.isFinite(rawNode.inDegree) ? Number(rawNode.inDegree) : 0,
+            outDegree: Number.isFinite(rawNode.outDegree) ? Number(rawNode.outDegree) : 0,
+            tags: Object.freeze(tags),
+            sourceUri: typeof rawNode.sourceUri === 'string' ? rawNode.sourceUri.trim() : '',
+            revision: typeof rawNode.revision === 'string' ? rawNode.revision.trim() : '',
+            identityAliases: Object.freeze(identityAliases),
+            evidenceRefs: Object.freeze(Array.isArray(rawNode.evidenceRefs)
+                ? rawNode.evidenceRefs.map((reference) => String(reference || '').trim()).filter(Boolean).slice(0, 8)
+                : []),
+        });
+    }
+
+    function addLookupReference(lookup, rawKey, nodeId) {
+        const key = normalizeLookupKey(rawKey);
+        if (!key) {
+            return;
+        }
+        if (!lookup.has(key)) {
+            lookup.set(key, new Set());
+        }
+        lookup.get(key).add(nodeId);
+    }
+
+    function createMobileExactIndex(graph) {
+        if (!graph || typeof graph !== 'object') {
+            throw new Error('Mobile exact index requires a graph payload.');
+        }
+        const declaredSchemaVersion = graph.schemaVersion ?? graph.projectionVersion;
+        if (declaredSchemaVersion !== undefined && Number(declaredSchemaVersion) !== PROJECTION_VERSION) {
+            throw new Error(`Unsupported mobile projection schema version: ${String(declaredSchemaVersion)}.`);
+        }
+        const rawNodes = Array.isArray(graph.nodes) ? graph.nodes : [];
+        const rawEdges = Array.isArray(graph.edges) ? graph.edges : [];
+        if (rawNodes.length > MAX_NODES) {
+            throw new Error(`Mobile exact index node limit exceeded: ${rawNodes.length}/${MAX_NODES}.`);
+        }
+        if (rawEdges.length > MAX_EDGES) {
+            throw new Error(`Mobile exact index edge limit exceeded: ${rawEdges.length}/${MAX_EDGES}.`);
+        }
+
+        const nodeById = new Map();
+        const normalizedNodeIds = new Set();
+        const lookup = new Map();
+        const outgoing = new Map();
+        const incoming = new Map();
+
+        rawNodes.forEach((rawNode) => {
+            const node = projectNode(rawNode);
+            const normalizedId = normalizeLookupKey(node.id);
+            if (normalizedNodeIds.has(normalizedId)) {
+                throw new Error(`Mobile exact index contains a duplicate node id: ${node.id}.`);
+            }
+            normalizedNodeIds.add(normalizedId);
+            nodeById.set(node.id, node);
+            outgoing.set(node.id, new Map());
+            incoming.set(node.id, new Map());
+            addLookupReference(lookup, node.id, node.id);
+            addLookupReference(lookup, node.canonicalId, node.id);
+            addLookupReference(lookup, node.label, node.id);
+            addLookupReference(lookup, node.sourceUri, node.id);
+            addLookupReference(lookup, node.revision, node.id);
+            node.identityAliases.forEach((alias) => addLookupReference(lookup, alias, node.id));
+            node.tags.forEach((tag) => addLookupReference(lookup, tag, node.id));
+        });
+
+        let edgeCount = 0;
+        let explicitEdgeCount = 0;
+        let inferredEdgeCount = 0;
+        let runtimeEdgeCount = 0;
+        rawEdges.forEach((rawEdge) => {
+            if (!rawEdge || typeof rawEdge !== 'object') {
+                throw new Error('Mobile exact index requires every edge to be an object.');
+            }
+            const source = readEndpointId(rawEdge.source);
+            const target = readEndpointId(rawEdge.target);
+            if (!source || !target || !nodeById.has(source) || !nodeById.has(target)) {
+                throw new Error(`Mobile exact index edge references an unknown node: ${source || '?'} -> ${target || '?'}.`);
+            }
+            if (source === target) {
+                return;
+            }
+            const sourceEdges = outgoing.get(source);
+            if (sourceEdges.has(target)) {
+                return;
+            }
+            const edgeType = typeof rawEdge.type === 'string' && rawEdge.type.trim()
+                ? rawEdge.type.trim()
+                : 'association';
+            const edgeKind = classifyEdgeType(edgeType);
+            sourceEdges.set(target, edgeType);
+            incoming.get(target).set(source, edgeType);
+            edgeCount += 1;
+            if (edgeKind === 'explicit') explicitEdgeCount += 1;
+            else if (edgeKind === 'inferred') inferredEdgeCount += 1;
+            else runtimeEdgeCount += 1;
+        });
+
+        function searchExact(term, requestedLimit) {
+            const normalizedTerm = normalizeLookupKey(term);
+            if (!normalizedTerm || normalizedTerm.length > MAX_QUERY_LENGTH) {
+                return [];
+            }
+            const limit = boundedPositiveInteger(requestedLimit, 25, MAX_MATCHES);
+            const matchedIds = lookup.get(normalizedTerm) || new Set();
+            return Array.from(matchedIds)
+                .sort((left, right) => left.localeCompare(right))
+                .slice(0, limit)
+                .map((id) => nodeById.get(id));
+        }
+
+        function resolveNodeReference(reference) {
+            const direct = typeof reference === 'string' ? reference.trim() : '';
+            if (direct && nodeById.has(direct)) {
+                return direct;
+            }
+            const matches = lookup.get(normalizeLookupKey(reference));
+            return matches && matches.size === 1 ? Array.from(matches)[0] : '';
+        }
+
+        function neighbors(nodeId, requestedLimit, requestedKinds) {
+            const resolvedNodeId = resolveNodeReference(nodeId);
+            if (!resolvedNodeId) {
+                return [];
+            }
+            const limit = boundedPositiveInteger(requestedLimit, 16, MAX_NEIGHBORS);
+            const edgeKinds = normalizeEdgeKinds(requestedKinds);
+            const adjacent = [];
+            outgoing.get(resolvedNodeId).forEach((edgeType, id) => {
+                if (!edgeKinds || edgeKinds.has(classifyEdgeType(edgeType))) {
+                    adjacent.push({ ...nodeById.get(id), direction: 'outgoing', edgeType, edgeKind: classifyEdgeType(edgeType) });
+                }
+            });
+            incoming.get(resolvedNodeId).forEach((edgeType, id) => {
+                if (!edgeKinds || edgeKinds.has(classifyEdgeType(edgeType))) {
+                    adjacent.push({ ...nodeById.get(id), direction: 'incoming', edgeType, edgeKind: classifyEdgeType(edgeType) });
+                }
+            });
+            return adjacent
+                .sort((left, right) => {
+                    if (left.direction !== right.direction) {
+                        return left.direction === 'outgoing' ? -1 : 1;
+                    }
+                    return left.id.localeCompare(right.id);
+                })
+                    .slice(0, limit);
+        }
+
+        function isPrerequisiteRouteNeighbor(neighbor) {
+            return neighbor
+                && neighbor.direction === 'incoming'
+                && /prerequisite|precondition|foundation|先修|前置|基础|sequence/iu.test(
+                    String(neighbor.edgeType || '')
+                );
+        }
+
+        function isApplicationRouteNeighbor(neighbor) {
+            return neighbor
+                && neighbor.direction === 'outgoing'
+                && /application|use|performance|应用|用例|性能/iu.test(
+                    String(neighbor.edgeType || '')
+                );
+        }
+
+        function learningRoute(anchorReference, requestedLimit) {
+            const anchorId = resolveNodeReference(anchorReference);
+            if (!anchorId) {
+                return [];
+            }
+            const limit = boundedPositiveInteger(requestedLimit, 6, 8);
+            const anchor = nodeById.get(anchorId);
+            const adjacent = neighbors(anchorId, Math.min(MAX_NEIGHBORS, limit * 3), ['explicit', 'runtime']);
+            const entries = [];
+            const seen = new Set();
+            const append = (neighbor, role, orderingBasis) => {
+                const nodeId = String(neighbor && neighbor.id || '').trim();
+                if (!nodeId || seen.has(nodeId)) {
+                    return;
+                }
+                seen.add(nodeId);
+                entries.push({
+                    nodeId,
+                    title: String(neighbor && (neighbor.label || neighbor.id) || '').trim(),
+                    role,
+                    orderingBasis,
+                });
+            };
+            adjacent
+                .filter(isPrerequisiteRouteNeighbor)
+                .sort((left, right) => String(left.label || left.id || '').localeCompare(String(right.label || right.id || '')))
+                .forEach((neighbor) => append(neighbor, 'prerequisite', 'explicit_prerequisite'));
+            append(anchor, 'core', 'semantic_grouping');
+            adjacent
+                .filter((neighbor) => !isPrerequisiteRouteNeighbor(neighbor))
+                .sort((left, right) => {
+                    const leftApplication = isApplicationRouteNeighbor(left) ? 1 : 0;
+                    const rightApplication = isApplicationRouteNeighbor(right) ? 1 : 0;
+                    return leftApplication - rightApplication
+                        || String(left.label || left.id || '').localeCompare(String(right.label || right.id || ''));
+                })
+                .forEach((neighbor) => append(
+                    neighbor,
+                    isApplicationRouteNeighbor(neighbor) ? 'application' : 'mechanism',
+                    isApplicationRouteNeighbor(neighbor) ? 'explicit_sequence' : 'semantic_grouping'
+                ));
+            return entries.slice(0, limit).map((entry, index) => ({
+                ...entry,
+                order: index + 1,
+            }));
+        }
+
+        function shortestPath(sourceNodeId, targetNodeId, requestedMaxDepth, requestedMaxVisitedNodes) {
+            const resolvedSourceId = resolveNodeReference(sourceNodeId);
+            const resolvedTargetId = resolveNodeReference(targetNodeId);
+            if (!resolvedSourceId || !resolvedTargetId) {
+                return null;
+            }
+            if (resolvedSourceId === resolvedTargetId) {
+                return [resolvedSourceId];
+            }
+            const maxDepth = boundedPositiveInteger(requestedMaxDepth, 4, MAX_PATH_DEPTH);
+            const maxVisitedNodes = boundedPositiveInteger(
+                requestedMaxVisitedNodes,
+                2000,
+                MAX_VISITED_NODES
+            );
+            const queue = [{ id: resolvedSourceId, depth: 0 }];
+            const parentById = new Map([[resolvedSourceId, null]]);
+
+            for (let cursor = 0; cursor < queue.length; cursor += 1) {
+                const current = queue[cursor];
+                if (current.depth >= maxDepth) {
+                    continue;
+                }
+                for (const nextId of outgoing.get(current.id).keys()) {
+                    if (parentById.has(nextId)) {
+                        continue;
+                    }
+                    if (parentById.size >= maxVisitedNodes) {
+                        return null;
+                    }
+                    parentById.set(nextId, current.id);
+                    if (nextId === resolvedTargetId) {
+                        const path = [resolvedTargetId];
+                        let parentId = current.id;
+                        while (parentId) {
+                            path.push(parentId);
+                            parentId = parentById.get(parentId);
+                        }
+                        return path.reverse();
+                    }
+                    queue.push({ id: nextId, depth: current.depth + 1 });
+                }
+            }
+            return null;
+        }
+
+        function statistics(options) {
+            const base = {
+                nodeCount: nodeById.size,
+                edgeCount,
+            };
+            if (!options || options.includeProvenance !== true) {
+                return base;
+            }
+            return {
+                ...base,
+                projectionVersion: PROJECTION_VERSION,
+                explicitEdgeCount,
+                inferredEdgeCount,
+                runtimeEdgeCount,
+            };
+        }
+
+        return Object.freeze({
+            projectionVersion: PROJECTION_VERSION,
+            searchExact,
+            neighbors,
+            learningRoute,
+            shortestPath,
+            statistics,
+        });
+    }
+
+    return Object.freeze({
+        createMobileExactIndex,
+        limits: Object.freeze({
+            maxNodes: MAX_NODES,
+            maxEdges: MAX_EDGES,
+            maxQueryLength: MAX_QUERY_LENGTH,
+            maxMatches: MAX_MATCHES,
+            maxNeighbors: MAX_NEIGHBORS,
+            maxPathDepth: MAX_PATH_DEPTH,
+            maxVisitedNodes: MAX_VISITED_NODES,
+        }),
+    });
+}));

package/dist/src/frontend/mobile_identity_contract.js

@@ -0,0 +1,221 @@
+(function attachMobileIdentityContract(root, factory) {
+    const api = factory();
+    if (typeof module === 'object' && module.exports) {
+        module.exports = api;
+    }
+    if (root) {
+        root.NoteConnectionMobileIdentity = api;
+    }
+}(typeof globalThis !== 'undefined' ? globalThis : this, function createMobileIdentityContract() {
+    'use strict';
+
+    const SOURCE_URI_PREFIX = 'note://workspace/v1/';
+    const SHA256_K = Object.freeze([
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+        0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+        0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+        0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+        0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+        0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+        0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+        0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+        0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    ]);
+
+    function normalizeUnicodeText(value, fieldName) {
+        if (typeof value !== 'string') {
+            throw new Error(`${fieldName} must be a string.`);
+        }
+        if (value.includes('\0')) {
+            throw new Error(`${fieldName} must not contain NUL characters.`);
+        }
+        return typeof value.normalize === 'function' ? value.normalize('NFC') : value;
+    }
+
+    function normalizePortablePath(relativePath) {
+        const displayPath = normalizeUnicodeText(relativePath, 'Relative resource path')
+            .replace(/\\/g, '/')
+            .trim();
+        const segments = displayPath.split('/').filter(Boolean);
+        if (segments[0] && segments[0].toLowerCase() === 'knowledge_base') {
+            segments.shift();
+        }
+        if (segments.length === 0 || segments.some(segment => segment === '.' || segment === '..')) {
+            throw new Error(`Relative resource path is unsafe: ${relativePath}`);
+        }
+        return segments.map(segment => segment.toLowerCase()).join('/');
+    }
+
+    function createSourceUri(canonicalRelativePath) {
+        return `${SOURCE_URI_PREFIX}${canonicalRelativePath
+            .split('/')
+            .map(segment => encodeURIComponent(segment))
+            .join('/')}`;
+    }
+
+    function createCanonicalId(canonicalRelativePath) {
+        return canonicalRelativePath.replace(/\.(?:md|markdown)$/i, '');
+    }
+
+    function utf8Encode(value) {
+        if (typeof TextEncoder === 'function') {
+            return new TextEncoder().encode(value);
+        }
+        const bytes = [];
+        for (let index = 0; index < value.length; index += 1) {
+            let codePoint = value.codePointAt(index);
+            if (codePoint > 0xffff) {
+                index += 1;
+            }
+            if (codePoint <= 0x7f) {
+                bytes.push(codePoint);
+            } else if (codePoint <= 0x7ff) {
+                bytes.push(0xc0 | (codePoint >> 6), 0x80 | (codePoint & 0x3f));
+            } else if (codePoint <= 0xffff) {
+                bytes.push(
+                    0xe0 | (codePoint >> 12),
+                    0x80 | ((codePoint >> 6) & 0x3f),
+                    0x80 | (codePoint & 0x3f),
+                );
+            } else {
+                bytes.push(
+                    0xf0 | (codePoint >> 18),
+                    0x80 | ((codePoint >> 12) & 0x3f),
+                    0x80 | ((codePoint >> 6) & 0x3f),
+                    0x80 | (codePoint & 0x3f),
+                );
+            }
+        }
+        return Uint8Array.from(bytes);
+    }
+
+    function rightRotate(value, amount) {
+        return (value >>> amount) | (value << (32 - amount));
+    }
+
+    function sha256HexSync(value) {
+        const bytes = utf8Encode(normalizeUnicodeText(value, 'Resource content'));
+        const bitLength = bytes.length * 8;
+        const paddedLength = ((bytes.length + 9 + 63) >> 6) << 6;
+        const padded = new Uint8Array(paddedLength);
+        padded.set(bytes);
+        padded[bytes.length] = 0x80;
+        const view = new DataView(padded.buffer);
+        view.setUint32(padded.length - 4, bitLength >>> 0);
+        view.setUint32(padded.length - 8, Math.floor(bitLength / 0x100000000));
+
+        let h0 = 0x6a09e667;
+        let h1 = 0xbb67ae85;
+        let h2 = 0x3c6ef372;
+        let h3 = 0xa54ff53a;
+        let h4 = 0x510e527f;
+        let h5 = 0x9b05688c;
+        let h6 = 0x1f83d9ab;
+        let h7 = 0x5be0cd19;
+        const words = new Uint32Array(64);
+
+        for (let offset = 0; offset < padded.length; offset += 64) {
+            for (let index = 0; index < 16; index += 1) {
+                words[index] = view.getUint32(offset + index * 4);
+            }
+            for (let index = 16; index < 64; index += 1) {
+                const s0 = rightRotate(words[index - 15], 7)
+                    ^ rightRotate(words[index - 15], 18)
+                    ^ (words[index - 15] >>> 3);
+                const s1 = rightRotate(words[index - 2], 17)
+                    ^ rightRotate(words[index - 2], 19)
+                    ^ (words[index - 2] >>> 10);
+                words[index] = (words[index - 16] + s0 + words[index - 7] + s1) >>> 0;
+            }
+
+            let a = h0;
+            let b = h1;
+            let c = h2;
+            let d = h3;
+            let e = h4;
+            let f = h5;
+            let g = h6;
+            let h = h7;
+            for (let index = 0; index < 64; index += 1) {
+                const sigma1 = rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25);
+                const choose = (e & f) ^ (~e & g);
+                const temp1 = (h + sigma1 + choose + SHA256_K[index] + words[index]) >>> 0;
+                const sigma0 = rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22);
+                const majority = (a & b) ^ (a & c) ^ (b & c);
+                const temp2 = (sigma0 + majority) >>> 0;
+                h = g;
+                g = f;
+                f = e;
+                e = (d + temp1) >>> 0;
+                d = c;
+                c = b;
+                b = a;
+                a = (temp1 + temp2) >>> 0;
+            }
+            h0 = (h0 + a) >>> 0;
+            h1 = (h1 + b) >>> 0;
+            h2 = (h2 + c) >>> 0;
+            h3 = (h3 + d) >>> 0;
+            h4 = (h4 + e) >>> 0;
+            h5 = (h5 + f) >>> 0;
+            h6 = (h6 + g) >>> 0;
+            h7 = (h7 + h) >>> 0;
+        }
+
+        return [h0, h1, h2, h3, h4, h5, h6, h7]
+            .map(valuePart => valuePart.toString(16).padStart(8, '0'))
+            .join('');
+    }
+
+    async function sha256Hex(value) {
+        const normalized = normalizeUnicodeText(value, 'Resource content');
+        const cryptoApi = typeof globalThis !== 'undefined' ? globalThis.crypto : null;
+        if (cryptoApi && cryptoApi.subtle && typeof TextEncoder === 'function') {
+            const digest = await cryptoApi.subtle.digest('SHA-256', new TextEncoder().encode(normalized));
+            return Array.from(new Uint8Array(digest))
+                .map(byte => byte.toString(16).padStart(2, '0'))
+                .join('');
+        }
+        return sha256HexSync(normalized);
+    }
+
+    async function createResourceIdentity(relativePath, legacyId, content) {
+        const displayRelativePath = normalizeUnicodeText(relativePath, 'Relative resource path')
+            .replace(/\\/g, '/')
+            .trim();
+        const canonicalRelativePath = normalizePortablePath(displayRelativePath);
+        const normalizedLegacyId = normalizeUnicodeText(String(legacyId || ''), 'Legacy resource ID').trim();
+        if (!normalizedLegacyId) {
+            throw new Error('Legacy resource ID must not be empty.');
+        }
+        return {
+            sourceUri: createSourceUri(canonicalRelativePath),
+            canonicalId: createCanonicalId(canonicalRelativePath),
+            revision: `sha256:${await sha256Hex(content)}`,
+            identityAliases: Array.from(new Set([
+                normalizedLegacyId,
+                normalizedLegacyId.toLowerCase().endsWith('.md')
+                    ? normalizedLegacyId
+                    : `${normalizedLegacyId}.md`,
+                displayRelativePath,
+                canonicalRelativePath,
+            ])),
+        };
+    }
+
+    return Object.freeze({
+        sourceUriPrefix: SOURCE_URI_PREFIX,
+        normalizePortablePath,
+        createSourceUri,
+        sha256Hex,
+        sha256HexSync,
+        createResourceIdentity,
+    });
+}));