attention-manifest-protocol 0.4.2 → 0.4.3

package/lib/outline/office.js

@@ -0,0 +1,2375 @@
+/**
+ * Read-only Office document parsing.
+ *
+ * The agent workspace exposes `outline`, `import`, `export` and `dependency`
+ * for files, so an Office container must answer the same questions as a source
+ * file: what is inside, what does it point at, and what does it expose? This
+ * module does that without a third-party parser or a runtime dependency:
+ *
+ * - OOXML (`.docx`, `.xlsx`, `.pptx`) is a ZIP of XML parts. `zip.ts` reads the
+ *   archive and a bounded tag scanner below reads the parts. The scanner is
+ *   deliberately not a DOM: it records tag spans, attributes and matching close
+ *   indices, which is enough to walk paragraphs, slides, sheets and formulas
+ *   with a hard tag/depth limit.
+ * - Legacy binaries (`.doc`, `.xls`, `.ppt`, `.pub`) are OLE Compound Files.
+ *   `cfb.ts` extracts named streams and this module recovers printable
+ *   UTF-16LE/ASCII text. That recovery is heuristic and reported as such.
+ * - Access databases (`.accdb`, `.mdb`) use the Jet/ACE format rather than CFB.
+ *   The header is recognised and catalog names are recovered on a best-effort
+ *   basis; no page or column semantics are claimed.
+ * - Anything else is `kind: "unknown"` with an explicit warning instead of a
+ *   guessed parse.
+ *
+ * Parsing is not semantic validation. Word headers/footnotes/comments,
+ * PowerPoint layouts/notes/charts, Excel formula results and Access table
+ * definitions are outside the model. Every result therefore carries warnings
+ * that name the unsupported surface; `officeImports`, `officeExports` and
+ * `officeReferences` expose the facts that were actually recovered.
+ */
+import { lstatSync, readFileSync } from "node:fs";
+import { posix } from "node:path";
+import { rawDigest } from "../fingerprint/raw.js";
+import { readCfb } from "../file/cfb.js";
+import { fail, isFilesystemError } from "../file/errors.js";
+import { hasOfficeOutlineParser, registerOfficeOutlineParser } from "./officeBridge.js";
+import { readZipEntries, zipText } from "../file/zip.js";
+/**
+ * Largest Office file `parseOffice` will load. Legacy containers and OOXML
+ * packages can be much larger than a text outline; `parseOffice` still applies
+ * the same 64 MiB ceiling as the rest of the bounded readers.
+ */
+export const OfficeMaxDocumentBytes = 64 * 1024 * 1024;
+/**
+ * Largest Office file the outline bridge accepts from raw bytes.
+ *
+ * `outline.ts` owns its own 4 MiB text ceiling and routes Office containers
+ * through `readOutlineBytes` before calling the registered parser. Keeping the
+ * same value here means a direct `officeOutlineParser` caller gets
+ * `quota_exceeded` before any container walk, never `binary_file`, and the two
+ * entry points agree on the bound.
+ */
+export const OfficeMaxOutlineBytes = 4 * 1024 * 1024;
+const MaxSections = 2000;
+const MaxReferences = 2000;
+const MaxImports = 500;
+const MaxExports = 1000;
+const MaxWarnings = 48;
+const MaxLabelLength = 200;
+const MaxDetailLength = 200;
+const MaxTextFragments = 500;
+const MaxRawFragments = 4096;
+const MaxTextScanBytes = 48 * 1024 * 1024;
+const MaxXmlTags = 200000;
+const MaxXmlDepth = 256;
+const MaxRelationshipTargets = 500;
+/**
+ * Extensions recognized as Office documents. The map is lowercase; `isOfficeFile`
+ * and `kindFromPath` both fold the caller path before lookup.
+ */
+const OfficeExtensions = {
+    ".docx": "word",
+    ".doc": "word",
+    ".xlsx": "excel",
+    ".xls": "excel",
+    ".pptx": "powerpoint",
+    ".ppt": "powerpoint",
+    ".pub": "publisher",
+    ".accdb": "access",
+    ".mdb": "access",
+};
+/**
+ * Fold a path to its lowercase extension. A dot-file or a path without an
+ * extension yields an empty string.
+ *
+ * @param path - Caller path.
+ * @returns Lowercase extension including the dot, or `""`.
+ */
+const extensionOf = (path) => {
+    const lower = path.toLowerCase();
+    const slash = lower.lastIndexOf("/");
+    const name = slash === -1 ? lower : lower.slice(slash + 1);
+    const dot = name.lastIndexOf(".");
+    return dot <= 0 ? "" : name.slice(dot);
+};
+/**
+ * Classify a path by extension.
+ *
+ * @param path - Caller path.
+ * @returns Office family, or `unknown`.
+ */
+const kindFromPath = (path) => OfficeExtensions[extensionOf(path)] ?? "unknown";
+/**
+ * Whether a path names a supported Office document. The check is purely
+ * syntactic: a file with a `.docx` suffix that is not a ZIP is still routed to
+ * the Office parser so it can report a structured warning.
+ *
+ * @param path - Root-relative or absolute path.
+ * @returns Whether the extension is one of the supported Office extensions.
+ */
+export const isOfficeFile = (path) => kindFromPath(path) !== "unknown";
+/**
+ * Collapse whitespace and bound a label.
+ *
+ * @param value - Raw label.
+ * @param fallback - Text used when the label is empty.
+ * @returns A compact label.
+ */
+const cleanLabel = (value, fallback) => {
+    const text = value.replace(/\s+/g, " ").trim();
+    const chosen = text.length === 0 ? fallback : text;
+    return chosen.slice(0, MaxLabelLength);
+};
+/**
+ * Collapse whitespace and bound a detail/target string.
+ *
+ * @param value - Raw value.
+ * @returns A compact value.
+ */
+const cleanDetail = (value) => value.replace(/\s+/g, " ").trim().slice(0, MaxDetailLength);
+/**
+ * Read ASCII bytes from a buffer without assuming a zero terminator.
+ *
+ * @param bytes - Source bytes.
+ * @param offset - Start offset.
+ * @param length - Maximum byte count.
+ * @returns Printable ASCII characters only.
+ */
+const asciiAt = (bytes, offset, length) => {
+    const end = Math.min(bytes.length, offset + length);
+    let value = "";
+    for (let index = offset; index < end; index += 1) {
+        const code = bytes[index];
+        if (code < 0x20 || code > 0x7e) {
+            break;
+        }
+        value += String.fromCharCode(code);
+    }
+    return value;
+};
+/**
+ * Extract an errno code from an unknown thrown value without trusting it.
+ *
+ * @param error - Caught value.
+ * @returns The string code, or `""`.
+ */
+const errorCode = (error) => {
+    if (typeof (error) !== "object" || error === null) {
+        return "";
+    }
+    const code = error.code;
+    return typeof (code) === "string" ? code : "";
+};
+/**
+ * Translate a host filesystem failure into the closed domain taxonomy.
+ *
+ * @param error - Caught value.
+ * @returns Never; throws a classified error.
+ */
+const mapFsError = (error) => {
+    if (isFilesystemError(error)) {
+        throw error;
+    }
+    switch (errorCode(error)) {
+        case "ENOENT": {
+            return fail("not_found");
+        }
+        case "EACCES":
+        case "EPERM": {
+            return fail("permission_denied");
+        }
+        case "EISDIR": {
+            return fail("not_file");
+        }
+        case "ENOTDIR": {
+            return fail("not_directory");
+        }
+        case "ELOOP": {
+            return fail("symlink_denied");
+        }
+        case "ENOSPC":
+        case "EDQUOT": {
+            return fail("quota_exceeded");
+        }
+        default: {
+            return fail("internal_error");
+        }
+    }
+};
+/**
+ * `lstat` through the domain error taxonomy.
+ *
+ * @param absolute - Host absolute path.
+ * @returns File stats.
+ */
+const statOrFail = (absolute) => {
+    try {
+        return lstatSync(absolute);
+    }
+    catch (error) {
+        return mapFsError(error);
+    }
+};
+/**
+ * Read whole-file bytes through the domain error taxonomy.
+ *
+ * @param absolute - Host absolute path.
+ * @returns File bytes.
+ */
+const readBytesOrFail = (absolute) => {
+    try {
+        return readFileSync(absolute);
+    }
+    catch (error) {
+        return mapFsError(error);
+    }
+};
+/**
+ * Decode the five predefined XML entities and numeric character references.
+ * Unknown entities are left intact so a caller can see exactly what was not
+ * understood.
+ *
+ * @param value - Encoded text.
+ * @returns Decoded text.
+ */
+const decodeXmlEntities = (value) => value.replace(/&(#x[0-9A-Fa-f]+|#[0-9]+|[A-Za-z][A-Za-z0-9]*);/g, (match, entity) => {
+    if (entity === "amp") {
+        return "&";
+    }
+    if (entity === "lt") {
+        return "<";
+    }
+    if (entity === "gt") {
+        return ">";
+    }
+    if (entity === "quot") {
+        return '"';
+    }
+    if (entity === "apos") {
+        return "'";
+    }
+    if (entity === "nbsp") {
+        return "\u00a0";
+    }
+    if (entity.startsWith("#x") || entity.startsWith("#X")) {
+        const code = Number.parseInt(entity.slice(2), 16);
+        return Number.isSafeInteger(code) && code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : match;
+    }
+    if (entity.startsWith("#")) {
+        const code = Number.parseInt(entity.slice(1), 10);
+        return Number.isSafeInteger(code) && code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : match;
+    }
+    return match;
+});
+/**
+ * Remove comments, CDATA markers and any residual tags from a text fragment,
+ * then decode entities. Used for the content of `<w:t>`, `<a:t>`, `<f>` and
+ * similar leaf elements where nested markup is not expected.
+ *
+ * @param value - Leaf content.
+ * @returns Plain text.
+ */
+const xmlText = (value) => decodeXmlEntities(value
+    .replace(/<!--[\s\S]*?-->/g, "")
+    .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1")
+    .replace(/<[^>]*>/g, ""));
+/**
+ * Find the `>` that closes a tag, ignoring `>` characters inside quoted
+ * attribute values.
+ *
+ * @param xml - Source XML.
+ * @param start - Offset of `<`.
+ * @returns Offset of `>`, or `-1`.
+ */
+const findTagEnd = (xml, start) => {
+    let quote = "";
+    for (let index = start + 1; index < xml.length; index += 1) {
+        const char = xml[index];
+        if (quote.length > 0) {
+            if (char === quote) {
+                quote = "";
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === ">") {
+            return index;
+        }
+    }
+    return -1;
+};
+/**
+ * Parse the attribute section of an open tag. Attribute values may be single or
+ * double quoted; entity references are decoded.
+ *
+ * @param body - Tag text between `<` and `>`, trimmed.
+ * @param from - Index after the tag name.
+ * @returns Attribute map.
+ */
+const parseAttributes = (body, from) => {
+    const attrs = {};
+    let index = from;
+    while (index < body.length) {
+        while (index < body.length && /\s/.test(body[index])) {
+            index += 1;
+        }
+        if (index >= body.length || body[index] === "/") {
+            break;
+        }
+        const equals = body.indexOf("=", index);
+        if (equals === -1) {
+            break;
+        }
+        const name = body.slice(index, equals).trim();
+        let valueStart = equals + 1;
+        while (valueStart < body.length && /\s/.test(body[valueStart])) {
+            valueStart += 1;
+        }
+        const quote = body[valueStart] ?? "";
+        if (quote !== '"' && quote !== "'") {
+            break;
+        }
+        const valueEnd = body.indexOf(quote, valueStart + 1);
+        if (valueEnd === -1) {
+            break;
+        }
+        if (name.length > 0) {
+            attrs[name] = decodeXmlEntities(body.slice(valueStart + 1, valueEnd));
+        }
+        index = valueEnd + 1;
+    }
+    return attrs;
+};
+/**
+ * Scan XML into an ordered tag list with bounded nesting and tag count.
+ *
+ * This is intentionally not a validating parser. It recognises comments,
+ * processing instructions, CDATA sections and doctype declarations, handles
+ * quoted `>` characters and records matching close indices with a stack. A
+ * document that exceeds the tag or depth ceiling throws; Office callers turn
+ * that into a warning because a single oversized part should not discard the
+ * rest of the package.
+ *
+ * @param xml - XML text.
+ * @returns Tags with matching-close indices.
+ */
+const scanXml = (xml) => {
+    const tags = [];
+    const closeOf = [];
+    const stack = [];
+    let depth = 0;
+    let index = 0;
+    while (index < xml.length) {
+        const start = xml.indexOf("<", index);
+        if (start === -1) {
+            break;
+        }
+        if (xml.startsWith("<!--", start)) {
+            const end = xml.indexOf("-->", start + 4);
+            if (end === -1) {
+                break;
+            }
+            index = end + 3;
+            continue;
+        }
+        if (xml.startsWith("<![CDATA[", start)) {
+            const end = xml.indexOf("]]>", start + 9);
+            if (end === -1) {
+                break;
+            }
+            index = end + 3;
+            continue;
+        }
+        const next = xml[start + 1] ?? "";
+        if (next === "!" || next === "?") {
+            const end = findTagEnd(xml, start);
+            if (end === -1) {
+                break;
+            }
+            index = end + 1;
+            continue;
+        }
+        const end = findTagEnd(xml, start);
+        if (end === -1) {
+            throw new Error("unterminated xml tag");
+        }
+        const body = xml.slice(start + 1, end).trim();
+        index = end + 1;
+        if (body.length === 0) {
+            continue;
+        }
+        const closing = body.startsWith("/");
+        const content = closing ? body.slice(1).trim() : body;
+        const selfClosing = !closing && content.endsWith("/");
+        const withoutSlash = selfClosing ? content.slice(0, -1).trimEnd() : content;
+        let nameEnd = 0;
+        while (nameEnd < withoutSlash.length && !/\s/.test(withoutSlash[nameEnd])) {
+            nameEnd += 1;
+        }
+        const name = withoutSlash.slice(0, nameEnd);
+        if (name.length === 0) {
+            continue;
+        }
+        const colon = name.lastIndexOf(":");
+        const local = colon === -1 ? name : name.slice(colon + 1);
+        const attrs = closing ? {} : parseAttributes(withoutSlash, nameEnd);
+        const tagIndex = tags.length;
+        tags.push({ name, local, closing, selfClosing, attrs, start, end: end + 1 });
+        closeOf.push(-1);
+        if (tags.length > MaxXmlTags) {
+            throw new Error("xml tag limit exceeded");
+        }
+        if (closing) {
+            depth = Math.max(0, depth - 1);
+            const open = stack.pop();
+            if (open !== (void 0)) {
+                closeOf[open] = tagIndex;
+            }
+        }
+        else if (!selfClosing) {
+            depth += 1;
+            if (depth > MaxXmlDepth) {
+                throw new Error("xml nesting limit exceeded");
+            }
+            stack.push(tagIndex);
+        }
+    }
+    return { tags, closeOf, unclosed: stack.length };
+};
+/**
+ * Attribute lookup with namespace-prefix fallback: an exact `r:id` wins over a
+ * bare `id`, and `w:val` is found when the caller only knows the local name.
+ *
+ * @param tag - Tag to inspect.
+ * @param name - Qualified or local attribute name.
+ * @returns Attribute value, or `""`.
+ */
+const xmlAttr = (tag, name) => {
+    const direct = tag.attrs[name];
+    if (direct !== (void 0)) {
+        return direct;
+    }
+    const colon = name.lastIndexOf(":");
+    const local = colon === -1 ? name : name.slice(colon + 1);
+    const keys = Object.keys(tag.attrs);
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        const keyColon = key.lastIndexOf(":");
+        const keyLocal = keyColon === -1 ? key : key.slice(keyColon + 1);
+        if (keyLocal === local) {
+            return tag.attrs[key];
+        }
+    }
+    return "";
+};
+/**
+ * Text content of one element, using its precomputed matching close.
+ *
+ * @param xml - Source XML.
+ * @param scan - Tag scan for the same source.
+ * @param index - Index of the open tag.
+ * @returns Decoded inner text, or `""` when the element is self-closing or
+ * unclosed.
+ */
+const xmlInnerText = (xml, scan, index) => {
+    const tag = scan.tags[index];
+    if (tag.selfClosing) {
+        return "";
+    }
+    const close = scan.closeOf[index];
+    if (close < 0) {
+        return "";
+    }
+    return xmlText(xml.slice(tag.end, scan.tags[close].start));
+};
+/**
+ * First child element with a given local name inside an open element.
+ *
+ * @param scan - Tag scan.
+ * @param openIndex - Enclosing open tag.
+ * @param local - Local child name.
+ * @returns Index of the child, or `-1`.
+ */
+const xmlChild = (scan, openIndex, local) => {
+    const close = scan.closeOf[openIndex];
+    const end = close < 0 ? scan.tags.length : close;
+    for (let index = openIndex + 1; index < end; index += 1) {
+        const tag = scan.tags[index];
+        if (!tag.closing && tag.local === local) {
+            return index;
+        }
+    }
+    return -1;
+};
+/**
+ * Text of the first matching child element.
+ *
+ * @param xml - Source XML.
+ * @param scan - Tag scan.
+ * @param openIndex - Enclosing open tag.
+ * @param local - Local child name.
+ * @returns Decoded text, or `""`.
+ */
+const xmlChildText = (xml, scan, openIndex, local) => {
+    const child = xmlChild(scan, openIndex, local);
+    return child === -1 ? "" : xmlInnerText(xml, scan, child);
+};
+/**
+ * Resolve an internal OOXML relationship target against its source part.
+ *
+ * @param sourcePart - Part that owns the relationship.
+ * @param target - Relationship target as written.
+ * @returns Normalized package part name.
+ */
+const resolvePart = (sourcePart, target) => {
+    if (target.startsWith("/")) {
+        return posix.normalize(target.slice(1)).replace(/^\.\//, "");
+    }
+    return posix.normalize(posix.join(posix.dirname(sourcePart), target)).replace(/^\.\//, "");
+};
+/**
+ * Path of the relationships part for an OOXML part.
+ *
+ * @param part - Source part name.
+ * @returns Relationships part name.
+ */
+const relationshipsPart = (part) => {
+    const directory = posix.dirname(part);
+    const file = `${posix.basename(part)}.rels`;
+    return directory === "." ? `_rels/${file}` : `${directory}/_rels/${file}`;
+};
+/**
+ * Read a relationships part. Missing parts are normal (a minimal fixture or a
+ * package without links), so this returns an empty list rather than warning.
+ *
+ * @param entries - OOXML package parts.
+ * @param part - Source part name.
+ * @returns Relationships in document order.
+ */
+const readRelationships = (entries, part) => {
+    const xml = zipText(entries, relationshipsPart(part));
+    if (xml === (void 0)) {
+        return [];
+    }
+    const scan = scanXml(xml);
+    const relationships = [];
+    for (let index = 0; index < scan.tags.length && relationships.length < MaxRelationshipTargets; index += 1) {
+        const tag = scan.tags[index];
+        if (tag.closing || tag.local !== "Relationship") {
+            continue;
+        }
+        const id = xmlAttr(tag, "Id");
+        const type = xmlAttr(tag, "Type");
+        const rawTarget = xmlAttr(tag, "Target");
+        if (rawTarget.length === 0) {
+            continue;
+        }
+        const external = xmlAttr(tag, "TargetMode") === "External";
+        relationships.push({
+            id,
+            type,
+            target: external ? rawTarget : resolvePart(part, rawTarget),
+            external,
+        });
+    }
+    return relationships;
+};
+/**
+ * Index a relationship list by id.
+ *
+ * @param relationships - Relationships to index.
+ * @returns Id to relationship.
+ */
+const relationshipMap = (relationships) => {
+    const map = new Map();
+    for (let index = 0; index < relationships.length; index += 1) {
+        map.set(relationships[index].id, relationships[index]);
+    }
+    return map;
+};
+/**
+ * Create the empty document and its context.
+ *
+ * @param path - Root-relative path.
+ * @param kind - Initial family guess.
+ * @param format - Container format.
+ * @param bytes - Complete file bytes.
+ * @returns Context for one parse.
+ */
+const createContext = (path, kind, format, bytes) => {
+    const document = {
+        path,
+        kind,
+        format,
+        bytes: BigInt(bytes.byteLength),
+        fingerprint: rawDigest(bytes),
+        sections: [],
+        references: [],
+        imports: [],
+        exports: [],
+        metadata: {},
+        warnings: [],
+    };
+    return {
+        document,
+        sections: document.sections,
+        referenceKeys: new Set(),
+        exportKeys: new Set(),
+        importKeys: new Set(),
+        warningKeys: new Set(),
+        count: 0,
+        truncated: false,
+    };
+};
+/**
+ * Add a warning, deduplicated and bounded.
+ *
+ * @param context - Parse context.
+ * @param message - Human-readable warning.
+ */
+const pushWarning = (context, message) => {
+    const clean = message.replace(/\s+/g, " ").trim().slice(0, 240);
+    if (clean.length === 0 || context.warningKeys.has(clean) || context.document.warnings.length >= MaxWarnings) {
+        return;
+    }
+    context.warningKeys.add(clean);
+    context.document.warnings.push(clean);
+};
+/**
+ * Set one metadata value when it is non-empty.
+ *
+ * @param context - Parse context.
+ * @param key - Metadata key.
+ * @param value - Raw value.
+ */
+const setMetadata = (context, key, value) => {
+    const clean = value.replace(/\s+/g, " ").trim().slice(0, 300);
+    if (clean.length > 0) {
+        context.document.metadata[key] = clean;
+    }
+};
+/**
+ * Append a section and return it, or `undefined` once the section budget is
+ * exhausted. Children are appended pre-order, so `index` matches document
+ * order.
+ *
+ * @param context - Parse context.
+ * @param parent - Parent section, or `undefined` for a root section.
+ * @param kind - Section kind.
+ * @param label - Raw label.
+ * @param depth - Hierarchy depth.
+ * @returns The new section, or `undefined` when truncated.
+ */
+const appendSection = (context, parent, kind, label, depth) => {
+    if (context.count >= MaxSections) {
+        context.truncated = true;
+        return undefined;
+    }
+    const index = context.count;
+    context.count += 1;
+    const section = {
+        id: `${kind}-${index}`,
+        label: cleanLabel(label, `Section ${index + 1}`),
+        kind,
+        depth: Math.max(0, Math.trunc(depth)),
+        index,
+        children: [],
+    };
+    if (parent === (void 0)) {
+        context.sections.push(section);
+    }
+    else {
+        parent.children.push(section);
+    }
+    return section;
+};
+/**
+ * Add an outbound reference, deduplicated by kind/from/target.
+ *
+ * @param context - Parse context.
+ * @param reference - Reference to add.
+ */
+const addReference = (context, reference) => {
+    if (context.document.references.length >= MaxReferences) {
+        return;
+    }
+    const target = cleanDetail(reference.target);
+    const from = cleanDetail(reference.from);
+    if (target.length === 0) {
+        return;
+    }
+    const key = `${reference.kind}\u0000${from}\u0000${target}`;
+    if (context.referenceKeys.has(key)) {
+        return;
+    }
+    context.referenceKeys.add(key);
+    const detail = cleanDetail(reference.detail ?? "");
+    context.document.references.push({
+        kind: reference.kind,
+        from,
+        target,
+        ...(detail.length === 0 ? {} : { detail }),
+    });
+};
+/**
+ * Add an external import target, deduplicated.
+ *
+ * @param context - Parse context.
+ * @param target - URL or external path.
+ */
+const addImport = (context, target) => {
+    const clean = cleanDetail(target);
+    if (clean.length === 0 || context.importKeys.has(clean) || context.document.imports.length >= MaxImports) {
+        return;
+    }
+    context.importKeys.add(clean);
+    context.document.imports.push(clean);
+};
+/**
+ * Add an exported name, deduplicated.
+ *
+ * @param context - Parse context.
+ * @param name - Exported symbol or object name.
+ */
+const addExport = (context, name) => {
+    const clean = cleanLabel(name, "");
+    if (clean.length === 0 || context.exportKeys.has(clean) || context.document.exports.length >= MaxExports) {
+        return;
+    }
+    context.exportKeys.add(clean);
+    context.document.exports.push(clean);
+};
+/**
+ * Read `docProps/core.xml` and `docProps/app.xml` into metadata.
+ *
+ * @param context - Parse context.
+ * @param entries - OOXML package parts.
+ */
+const readDocumentProperties = (context, entries) => {
+    const core = zipText(entries, "docProps/core.xml");
+    if (core !== (void 0)) {
+        const scan = scanXml(core);
+        const fieldKeys = {
+            title: "title",
+            creator: "creator",
+            lastModifiedBy: "lastModifiedBy",
+            created: "created",
+            modified: "modified",
+            subject: "subject",
+            description: "description",
+            keywords: "keywords",
+            category: "category",
+        };
+        for (let index = 0; index < scan.tags.length; index += 1) {
+            const tag = scan.tags[index];
+            if (tag.closing || tag.selfClosing) {
+                continue;
+            }
+            const key = fieldKeys[tag.local];
+            if (key === (void 0)) {
+                continue;
+            }
+            setMetadata(context, key, xmlInnerText(core, scan, index));
+        }
+    }
+    const app = zipText(entries, "docProps/app.xml");
+    if (app !== (void 0)) {
+        const scan = scanXml(app);
+        const fieldKeys = {
+            Application: "application",
+            Company: "company",
+            AppVersion: "appVersion",
+            Pages: "pages",
+            Words: "words",
+            Slides: "slides",
+            Worksheets: "worksheets",
+        };
+        for (let index = 0; index < scan.tags.length; index += 1) {
+            const tag = scan.tags[index];
+            if (tag.closing || tag.selfClosing) {
+                continue;
+            }
+            const key = fieldKeys[tag.local];
+            if (key === (void 0)) {
+                continue;
+            }
+            setMetadata(context, key, xmlInnerText(app, scan, index));
+        }
+    }
+};
+/**
+ * Heading level for a Word paragraph, from an explicit outline level (which
+ * wins) or a built-in Heading/Title style id.
+ *
+ * @param style - Style id from `<w:pStyle w:val>`.
+ * @param outline - Raw outline level from `<w:outlineLvl w:val>`.
+ * @returns One-based heading level, or `0` for body text.
+ */
+const wordHeadingLevel = (style, outline) => {
+    if (outline.length > 0) {
+        const value = Number.parseInt(outline, 10);
+        if (Number.isSafeInteger(value) && value >= 0 && value <= 8) {
+            return value + 1;
+        }
+    }
+    const heading = /^Heading\s*([1-9])$/i.exec(style.trim());
+    if (heading !== null) {
+        return Number(heading[1]);
+    }
+    return /^Title$/i.test(style.trim()) ? 1 : 0;
+};
+/**
+ * Parse `word/document.xml` into heading/paragraph sections plus bookmarks.
+ *
+ * @param context - Parse context.
+ * @param entries - OOXML package parts.
+ */
+const parseWord = (context, entries) => {
+    const xml = zipText(entries, "word/document.xml");
+    if (xml === (void 0)) {
+        pushWarning(context, "word package has no word/document.xml");
+        return;
+    }
+    const scan = scanXml(xml);
+    const paragraphs = [];
+    let current;
+    let nested = 0;
+    for (let index = 0; index < scan.tags.length; index += 1) {
+        const tag = scan.tags[index];
+        if (tag.local === "p" && !tag.closing) {
+            if (tag.selfClosing) {
+                continue;
+            }
+            if (current === (void 0)) {
+                current = { texts: [], style: "", outline: "" };
+            }
+            else {
+                nested += 1;
+            }
+            continue;
+        }
+        if (tag.local === "p" && tag.closing) {
+            if (current === (void 0)) {
+                continue;
+            }
+            if (nested > 0) {
+                nested -= 1;
+                continue;
+            }
+            paragraphs.push({ text: current.texts.join(""), style: current.style, outline: current.outline });
+            current = undefined;
+            continue;
+        }
+        if (tag.local === "bookmarkStart" && !tag.closing) {
+            const bookmark = xmlAttr(tag, "w:name");
+            if (bookmark.length > 0 && bookmark !== "_GoBack") {
+                addExport(context, bookmark);
+                addReference(context, { kind: "bookmark", from: context.document.path, target: bookmark, detail: "bookmark" });
+            }
+            continue;
+        }
+        if (current === (void 0)) {
+            continue;
+        }
+        if (tag.local === "t" && !tag.closing) {
+            const text = xmlInnerText(xml, scan, index);
+            if (text.length > 0) {
+                current.texts.push(text);
+            }
+        }
+        else if (tag.local === "pStyle" && !tag.closing) {
+            current.style = xmlAttr(tag, "w:val");
+        }
+        else if (tag.local === "outlineLvl" && !tag.closing) {
+            current.outline = xmlAttr(tag, "w:val");
+        }
+        else if (tag.local === "hyperlink" && !tag.closing) {
+            const anchor = xmlAttr(tag, "w:anchor");
+            if (anchor.length > 0) {
+                addReference(context, { kind: "bookmark", from: context.document.path, target: `#${anchor}`, detail: "internal bookmark" });
+            }
+        }
+    }
+    if (current !== (void 0)) {
+        paragraphs.push({ text: current.texts.join(""), style: current.style, outline: current.outline });
+    }
+    const headingStack = [];
+    for (let index = 0; index < paragraphs.length; index += 1) {
+        const paragraph = paragraphs[index];
+        const text = cleanLabel(paragraph.text, "");
+        if (text.length === 0) {
+            continue;
+        }
+        const level = wordHeadingLevel(paragraph.style, paragraph.outline);
+        if (level > 0) {
+            while (headingStack.length > 0 && headingStack[headingStack.length - 1].level >= level) {
+                headingStack.pop();
+            }
+            const parent = headingStack[headingStack.length - 1];
+            const section = appendSection(context, parent === (void 0) ? undefined : parent.section, "heading", text, parent === (void 0) ? level - 1 : parent.section.depth + 1);
+            if (section !== (void 0)) {
+                headingStack.push({ level, section });
+            }
+        }
+        else {
+            const parent = headingStack[headingStack.length - 1];
+            appendSection(context, parent === (void 0) ? undefined : parent.section, "paragraph", text, parent === (void 0) ? 0 : parent.section.depth + 1);
+        }
+    }
+    const relationships = readRelationships(entries, "word/document.xml");
+    for (let index = 0; index < relationships.length; index += 1) {
+        const relationship = relationships[index];
+        const type = relationship.type.toLowerCase();
+        if (type.endsWith("/hyperlink")) {
+            addReference(context, {
+                kind: "hyperlink",
+                from: context.document.path,
+                target: relationship.target,
+                detail: relationship.external ? "external hyperlink" : "internal hyperlink",
+            });
+        }
+        else if (relationship.external) {
+            addReference(context, { kind: "external-link", from: context.document.path, target: relationship.target, detail: "external relationship" });
+        }
+        else if (type.endsWith("/image") ||
+            type.endsWith("/oleobject") ||
+            type.endsWith("/package") ||
+            type.endsWith("/diagramdata") ||
+            type.endsWith("/chart")) {
+            addReference(context, { kind: "embedded", from: context.document.path, target: relationship.target, detail: "embedded part" });
+        }
+        else {
+            continue;
+        }
+        if (relationship.external) {
+            addImport(context, relationship.target);
+        }
+    }
+    pushWarning(context, "word: main document body only; headers, footnotes, comments, revisions, text boxes and embedded objects are not expanded");
+};
+/**
+ * Read shared strings. The cell content is not projected into the outline, but
+ * reading the part validates it and records its size; a malformed shared-string
+ * part is downgraded to a warning rather than failing the workbook.
+ *
+ * @param context - Parse context.
+ * @param entries - OOXML package parts.
+ * @returns Decoded shared strings.
+ */
+const readSharedStrings = (context, entries) => {
+    const xml = zipText(entries, "xl/sharedStrings.xml");
+    if (xml === (void 0)) {
+        return [];
+    }
+    try {
+        const scan = scanXml(xml);
+        const strings = [];
+        for (let index = 0; index < scan.tags.length && strings.length < 10000; index += 1) {
+            const tag = scan.tags[index];
+            if (tag.closing || tag.selfClosing || tag.local !== "si") {
+                continue;
+            }
+            const close = scan.closeOf[index];
+            const end = close < 0 ? scan.tags.length : close;
+            let text = "";
+            for (let child = index + 1; child < end; child += 1) {
+                const childTag = scan.tags[child];
+                if (!childTag.closing && childTag.local === "t") {
+                    text += xmlInnerText(xml, scan, child);
+                }
+            }
+            strings.push(text);
+        }
+        return strings;
+    }
+    catch (error) {
+        pushWarning(context, `excel: shared strings ignored (${error instanceof Error ? error.message : "parse failure"})`);
+        return [];
+    }
+};
+/**
+ * Read the workbook sheet list and defined names. Sheet order is the order of
+ * `<sheet>` elements; each is resolved through the workbook relationships with
+ * a name-based fallback for minimal packages.
+ *
+ * @param context - Parse context.
+ * @param entries - OOXML package parts.
+ * @returns Sheets and defined names.
+ */
+const readWorkbook = (context, entries) => {
+    const xml = zipText(entries, "xl/workbook.xml");
+    if (xml === (void 0)) {
+        pushWarning(context, "excel package has no xl/workbook.xml");
+        return { sheets: [], names: [] };
+    }
+    const scan = scanXml(xml);
+    const relationships = relationshipMap(readRelationships(entries, "xl/workbook.xml"));
+    const sheets = [];
+    const names = [];
+    for (let index = 0; index < scan.tags.length; index += 1) {
+        const tag = scan.tags[index];
+        if (tag.closing) {
+            continue;
+        }
+        if (tag.local === "sheet") {
+            const name = cleanLabel(xmlAttr(tag, "name"), `Sheet ${sheets.length + 1}`);
+            const relationId = xmlAttr(tag, "r:id");
+            const relationship = relationships.get(relationId);
+            const fallback = `xl/worksheets/sheet${sheets.length + 1}.xml`;
+            sheets.push({ name, relationId, part: relationship === (void 0) ? fallback : relationship.target });
+        }
+        else if (tag.local === "definedName") {
+            const name = cleanLabel(xmlAttr(tag, "name"), "");
+            if (name.length === 0) {
+                continue;
+            }
+            const localRaw = xmlAttr(tag, "localSheetId");
+            const localSheetIndex = localRaw.length === 0 ? -1 : Number.parseInt(localRaw, 10);
+            names.push({ name, localSheetIndex: Number.isSafeInteger(localSheetIndex) ? localSheetIndex : -1, formula: xmlInnerText(xml, scan, index) });
+        }
+    }
+    return { sheets, names };
+};
+/**
+ * Replace double-quoted Excel string literals with spaces, preserving offsets
+ * so reference positions in the original formula remain meaningful.
+ *
+ * @param formula - Formula text.
+ * @returns Masked character array joined back into a string.
+ */
+const maskFormulaStrings = (formula) => {
+    const chars = formula.split("");
+    let index = 0;
+    while (index < chars.length) {
+        if (chars[index] !== '"') {
+            index += 1;
+            continue;
+        }
+        chars[index] = " ";
+        index += 1;
+        while (index < chars.length) {
+            if (chars[index] === '"') {
+                if (index + 1 < chars.length && chars[index + 1] === '"') {
+                    chars[index] = " ";
+                    chars[index + 1] = " ";
+                    index += 2;
+                    continue;
+                }
+                chars[index] = " ";
+                index += 1;
+                break;
+            }
+            chars[index] = " ";
+            index += 1;
+        }
+    }
+    return chars.join("");
+};
+/**
+ * Blank a matched span so a later, less specific regex cannot report the same
+ * token as a different reference kind.
+ *
+ * @param chars - Mutable character array.
+ * @param start - Match start.
+ * @param length - Match length.
+ */
+const maskSpan = (chars, start, length) => {
+    for (let index = start; index < start + length && index < chars.length; index += 1) {
+        chars[index] = " ";
+    }
+};
+/**
+ * Extract A1, Sheet!A1 and [n]Sheet!A1 references from one formula.
+ *
+ * External workbook references are resolved through the package's external
+ * link parts when available; the unresolved `[n]` form is kept otherwise. Only
+ * lexical references are reported: formulas are not evaluated, shared formulas
+ * are not expanded and dynamic references are not inferred.
+ *
+ * @param context - Parse context.
+ * @param formula - Cell formula without the leading `=`.
+ * @param sheetName - Sheet that owns the cell.
+ * @param address - Cell address such as `B4`.
+ * @param externalTargets - External link index to target path.
+ */
+const addFormulaReferences = (context, formula, sheetName, address, externalTargets) => {
+    if (formula.length === 0) {
+        return;
+    }
+    const masked = maskFormulaStrings(formula);
+    const chars = masked.split("");
+    const from = `${sheetName}!${address}`;
+    const external = /(?:'\[(\d+)\]([^']*)'|\[(\d+)\]([A-Za-z0-9_.]+))!(\$?[A-Z]{1,3}\$?[1-9]\d*)/g;
+    let match = external.exec(masked);
+    while (match !== null) {
+        const linkIndex = Number(match[1] ?? match[3]);
+        const targetSheet = match[2] ?? match[4] ?? "";
+        const targetAddress = match[5];
+        const target = `[${linkIndex}]${targetSheet}!${targetAddress}`;
+        addReference(context, { kind: "formula", from, target, detail: "external workbook reference" });
+        const resolved = externalTargets.get(linkIndex);
+        if (resolved !== (void 0)) {
+            addImport(context, resolved);
+        }
+        maskSpan(chars, match.index, match[0].length);
+        match = external.exec(masked);
+    }
+    const afterExternal = chars.join("");
+    const sheetPattern = /(?<![\w\]'])(?:'((?:[^']|'')+)'|([A-Za-z_][A-Za-z0-9_.]*))!(\$?[A-Z]{1,3}\$?[1-9]\d*)/g;
+    let sheetMatch = sheetPattern.exec(afterExternal);
+    while (sheetMatch !== null) {
+        const targetSheet = (sheetMatch[1] ?? sheetMatch[2] ?? "").replace(/''/g, "'");
+        const targetAddress = sheetMatch[3];
+        if (!targetSheet.startsWith("[")) {
+            addReference(context, { kind: "formula", from, target: `${targetSheet}!${targetAddress}`, detail: "sheet reference" });
+            maskSpan(chars, sheetMatch.index, sheetMatch[0].length);
+        }
+        sheetMatch = sheetPattern.exec(afterExternal);
+    }
+    const rest = chars.join("");
+    const plain = /(?<![A-Za-z0-9_.$])\$?[A-Z]{1,3}\$?[1-9]\d*(?![A-Za-z0-9_(])/g;
+    let plainMatch = plain.exec(rest);
+    while (plainMatch !== null) {
+        addReference(context, { kind: "formula", from, target: plainMatch[0], detail: "cell reference" });
+        plainMatch = plain.exec(rest);
+    }
+};
+/**
+ * Read external-link targets. `xl/externalLinks/externalLinkN.xml` has a
+ * relationships part whose external target is the linked workbook.
+ *
+ * @param entries - OOXML package parts.
+ * @returns External link index to target.
+ */
+const readExternalTargets = (entries) => {
+    const targets = new Map();
+    const names = Array.from(entries.keys()).filter((name) => /^xl\/externalLinks\/externalLink[0-9]+\.xml$/.test(name));
+    names.sort((left, right) => {
+        const leftNumber = Number(/externalLink([0-9]+)\.xml$/.exec(left)?.[1] ?? 0);
+        const rightNumber = Number(/externalLink([0-9]+)\.xml$/.exec(right)?.[1] ?? 0);
+        return leftNumber - rightNumber;
+    });
+    for (let index = 0; index < names.length; index += 1) {
+        const name = names[index];
+        const linkIndex = Number(/externalLink([0-9]+)\.xml$/.exec(name)?.[1] ?? names.length + 1);
+        const relationships = readRelationships(entries, name);
+        const external = relationships.find((relationship) => relationship.external);
+        if (external !== (void 0)) {
+            targets.set(linkIndex, external.target);
+        }
+    }
+    return targets;
+};
+/**
+ * Read worksheet tables through the worksheet relationships.
+ *
+ * @param entries - OOXML package parts.
+ * @param sheetPart - Worksheet part.
+ * @returns Table definitions in relationship order.
+ */
+const readSheetTables = (entries, sheetPart) => {
+    const relationships = readRelationships(entries, sheetPart);
+    const tables = [];
+    for (let index = 0; index < relationships.length; index += 1) {
+        const relationship = relationships[index];
+        if (!relationship.type.toLowerCase().endsWith("/table") || relationship.external) {
+            continue;
+        }
+        const xml = zipText(entries, relationship.target);
+        if (xml === (void 0)) {
+            continue;
+        }
+        try {
+            const scan = scanXml(xml);
+            for (let tagIndex = 0; tagIndex < scan.tags.length; tagIndex += 1) {
+                const tag = scan.tags[tagIndex];
+                if (tag.closing || tag.local !== "table") {
+                    continue;
+                }
+                const name = cleanLabel(xmlAttr(tag, "name"), "");
+                const displayName = cleanLabel(xmlAttr(tag, "displayName"), name);
+                const ref = cleanLabel(xmlAttr(tag, "ref"), "");
+                if (displayName.length > 0) {
+                    tables.push({ name, displayName, ref });
+                }
+                break;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return tables;
+};
+/**
+ * Parse one worksheet: formulas and hyperlinks. Cell values and shared strings
+ * are deliberately not emitted as outline nodes; the sheet/table/named-range
+ * hierarchy is the structural contract for this format.
+ *
+ * @param context - Parse context.
+ * @param entries - OOXML package parts.
+ * @param sheet - Sheet definition.
+ * @param externalTargets - External link index to target.
+ * @returns Whether the worksheet part was readable.
+ */
+const parseWorksheet = (context, entries, sheet, externalTargets) => {
+    const xml = zipText(entries, sheet.part);
+    if (xml === (void 0)) {
+        pushWarning(context, `excel: worksheet part ${sheet.part} is missing`);
+        return false;
+    }
+    const scan = scanXml(xml);
+    const relationships = relationshipMap(readRelationships(entries, sheet.part));
+    for (let index = 0; index < scan.tags.length; index += 1) {
+        const tag = scan.tags[index];
+        if (tag.closing) {
+            continue;
+        }
+        if (tag.local === "c") {
+            const address = xmlAttr(tag, "r");
+            if (!/^[A-Z]{1,3}[1-9][0-9]*$/.test(address)) {
+                continue;
+            }
+            const formula = xmlChildText(xml, scan, index, "f");
+            if (formula.length > 0) {
+                addFormulaReferences(context, formula, sheet.name, address, externalTargets);
+            }
+        }
+        else if (tag.local === "hyperlink") {
+            const relationshipId = xmlAttr(tag, "r:id");
+            const location = xmlAttr(tag, "location");
+            const relationship = relationships.get(relationshipId);
+            if (relationship !== (void 0)) {
+                addReference(context, {
+                    kind: "hyperlink",
+                    from: `${sheet.name}!${xmlAttr(tag, "ref")}`,
+                    target: relationship.target,
+                    detail: relationship.external ? "external hyperlink" : "internal hyperlink",
+                });
+                if (relationship.external) {
+                    addImport(context, relationship.target);
+                }
+            }
+            else if (location.length > 0) {
+                addReference(context, {
+                    kind: "hyperlink",
+                    from: `${sheet.name}!${xmlAttr(tag, "ref")}`,
+                    target: `#${location}`,
+                    detail: "internal hyperlink",
+                });
+            }
+        }
+    }
+    return true;
+};
+/**
+ * Parse an OOXML spreadsheet into sheet sections with table and named-range
+ * children.
+ *
+ * @param context - Parse context.
+ * @param entries - OOXML package parts.
+ */
+const parseExcel = (context, entries) => {
+    const workbook = readWorkbook(context, entries);
+    const sharedStrings = readSharedStrings(context, entries);
+    const externalTargets = readExternalTargets(entries);
+    for (let index = 0; index < externalTargets.size; index += 1) {
+        const entry = Array.from(externalTargets.entries())[index];
+        if (entry !== (void 0)) {
+            addReference(context, { kind: "external-link", from: context.document.path, target: entry[1], detail: `external workbook [${entry[0]}]` });
+            addImport(context, entry[1]);
+        }
+    }
+    if (workbook.sheets.length === 0) {
+        pushWarning(context, "excel: workbook defines no sheets");
+    }
+    for (let index = 0; index < workbook.sheets.length; index += 1) {
+        const sheet = workbook.sheets[index];
+        const sheetSection = appendSection(context, undefined, "sheet", sheet.name, 0);
+        try {
+            parseWorksheet(context, entries, sheet, externalTargets);
+        }
+        catch (error) {
+            pushWarning(context, `excel: sheet ${sheet.name} could not be parsed (${error instanceof Error ? error.message : "parse failure"})`);
+        }
+        const tables = readSheetTables(entries, sheet.part);
+        for (let tableIndex = 0; tableIndex < tables.length; tableIndex += 1) {
+            const table = tables[tableIndex];
+            if (sheetSection !== (void 0)) {
+                appendSection(context, sheetSection, "table", table.displayName, 1);
+            }
+            addExport(context, table.displayName);
+        }
+        for (let nameIndex = 0; nameIndex < workbook.names.length; nameIndex += 1) {
+            const defined = workbook.names[nameIndex];
+            if (defined.localSheetIndex !== index) {
+                continue;
+            }
+            if (sheetSection !== (void 0)) {
+                appendSection(context, sheetSection, "section", defined.name, 1);
+            }
+            addExport(context, defined.name);
+            addReference(context, { kind: "named-range", from: context.document.path, target: defined.name, detail: defined.formula });
+        }
+    }
+    const globalNames = workbook.names.filter((name) => name.localSheetIndex < 0);
+    if (globalNames.length > 0) {
+        const namedSection = appendSection(context, undefined, "section", "Named ranges", 0);
+        for (let index = 0; index < globalNames.length; index += 1) {
+            const defined = globalNames[index];
+            if (namedSection !== (void 0)) {
+                appendSection(context, namedSection, "section", defined.name, 1);
+            }
+            addExport(context, defined.name);
+            addReference(context, { kind: "named-range", from: context.document.path, target: defined.name, detail: defined.formula });
+        }
+    }
+    setMetadata(context, "excel.sheets", String(workbook.sheets.length));
+    setMetadata(context, "excel.definedNames", String(workbook.names.length));
+    setMetadata(context, "excel.sharedStrings", String(sharedStrings.length));
+    pushWarning(context, "excel: formulas are not evaluated; cell values remain cached; shared/dynamic/external references beyond literal A1 syntax are not expanded");
+};
+/**
+ * Read the slide order through presentation relationships, with a numeric
+ * part-name fallback for packages that omit the relationship part.
+ *
+ * @param entries - OOXML package parts.
+ * @returns Slides in presentation order.
+ */
+const readSlides = (entries) => {
+    const xml = zipText(entries, "ppt/presentation.xml");
+    const relationships = relationshipMap(readRelationships(entries, "ppt/presentation.xml"));
+    const slides = [];
+    if (xml !== (void 0)) {
+        const scan = scanXml(xml);
+        for (let index = 0; index < scan.tags.length; index += 1) {
+            const tag = scan.tags[index];
+            if (tag.closing || tag.local !== "sldId") {
+                continue;
+            }
+            const relationId = xmlAttr(tag, "r:id");
+            const relationship = relationships.get(relationId);
+            if (relationship !== (void 0)) {
+                slides.push({ relationId, part: relationship.target });
+            }
+        }
+    }
+    if (slides.length === 0) {
+        const names = Array.from(entries.keys()).filter((name) => /^ppt\/slides\/slide[0-9]+\.xml$/.test(name));
+        names.sort((left, right) => {
+            const leftNumber = Number(/slide([0-9]+)\.xml$/.exec(left)?.[1] ?? 0);
+            const rightNumber = Number(/slide([0-9]+)\.xml$/.exec(right)?.[1] ?? 0);
+            return leftNumber - rightNumber;
+        });
+        for (let index = 0; index < names.length; index += 1) {
+            slides.push({ relationId: "", part: names[index] });
+        }
+    }
+    return slides;
+};
+/**
+ * Extract slide text, title placeholders and slide relationships.
+ *
+ * @param context - Parse context.
+ * @param entries - OOXML package parts.
+ * @param slide - Slide part.
+ * @param ordinal - One-based slide number.
+ * @returns Nothing.
+ */
+const parseSlide = (context, entries, slide, ordinal) => {
+    const xml = zipText(entries, slide.part);
+    if (xml === (void 0)) {
+        pushWarning(context, `powerpoint: slide part ${slide.part} is missing`);
+        appendSection(context, undefined, "slide", `Slide ${ordinal}`, 0);
+        return;
+    }
+    const scan = scanXml(xml);
+    const shapes = [];
+    const paragraphs = [];
+    let shape;
+    let paragraph;
+    for (let index = 0; index < scan.tags.length; index += 1) {
+        const tag = scan.tags[index];
+        if (tag.local === "sp") {
+            if (tag.closing) {
+                if (shape !== (void 0)) {
+                    shapes.push({ title: shape.title, paragraphs: [...shape.paragraphs] });
+                }
+                shape = undefined;
+                paragraph = undefined;
+            }
+            else if (!tag.selfClosing) {
+                shape = { title: false, paragraphs: [] };
+            }
+            continue;
+        }
+        if (shape !== (void 0) && tag.local === "ph" && !tag.closing) {
+            const placeholder = xmlAttr(tag, "type");
+            if (placeholder === "title" || placeholder === "ctrTitle") {
+                shape.title = true;
+            }
+        }
+        if (tag.local === "p" && !tag.name.startsWith("p:") && !tag.name.startsWith("p14:")) {
+            if (tag.closing) {
+                if (paragraph !== (void 0)) {
+                    const text = cleanLabel(paragraph.join(""), "");
+                    if (text.length > 0) {
+                        paragraphs.push(text);
+                        if (shape !== (void 0)) {
+                            shape.paragraphs.push(text);
+                        }
+                    }
+                    paragraph = undefined;
+                }
+            }
+            else if (paragraph === (void 0) && !tag.selfClosing) {
+                paragraph = [];
+            }
+            continue;
+        }
+        if (paragraph !== (void 0) && tag.local === "t" && !tag.closing && !tag.name.startsWith("p:")) {
+            const text = xmlInnerText(xml, scan, index);
+            if (text.length > 0) {
+                paragraph.push(text);
+            }
+        }
+    }
+    if (paragraph !== (void 0)) {
+        const text = cleanLabel(paragraph.join(""), "");
+        if (text.length > 0) {
+            paragraphs.push(text);
+        }
+    }
+    let title = "";
+    for (let index = 0; index < shapes.length; index += 1) {
+        if (shapes[index].title && shapes[index].paragraphs.length > 0) {
+            title = shapes[index].paragraphs.join(" ");
+            break;
+        }
+    }
+    const slideSection = appendSection(context, undefined, "slide", title.length > 0 ? title : `Slide ${ordinal}`, 0);
+    if (slideSection !== (void 0)) {
+        if (title.length > 0) {
+            appendSection(context, slideSection, "heading", title, 1);
+        }
+        for (let index = 0; index < paragraphs.length; index += 1) {
+            if (title.length > 0 && paragraphs[index] === title) {
+                continue;
+            }
+            appendSection(context, slideSection, "paragraph", paragraphs[index], 1);
+        }
+    }
+    const relationships = readRelationships(entries, slide.part);
+    for (let index = 0; index < relationships.length; index += 1) {
+        const relationship = relationships[index];
+        const type = relationship.type.toLowerCase();
+        if (type.endsWith("/hyperlink")) {
+            addReference(context, {
+                kind: "hyperlink",
+                from: context.document.path,
+                target: relationship.target,
+                detail: relationship.external ? "external hyperlink" : "internal hyperlink",
+            });
+        }
+        else if (type.endsWith("/oleobject") || type.endsWith("/package") || type.endsWith("/embedded")) {
+            addReference(context, { kind: "embedded", from: context.document.path, target: relationship.target, detail: "embedded object" });
+        }
+        else {
+            continue;
+        }
+        if (relationship.external) {
+            addImport(context, relationship.target);
+        }
+    }
+};
+/**
+ * Parse an OOXML presentation.
+ *
+ * @param context - Parse context.
+ * @param entries - OOXML package parts.
+ */
+const parsePowerPoint = (context, entries) => {
+    const slides = readSlides(entries);
+    if (slides.length === 0) {
+        pushWarning(context, "powerpoint: presentation contains no slides");
+    }
+    for (let index = 0; index < slides.length; index += 1) {
+        const fallbackNumber = Number(/slide([0-9]+)\.xml$/.exec(slides[index].part)?.[1] ?? 0);
+        const ordinal = slides[index].relationId.length === 0 && Number.isSafeInteger(fallbackNumber) && fallbackNumber > 0 ? fallbackNumber : index + 1;
+        try {
+            parseSlide(context, entries, slides[index], ordinal);
+        }
+        catch (error) {
+            pushWarning(context, `powerpoint: slide ${ordinal} could not be parsed (${error instanceof Error ? error.message : "parse failure"})`);
+            appendSection(context, undefined, "slide", `Slide ${ordinal}`, 0);
+        }
+    }
+    setMetadata(context, "powerpoint.slides", String(slides.length));
+    pushWarning(context, "powerpoint: slide order and text placeholders only; layouts, masters, notes, charts, SmartArt and images are not expanded");
+};
+/**
+ * Whether a UTF-16 code unit can be part of readable text. Surrogates are
+ * excluded because the scanner works on individual code units; unpaired
+ * surrogates are a strong signal of binary data.
+ *
+ * @param code - UTF-16 code unit.
+ * @returns Whether the unit is printable.
+ */
+const isPrintableCodeUnit = (code) => {
+    if (code === 0x09) {
+        return true;
+    }
+    if (code < 0x20 || code === 0x7f) {
+        return false;
+    }
+    if (code >= 0xd800 && code <= 0xdfff) {
+        return false;
+    }
+    if (code === 0xfeff || code === 0xfffe || code === 0xffff) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Count Unicode letters without constructing a code-point array.
+ *
+ * @param text - Candidate text.
+ * @returns Letter count.
+ */
+const letterCount = (text) => {
+    const matches = text.match(/\p{L}/gu);
+    return matches === null ? 0 : matches.length;
+};
+/**
+ * Detect ASCII bytes that were misread as UTF-16LE. When every code unit has
+ * printable ASCII in both byte lanes, the "text" is an ASCII run viewed with
+ * the wrong endianness (for example a Jet header), not real CJK text. Rejecting
+ * this shape removes the biggest false-positive class from whole-file scans
+ * without dropping legitimate UTF-16LE or CJK content.
+ *
+ * @param text - Candidate fragment.
+ * @returns Whether every code unit looks like two printable ASCII bytes.
+ */
+const looksByteSwappedAscii = (text) => {
+    const chars = Array.from(text);
+    if (chars.length < 4) {
+        return false;
+    }
+    let swapped = 0;
+    for (let index = 0; index < chars.length; index += 1) {
+        const code = chars[index].codePointAt(0);
+        if (code === (void 0) || code > 0xffff) {
+            return false;
+        }
+        const high = code >>> 8;
+        const low = code & 0xff;
+        if (high >= 0x20 && high <= 0x7e && low >= 0x20 && low <= 0x7e) {
+            swapped += 1;
+        }
+    }
+    return swapped === chars.length;
+};
+/**
+ * Whether a fragment is likely to be human-readable prose or a name rather
+ * than binary noise. The threshold favours precision: legacy formats contain
+ * many short ASCII runs inside structures, and false paragraphs are worse than
+ * a missed line.
+ *
+ * @param text - Normalized fragment.
+ * @returns Whether to keep it.
+ */
+const isMeaningfulFragment = (text) => {
+    if (text.length < 3) {
+        return false;
+    }
+    if (looksByteSwappedAscii(text)) {
+        return false;
+    }
+    const visible = text.replace(/\s/g, "").length;
+    if (visible < 3) {
+        return false;
+    }
+    const letters = letterCount(text);
+    if (letters < 2 || letters / visible < 0.35) {
+        return false;
+    }
+    const lower = text.toLowerCase();
+    if (lower === "root entry" ||
+        lower === "compobj" ||
+        lower === "summaryinformation" ||
+        lower === "documentsummaryinformation" ||
+        lower.startsWith("standard jet db") ||
+        lower.startsWith("standard ace db") ||
+        lower.startsWith("microsoft ")) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Scan UTF-16LE runs at one alignment.
+ *
+ * @param bytes - Stream bytes.
+ * @param parity - Starting byte offset (0 or 1).
+ * @param sink - Collected fragments.
+ * @returns Nothing; fragments are appended to `sink`.
+ */
+const scanUtf16 = (bytes, parity, sink) => {
+    let runStart = -1;
+    let run = "";
+    const flush = () => {
+        if (run.length >= 3) {
+            sink.push({ text: run, offset: runStart });
+        }
+        runStart = -1;
+        run = "";
+    };
+    for (let index = parity; index + 1 < bytes.length; index += 2) {
+        if (sink.length >= MaxRawFragments) {
+            flush();
+            return;
+        }
+        const code = bytes[index] | (bytes[index + 1] << 8);
+        if (isPrintableCodeUnit(code)) {
+            if (runStart < 0) {
+                runStart = index;
+            }
+            run += String.fromCharCode(code);
+        }
+        else {
+            flush();
+        }
+    }
+    flush();
+};
+/**
+ * Scan printable ASCII runs.
+ *
+ * @param bytes - Stream bytes.
+ * @param sink - Collected fragments.
+ * @returns Nothing; fragments are appended to `sink`.
+ */
+const scanAscii = (bytes, sink) => {
+    let runStart = -1;
+    let run = "";
+    const flush = () => {
+        if (run.length >= 3) {
+            sink.push({ text: run, offset: runStart });
+        }
+        runStart = -1;
+        run = "";
+    };
+    for (let index = 0; index < bytes.length; index += 1) {
+        if (sink.length >= MaxRawFragments) {
+            flush();
+            return;
+        }
+        const code = bytes[index];
+        if (code >= 0x20 && code <= 0x7e) {
+            if (runStart < 0) {
+                runStart = index;
+            }
+            run += String.fromCharCode(code);
+        }
+        else {
+            flush();
+        }
+    }
+    flush();
+};
+/**
+ * Recover printable text from a binary stream. UTF-16LE is tried at both byte
+ * alignments, then ASCII; fragments are ordered by their source offset and
+ * deduplicated after normalization. The 500-fragment ceiling is the
+ * "do not turn a binary file into a wall of noise" bound.
+ *
+ * @param bytes - Stream bytes.
+ * @returns Ordered fragments and whether raw scanning hit its own cap.
+ */
+const extractTextFragments = (bytes) => {
+    const raw = [];
+    scanUtf16(bytes, 0, raw);
+    /**
+     * The odd alignment is only a fallback. Scanning it unconditionally turns
+     * every UTF-16LE string into a second, byte-swapped "CJK" duplicate that
+     * passes the letter-ratio filter; that is binary noise, not document text.
+     */
+    if (raw.length === 0) {
+        scanUtf16(bytes, 1, raw);
+    }
+    if (raw.length < MaxRawFragments) {
+        scanAscii(bytes, raw);
+    }
+    const truncated = raw.length >= MaxRawFragments;
+    raw.sort((left, right) => left.offset - right.offset);
+    const fragments = [];
+    const seen = new Set();
+    for (let index = 0; index < raw.length && fragments.length < MaxTextFragments; index += 1) {
+        const text = raw[index].text.replace(/\s+/g, " ").trim().slice(0, 300);
+        if (!isMeaningfulFragment(text) || seen.has(text)) {
+            continue;
+        }
+        seen.add(text);
+        fragments.push({ text, offset: raw[index].offset });
+    }
+    return { fragments, truncated };
+};
+/**
+ * Recover text from named streams, falling back to every stream when none of
+ * the preferred names exist. Total scanned bytes are bounded independently of
+ * the CFB stream limit.
+ *
+ * @param streams - Stream map from `readCfb`.
+ * @param preferred - Stream names to try first.
+ * @returns Ordered fragments and whether scanning was truncated.
+ */
+const streamText = (streams, preferred) => {
+    const selected = [];
+    for (let index = 0; index < preferred.length; index += 1) {
+        const stream = streams.get(preferred[index]);
+        if (stream !== (void 0)) {
+            selected.push(stream);
+        }
+    }
+    if (selected.length === 0) {
+        streams.forEach((stream) => {
+            selected.push(stream);
+        });
+    }
+    const fragments = [];
+    let scanned = 0;
+    let truncated = false;
+    for (let index = 0; index < selected.length; index += 1) {
+        const stream = selected[index];
+        if (scanned >= MaxTextScanBytes) {
+            truncated = true;
+            break;
+        }
+        const allowed = stream.length > MaxTextScanBytes - scanned ? stream.subarray(0, MaxTextScanBytes - scanned) : stream;
+        scanned += allowed.length;
+        const extracted = extractTextFragments(allowed);
+        if (extracted.truncated) {
+            truncated = true;
+        }
+        for (let fragmentIndex = 0; fragmentIndex < extracted.fragments.length && fragments.length < MaxTextFragments; fragmentIndex += 1) {
+            const fragment = extracted.fragments[fragmentIndex];
+            if (!fragments.some((candidate) => candidate.text === fragment.text)) {
+                fragments.push(fragment);
+            }
+        }
+    }
+    return { fragments, truncated };
+};
+/**
+ * Add URL references recovered from legacy text. A URL is the one structured
+ * relationship that survives text extraction reliably; everything else in a
+ * legacy binary is reported as heuristic.
+ *
+ * @param context - Parse context.
+ * @param fragments - Recovered fragments.
+ */
+const addUrlReferences = (context, fragments) => {
+    const pattern = /https?:\/\/[^\s"'<>)\]]+/g;
+    for (let index = 0; index < fragments.length; index += 1) {
+        let match = pattern.exec(fragments[index].text);
+        while (match !== null) {
+            addReference(context, { kind: "hyperlink", from: context.document.path, target: match[0], detail: "legacy hyperlink" });
+            addImport(context, match[0]);
+            match = pattern.exec(fragments[index].text);
+        }
+    }
+};
+/**
+ * Build one text-oriented section with paragraph children. A section is only
+ * created when there is at least one printable fragment: an empty container or
+ * a stream with no recoverable text must not look like a parsed document
+ * section.
+ *
+ * @param context - Parse context.
+ * @param label - Section label.
+ * @param fragments - Paragraph fragments.
+ * @returns The created section, or `undefined` when there is no text or the
+ * section budget is exhausted.
+ */
+const appendTextSection = (context, label, fragments) => {
+    if (fragments.length === 0) {
+        pushWarning(context, `${label}: no printable text recovered`);
+        return undefined;
+    }
+    const section = appendSection(context, undefined, "section", label, 0);
+    if (section === (void 0)) {
+        return undefined;
+    }
+    for (let index = 0; index < fragments.length; index += 1) {
+        appendSection(context, section, "paragraph", fragments[index].text, 1);
+    }
+    return section;
+};
+/**
+ * Read BIFF `BOUNDSHEET` records (0x0085) from an Excel workbook stream. Sheet
+ * names are the only Excel structure the legacy reader claims; cells and
+ * formulas are not decoded.
+ *
+ * @param stream - Workbook or Book stream.
+ * @returns Sheet names in workbook order.
+ */
+const biffSheetNames = (stream) => {
+    const names = [];
+    const seen = new Set();
+    if (stream.length < 4) {
+        return names;
+    }
+    const view = new DataView(stream.buffer, stream.byteOffset, stream.byteLength);
+    let offset = 0;
+    let records = 0;
+    while (offset + 4 <= stream.length && records < 20000) {
+        const type = view.getUint16(offset, true);
+        const length = view.getUint16(offset + 2, true);
+        const dataStart = offset + 4;
+        if (dataStart + length > stream.length) {
+            break;
+        }
+        if (type === 0x0085 && length >= 8) {
+            const count = stream[dataStart + 6];
+            const flags = stream[dataStart + 7];
+            if (count > 0 && count <= 255) {
+                const nameStart = dataStart + 8;
+                const wide = (flags & 0x01) !== 0;
+                const byteLength = wide ? count * 2 : count;
+                if (nameStart + byteLength <= stream.length) {
+                    let name = "";
+                    for (let index = 0; index < count; index += 1) {
+                        const code = wide ? stream[nameStart + index * 2] | (stream[nameStart + index * 2 + 1] << 8) : stream[nameStart + index];
+                        if (code === 0 || code < 0x20) {
+                            break;
+                        }
+                        name += String.fromCharCode(code);
+                    }
+                    const clean = cleanLabel(name, "");
+                    if (clean.length > 0 && !seen.has(clean)) {
+                        seen.add(clean);
+                        names.push(clean);
+                    }
+                }
+            }
+        }
+        offset = dataStart + length;
+        records += 1;
+    }
+    return names;
+};
+/**
+ * Parse a legacy OLE Office document. Text is recovered from the stream that
+ * carries it in each format, then split into one section per meaningful
+ * fragment. No binary field is interpreted as a document object unless the
+ * format's own stream names identify it.
+ *
+ * @param context - Parse context.
+ * @param streams - CFB streams.
+ * @param kind - Document family.
+ */
+const parseLegacy = (context, streams, kind) => {
+    if (kind === "excel") {
+        const workbook = streams.get("Workbook") ?? streams.get("Book");
+        const sheetNames = workbook === (void 0) ? [] : biffSheetNames(workbook);
+        for (let index = 0; index < sheetNames.length; index += 1) {
+            appendSection(context, undefined, "sheet", sheetNames[index], 0);
+        }
+        const text = streamText(streams, ["Workbook", "Book"]);
+        appendTextSection(context, "Workbook text", text.fragments);
+        addUrlReferences(context, text.fragments);
+        if (text.truncated) {
+            pushWarning(context, "excel: legacy text scan reached its fragment limit");
+        }
+        setMetadata(context, "excel.sheets", String(sheetNames.length));
+        pushWarning(context, "excel: legacy BIFF text extraction is heuristic; cells, formulas and styles are not decoded");
+        return;
+    }
+    if (kind === "word") {
+        const text = streamText(streams, ["WordDocument"]);
+        appendTextSection(context, "Word document", text.fragments);
+        addUrlReferences(context, text.fragments);
+        if (text.truncated) {
+            pushWarning(context, "word: legacy text scan reached its fragment limit");
+        }
+        pushWarning(context, "word: legacy .doc text extraction is heuristic; tables, fields and formatting are not decoded");
+        return;
+    }
+    if (kind === "powerpoint") {
+        const text = streamText(streams, ["PowerPoint Document"]);
+        appendTextSection(context, "PowerPoint presentation", text.fragments);
+        addUrlReferences(context, text.fragments);
+        if (text.truncated) {
+            pushWarning(context, "powerpoint: legacy text scan reached its fragment limit");
+        }
+        pushWarning(context, "powerpoint: legacy .ppt text extraction is heuristic; slides, layouts and shapes are not decoded");
+        return;
+    }
+    if (kind === "publisher") {
+        const text = streamText(streams, ["Contents", "Quill", "QuillSub"]);
+        appendTextSection(context, "Publisher document", text.fragments);
+        addUrlReferences(context, text.fragments);
+        if (text.truncated) {
+            pushWarning(context, "publisher: legacy text scan reached its fragment limit");
+        }
+        pushWarning(context, "publisher: Publisher support is best-effort; text story order, pages, frames and layout are not decoded");
+        return;
+    }
+    const text = streamText(streams, []);
+    appendTextSection(context, "OLE streams", text.fragments);
+    addUrlReferences(context, text.fragments);
+    pushWarning(context, "ole: unrecognized document family; only printable text fragments were recovered");
+};
+/**
+ * Access/Jet engine magic strings after the four-byte file header.
+ */
+const AccessMagic = ["Standard Jet DB", "Standard ACE DB"];
+/**
+ * Detect a Jet/ACE database by its header. Access files are deliberately not
+ * treated as CFB: `.mdb` and `.accdb` use a page-oriented format with this
+ * signature at offset 4.
+ *
+ * @param bytes - Candidate file bytes.
+ * @returns Engine name, or `undefined` when the header is not an Access header.
+ */
+const accessEngine = (bytes) => {
+    if (bytes.length < 24 || bytes[0] !== 0x00 || bytes[1] !== 0x01 || bytes[2] !== 0x00 || bytes[3] !== 0x00) {
+        return undefined;
+    }
+    const magic = asciiAt(bytes, 4, 20);
+    for (let index = 0; index < AccessMagic.length; index += 1) {
+        if (magic.startsWith(AccessMagic[index])) {
+            return AccessMagic[index];
+        }
+    }
+    return undefined;
+};
+/**
+ * Parse an Access database on a best-effort basis. There is no page parser
+ * here, so catalog names are recovered from UTF-16LE identifier-shaped string
+ * runs and classified only by a conventional prefix. The warning states that
+ * limitation explicitly; no table schema or query SQL is claimed.
+ *
+ * @param context - Parse context.
+ * @param bytes - Database bytes.
+ * @param engine - Detected engine magic.
+ */
+const parseAccess = (context, bytes, engine) => {
+    pushWarning(context, "access catalog best-effort: catalog names are recovered from string runs, not from table/page parsing");
+    setMetadata(context, "access.engine", engine);
+    /**
+     * Skip the header and the first database page. Its ASCII engine magic and
+     * fixed fields would otherwise be read as UTF-16LE and surface as catalog
+     * candidates in an otherwise empty database.
+     */
+    const scanStart = Math.min(bytes.length, 4096);
+    const scanEnd = Math.min(bytes.length, scanStart + MaxTextScanBytes);
+    const scanned = extractTextFragments(bytes.subarray(scanStart, scanEnd));
+    const reserved = [
+        "select",
+        "from",
+        "where",
+        "table",
+        "index",
+        "primary",
+        "foreign",
+        "database",
+        "access",
+        "admin",
+        "system",
+        "standard",
+        "create",
+        "insert",
+        "update",
+        "delete",
+        "query",
+        "form",
+        "report",
+    ];
+    const candidates = [];
+    const seen = new Set();
+    for (let index = 0; index < scanned.fragments.length && candidates.length < 100; index += 1) {
+        const name = scanned.fragments[index].text;
+        if (!/^[\p{L}_][\p{L}\p{N}_ ]{1,62}$/u.test(name) || name.split(" ").length > 4) {
+            continue;
+        }
+        const lower = name.toLowerCase();
+        if (reserved.includes(lower) || lower.startsWith("msys") || lower.startsWith("~") || seen.has(lower)) {
+            continue;
+        }
+        seen.add(lower);
+        candidates.push(name);
+    }
+    if (candidates.length === 0) {
+        pushWarning(context, "access: no catalog names could be recovered");
+    }
+    else {
+        const catalog = appendSection(context, undefined, "section", "Access catalog (best effort)", 0);
+        for (let index = 0; index < candidates.length; index += 1) {
+            const kind = /^(?:qry|q_)/i.test(candidates[index]) ? "query" : "table";
+            if (catalog !== (void 0)) {
+                appendSection(context, catalog, kind, candidates[index], 1);
+            }
+        }
+    }
+    setMetadata(context, "access.catalogCandidates", String(candidates.length));
+    if (scanned.truncated) {
+        pushWarning(context, "access: catalog scan reached its fragment limit");
+    }
+};
+/**
+ * Determine the OOXML family from package part names when the extension is
+ * unknown or absent.
+ *
+ * @param entries - OOXML package parts.
+ * @returns Best family guess.
+ */
+const kindFromParts = (entries) => {
+    let word = false;
+    let excel = false;
+    let powerpoint = false;
+    const names = Array.from(entries.keys());
+    for (let index = 0; index < names.length; index += 1) {
+        if (names[index].startsWith("word/")) {
+            word = true;
+        }
+        else if (names[index].startsWith("xl/")) {
+            excel = true;
+        }
+        else if (names[index].startsWith("ppt/")) {
+            powerpoint = true;
+        }
+    }
+    if (word) {
+        return "word";
+    }
+    if (excel) {
+        return "excel";
+    }
+    if (powerpoint) {
+        return "powerpoint";
+    }
+    return "unknown";
+};
+/**
+ * Determine the legacy family from CFB stream names.
+ *
+ * @param streams - CFB streams.
+ * @returns Best family guess.
+ */
+const kindFromStreams = (streams) => {
+    if (streams.has("WordDocument")) {
+        return "word";
+    }
+    if (streams.has("Workbook") || streams.has("Book")) {
+        return "excel";
+    }
+    if (streams.has("PowerPoint Document")) {
+        return "powerpoint";
+    }
+    if (streams.has("Contents") || streams.has("Quill") || streams.has("QuillSub")) {
+        return "publisher";
+    }
+    return "unknown";
+};
+/**
+ * Whether a byte sequence starts with a ZIP header.
+ *
+ * A package normally starts with a local-file header (`PK\x03\x04`), but an
+ * empty archive starts with its end-of-central-directory record (`PK\x05\x06`)
+ * and a spanned archive with the spanning marker (`PK\x07\x08`). All three are
+ * valid ZIP starts, so all three are routed to the OOXML reader, which then
+ * reports an empty package instead of "unrecognized container".
+ *
+ * @param bytes - Candidate bytes.
+ * @returns Whether the ZIP magic is present.
+ */
+const hasZipMagic = (bytes) => bytes.length >= 4 &&
+    bytes[0] === 0x50 &&
+    bytes[1] === 0x4b &&
+    ((bytes[2] === 0x03 && bytes[3] === 0x04) || (bytes[2] === 0x05 && bytes[3] === 0x06) || (bytes[2] === 0x07 && bytes[3] === 0x08));
+/**
+ * Whether a byte sequence starts with the CFB signature.
+ *
+ * @param bytes - Candidate bytes.
+ * @returns Whether the CFB magic is present.
+ */
+const hasCfbMagic = (bytes) => bytes.length >= 8 &&
+    bytes[0] === 0xd0 &&
+    bytes[1] === 0xcf &&
+    bytes[2] === 0x11 &&
+    bytes[3] === 0xe0 &&
+    bytes[4] === 0xa1 &&
+    bytes[5] === 0xb1 &&
+    bytes[6] === 0x1a &&
+    bytes[7] === 0xe1;
+/**
+ * Parse Office bytes that have already been read and validated by a caller.
+ *
+ * The container level is decided by magic, not extension: a `.docx` that is
+ * really a CFB file is still treated as a CFB container, and a ZIP with an
+ * unhelpful extension is sniffed from its parts. Extension only disambiguates
+ * the document family inside a valid container.
+ *
+ * @param path - Root-relative path used in references and IDs.
+ * @param bytes - Complete file bytes.
+ * @returns Best-effort document.
+ */
+const parseOfficeBytes = (path, bytes) => {
+    const extensionKind = kindFromPath(path);
+    const format = hasZipMagic(bytes) ? "ooxml" : hasCfbMagic(bytes) || accessEngine(bytes) !== (void 0) ? "ole" : "unknown";
+    const context = createContext(path, extensionKind, format, bytes);
+    try {
+        if (format === "ooxml") {
+            let entries;
+            try {
+                entries = readZipEntries(bytes);
+            }
+            catch (error) {
+                if (isFilesystemError(error) && error.code === "quota_exceeded") {
+                    throw error;
+                }
+                pushWarning(context, `ooxml container rejected: ${error instanceof Error ? error.message : "parse failure"}`);
+            }
+            if (entries !== (void 0)) {
+                const kind = extensionKind === "unknown" ? kindFromParts(entries) : extensionKind;
+                context.document.kind = kind;
+                try {
+                    readDocumentProperties(context, entries);
+                }
+                catch (error) {
+                    pushWarning(context, `office properties ignored (${error instanceof Error ? error.message : "parse failure"})`);
+                }
+                try {
+                    if (kind === "word") {
+                        parseWord(context, entries);
+                    }
+                    else if (kind === "excel") {
+                        parseExcel(context, entries);
+                    }
+                    else if (kind === "powerpoint") {
+                        parsePowerPoint(context, entries);
+                    }
+                    else {
+                        pushWarning(context, "ooxml package does not contain word/, xl/ or ppt/ parts");
+                    }
+                }
+                catch (error) {
+                    pushWarning(context, `ooxml ${kind} structure ignored (${error instanceof Error ? error.message : "parse failure"})`);
+                }
+            }
+            else {
+                context.document.kind = extensionKind;
+            }
+        }
+        else if (format === "ole") {
+            const engine = accessEngine(bytes);
+            if (engine !== (void 0)) {
+                context.document.kind = "access";
+                parseAccess(context, bytes, engine);
+            }
+            else {
+                const cfb = readCfb(bytes);
+                for (let index = 0; index < cfb.warnings.length; index += 1) {
+                    pushWarning(context, cfb.warnings[index]);
+                }
+                const kind = extensionKind === "unknown" ? kindFromStreams(cfb.streams) : extensionKind;
+                context.document.kind = kind;
+                if (cfb.streams.size === 0) {
+                    pushWarning(context, "ole container has no readable streams");
+                }
+                else {
+                    try {
+                        parseLegacy(context, cfb.streams, kind);
+                    }
+                    catch (error) {
+                        pushWarning(context, `ole ${kind} structure ignored (${error instanceof Error ? error.message : "parse failure"})`);
+                    }
+                }
+            }
+        }
+        else {
+            context.document.kind = "unknown";
+            pushWarning(context, "unrecognized office container; no structure was extracted");
+        }
+    }
+    catch (error) {
+        if (isFilesystemError(error)) {
+            throw error;
+        }
+        pushWarning(context, `office parse stopped: ${error instanceof Error ? error.message : "unknown failure"}`);
+    }
+    if (context.truncated) {
+        pushWarning(context, `office section limit ${MaxSections} reached; remaining structure was not parsed`);
+    }
+    return context.document;
+};
+/**
+ * Parse one Office document, reading its bytes through the session sandbox.
+ *
+ * A file larger than 64 MiB is refused with `quota_exceeded` before it is read.
+ * Path resolution, symlink checks and file-type checks are delegated to
+ * `PathSandbox`, so this parser cannot read outside the session roots.
+ *
+ * @param sandbox - Session sandbox that owns path resolution.
+ * @param path - Root-relative POSIX path.
+ * @returns Best-effort document structure and warnings.
+ */
+export const parseOffice = (sandbox, path) => {
+    const rooted = sandbox.resolve(path, "read");
+    sandbox.revalidate(rooted);
+    const stat = statOrFail(rooted.absolute);
+    if (!stat.isFile()) {
+        return fail("not_file");
+    }
+    if (stat.size > OfficeMaxDocumentBytes) {
+        return fail("quota_exceeded");
+    }
+    sandbox.revalidate(rooted);
+    const bytes = readBytesOrFail(rooted.absolute);
+    if (bytes.byteLength > OfficeMaxDocumentBytes) {
+        return fail("quota_exceeded");
+    }
+    return parseOfficeBytes(rooted.relative, bytes);
+};
+/**
+ * Map an Office section kind to the closest existing outline kind. The outline
+ * vocabulary predates Office and has no `sheet`, `slide`, `table`, `query`,
+ * `form` or `report` values, so those become `section` rather than inventing
+ * enum members outside the shared type.
+ *
+ * @param kind - Office section kind.
+ * @returns Outline kind.
+ */
+const outlineKindOf = (kind) => {
+    if (kind === "heading") {
+        return "heading";
+    }
+    if (kind === "paragraph") {
+        return "paragraph";
+    }
+    return "section";
+};
+/**
+ * Number of sections in one subtree, including the subtree root.
+ *
+ * @param section - Office section.
+ * @returns Subtree section count.
+ */
+const countSections = (section) => {
+    let total = 1;
+    for (let index = 0; index < section.children.length; index += 1) {
+        total += countSections(section.children[index]);
+    }
+    return total;
+};
+/**
+ * Highest document ordinal in one subtree. A parent's range ends at the last
+ * ordinal of its deepest descendant, which keeps ranges nested and monotonic.
+ *
+ * @param section - Office section.
+ * @returns Highest ordinal in the subtree.
+ */
+const lastSectionIndex = (section) => {
+    let last = section.index;
+    for (let index = 0; index < section.children.length; index += 1) {
+        last = Math.max(last, lastSectionIndex(section.children[index]));
+    }
+    return last;
+};
+/**
+ * Build outline nodes from Office sections.
+ *
+ * Ranges are synthetic because Office formats expose neither text lines nor
+ * part offsets. Two monotonic projections keep the tree usable:
+ *
+ * - `startLine`/`endLine` are the section's document ordinals: `index + 1` up
+ *   to the highest ordinal in its subtree, so a parent covers its children and
+ *   siblings never overlap;
+ * - `startByte`/`endByte` project the same ordinal interval onto the container
+ *   size, so the sections partition the file exactly once and a parent still
+ *   covers its subtree.
+ *
+ * Both are explicitly approximate: they answer "where in document order", not
+ * "at which OOXML part offset". The path is `"<file>#<section-id>"` and every
+ * node is a symbol, not a file anchor.
+ *
+ * The raw-byte entry point enforces `OfficeMaxOutlineBytes` itself so a direct
+ * caller sees `quota_exceeded` rather than handing a container to a text
+ * charset detector (which would report `binary_file`). `buildOutline` applies
+ * the same ceiling before it reads the file.
+ *
+ * @param input - Path and complete container bytes.
+ * @returns Outline nodes in document order.
+ */
+export const officeOutlineParser = (input) => {
+    if (input.bytes.byteLength > OfficeMaxOutlineBytes) {
+        return fail("quota_exceeded");
+    }
+    const document = parseOfficeBytes(input.path, input.bytes);
+    const totalBytes = input.bytes.byteLength;
+    let sectionCount = 0;
+    for (let index = 0; index < document.sections.length; index += 1) {
+        sectionCount += countSections(document.sections[index]);
+    }
+    const byteAt = (ordinal) => sectionCount === 0 ? 0n : (BigInt(totalBytes) * BigInt(Math.max(0, Math.min(ordinal, sectionCount)))) / BigInt(sectionCount);
+    const build = (section) => {
+        const last = lastSectionIndex(section);
+        const children = [];
+        for (let index = 0; index < section.children.length; index += 1) {
+            children.push(build(section.children[index]));
+        }
+        const node = {
+            isFile: false,
+            isDirectory: false,
+            path: `${input.path}#${section.id}`,
+            type: outlineKindOf(section.kind),
+            range: {
+                startByte: byteAt(section.index),
+                endByte: byteAt(last + 1),
+                startLine: BigInt(section.index + 1),
+                endLine: BigInt(last + 1),
+            },
+            label: section.label,
+            depth: section.depth,
+            children,
+        };
+        return node;
+    };
+    const nodes = [];
+    for (let index = 0; index < document.sections.length; index += 1) {
+        nodes.push(build(document.sections[index]));
+    }
+    return nodes;
+};
+/**
+ * Install the Office outline extractor into the shared strategy registry.
+ * Idempotent: repeated calls leave the same parser registered.
+ */
+export const installOfficeOutlineParser = () => {
+    if (!hasOfficeOutlineParser()) {
+        registerOfficeOutlineParser(officeOutlineParser);
+    }
+};
+/**
+ * External targets of a parsed document, for dependency/import consumers.
+ *
+ * @param document - Parsed Office document.
+ * @returns A copy of the import list.
+ */
+export const officeImports = (document) => [...document.imports];
+/**
+ * Exported names of a parsed document, for export consumers.
+ *
+ * @param document - Parsed Office document.
+ * @returns A copy of the export list.
+ */
+export const officeExports = (document) => [...document.exports];
+/**
+ * Outbound references of a parsed document, for dependency consumers.
+ *
+ * @param document - Parsed Office document.
+ * @returns A copy of the reference list.
+ */
+export const officeReferences = (document) => document.references.map((reference) => ({ ...reference }));