document-outline.js 0.0.0 → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joseph Mearman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,121 @@
+# document-outline.js
+
+[![GitHub](https://img.shields.io/badge/GitHub-181717?logo=github&logoColor=white)](https://github.com/ExaDev/document-outline.js) [![npm](https://img.shields.io/badge/npm-CB3837?logo=npm&logoColor=white)](https://www.npmjs.com/package/document-outline.js) [![Release](https://img.shields.io/github/v/release/ExaDev/document-outline.js)](https://github.com/ExaDev/document-outline.js/releases/latest) [![CI](https://img.shields.io/github/actions/workflow/status/ExaDev/document-outline.js/ci.yml?branch=main)](https://github.com/ExaDev/document-outline.js/actions)
+
+> Utilities for consumers holding a tree-form `DocumentPackage` (document-schema.js 4.0.0) — the table-of-contents projection, effective-property resolution, and the flatten-to-leaves / leaf-text / stable-hash helpers — without importing the producer that made it. The outline package for the [documents.js family](https://github.com/ExaDev). Worker-isomorphic: the same code runs under Node and inside a Cloudflare Workers isolate.
+
+Created for [document-schema.js#14](https://github.com/ExaDev/document-schema.js/issues/14): none of the content shapes groups content by heading or list level — a heading paragraph sits in a flat `blocks` array like any other — so every consumer needing a nested tree (chunking a document for retrieval, generating a table of contents, structural diffing) had to rebuild the same nesting transform for itself. This package is that transform, once. It depends only on `document-schema.js` (plus `zod`): it never touches a codec, because it only ever operates on an already-produced package, regardless of which producer made it.
+
+[document-schema.js#20](https://github.com/ExaDev/document-schema.js/issues/20) then made the tree the canonical form: since 4.0.0, `DocumentPackage` **is** the tree — a discriminated union of `{ node, children }` group wrappers (`SectionGroupNode`, `SlideGroupNode`, `SheetGroupNode`, `DrawPageGroupNode`, `ShapeGroupNode`, `HeadingGroupNode`, `ListGroupNode`, all imported from `document-schema.js` itself). With the tree vocabulary owned by the schema, this package's phase-1 `decompose`/`flatten` pair — the flat-to-tree transform and its bijection — moved wholesale into [documents.js](https://github.com/ExaDev/documents.js)'s package boundary ([document-outline.js#2](https://github.com/ExaDev/document-outline.js/issues/2), phase 2): one implementation, one authority, no second copy of the grouping semantics here. What remains — and what this major release re-charters the package around — is the artefact-utility surface: everything a consumer holding a serialised tree-form package JSON needs to project, resolve, and hash it, with `document-schema.js` as the only dependency. The removal is the release note: `decompose`, `flatten`, `documentEnvelope`, and the local `PackageNode` types are gone from this package's surface outright, not `@deprecated` — the tree types live in `document-schema.js`, the lossless tree↔flat pair lives in `documents.js`.
+
+## Getting started
+
+Requires Node.js `>=20` and pnpm `11.6.0`.
+
+```sh
+pnpm install
+pnpm build          # tsdown -> dist/ (ESM + CJS + .d.ts)
+pnpm typecheck      # tsc -p tsconfig.json && tsc -p tsconfig.node.json (dual tsconfig)
+pnpm lint           # eslint . --fix --cache --max-warnings 0
+pnpm test           # vitest run
+pnpm test:watch     # vitest
+pnpm test:workers   # vitest run --config vitest.workers.config.ts, inside a real Cloudflare Workers (workerd) isolate
+```
+
+To run a single test file, pass its path to vitest directly, e.g. `pnpm exec vitest run src/outline/build.test.ts`.
+
+## What it provides
+
+| Module | Exports |
+|---|---|
+| `outline/build` | `buildOutline` (per-kind TOC projection over a `DocumentPackage`) |
+| `outline/effective` | `effectivePackage` (effective-property resolution) |
+| `outline/node` | `OutlineNode`, `OutlineChild`, `OutlineLeaf`, `OutlineNodeSchema`, `isOutlineNode`, `isOutlineChild`, `isOutlineLeaf` |
+| `outline/helpers` | `flattenOutline`, `outlineLeafText`, `leafContentHash` |
+
+Every module in the table is re-exported from the package root, so its exports import from `'document-outline.js'` directly. `outline/hash` (the `stableContentHash`/`canonicalise`/`sha256` primitives behind `leafContentHash`'s published recipe) is deliberately not on the root entry — it stays reachable via the `document-outline.js/outline/hash` subpath, keeping the root surface small.
+
+`buildOutline(pkg)` dispatches on `pkg.kind` and projects `pkg.children` into the root scope's children — `OutlineChild[]`, an ordered mix of this package's own `OutlineNode` groups and the schema's leaf payloads. The root is deliberately not itself a node (no synthetic "document" group), so a wordprocessing package's pre-heading content — or a package with no grouping signal at all — appears as leaves directly in the returned array.
+
+This is the **TOC projection**, not a decomposition, and the difference is the charter: it deliberately re-groups across container boundaries — a wordprocessing package's sections flow into one tree, a slide's paragraphs are taken across its shapes in shape order — which is exactly the lossiness a table of contents wants, and exactly why the lossless container-boundary-respecting pair lives in `documents.js`'s package boundary instead.
+
+An `OutlineNode` carries `text` (the group's own label), `level` (its source level signal, verbatim), and `children` (nested groups and leaf payloads in document order). `level` is the source signal, not tree depth: heading groups carry their anchor's `headingLevel` (1-based), list-item groups carry `list.level` (0-based), and the synthetic slide/sheet/page/formula groups are level 1. Render indentation from the nesting, never from `level` — a slide group (level 1) legitimately contains list items at levels 0, 1, 2… on the other scale.
+
+### Per-kind hierarchy
+
+| Kind | Groups | Nesting | Leaves |
+|---|---|---|---|
+| wordprocessing | one per heading group, by `headingLevel` | stack semantics; list groups nest inside by `list.level` | non-list blocks, at the current depth |
+| presentation | one per slide group, `Slide N` | slide paragraphs nest by `list.level`, across its shapes | non-paragraph blocks, at the current depth |
+| spreadsheet | one per sheet group, the sheet's name | — | the sheet's images, then its embedded objects |
+| drawing | one per page group, `Page N` | — | the page's shape contents flattened, then its vectors |
+| formula | a single node | — | the `ContentFormula` itself |
+
+Both nesting scales follow the same stack semantics, modelled on how Word's navigation pane and PowerPoint's outline view present structure: each new group nests under the deepest open group with a strictly shallower level and pops equal-or-deeper groups closed, so an H4 following an H2 becomes its direct child (no synthetic intermediates) and an H1 after an H3 pops to the root; list groups behave identically on `list.level`'s 0-based scale (a jump from level 0 to level 2 nests directly under the 0). Within a group the two compose: heading groups open scopes, list groups nest inside them, and non-paragraph blocks (tables, images, page breaks, embedded objects) attach as leaves at the current depth without changing it. A paragraph at a leaf position carries neither grouping signal in a well-formed tree, sits flat at its scope, and closes the list nesting — which is what keeps the flattened leaf order identical to document order. `headingLevel` is the only heading signal read — a Heading `styleId` without `headingLevel` does not group — and in presentations it is not read at all: slides have no heading hierarchy of their own, so `list.level` is the only depth signal they carry.
+
+Slide and page labels (`Slide 1`, `Page 1`, …) are 1-based, matching the Markdown renderer's own per-slide/per-page heading convention; spreadsheet groups are labelled with the sheet's own name (cells are addressable data, not outline content, and never appear); drawing vectors stay in the tree as textless leaves so structural diffing still sees them.
+
+## Effective properties
+
+A tree group may carry a `style` ref into the package's `styles` table ([document-schema.js#21](https://github.com/ExaDev/document-schema.js/issues/21)). `effectivePackage(pkg)` resolves those refs away using document-schema.js's own overlay helpers (`resolveStyleChain`, `applyParagraphStyleProperties`, `applyRunStyleProperties` — the mechanics are the schema's to own, the same single-authority rule that moved the tree vocabulary there) and returns the package with every ref consumed and the styles table dropped:
+
+```ts
+import { effectivePackage } from 'document-outline.js';
+
+const resolved = effectivePackage(pkg); // same tree, properties inlined, no styles table
+```
+
+The semantics: a group's ref, plus every ancestor group's ref, overlays onto each paragraph in that group's subtree — group anchors (heading and list groups carry full `ContentParagraph` anchors) and bare paragraph leaves alike — with the chain ordered outermost-first so the nearest group's entry wins over further-out ones, and the paragraph's own direct properties win over everything (the schema's apply helpers fill gaps, never overwrite). The run half of a resolved entry applies to every run of each paragraph it resolved for. The walk's boundary is the block flow: a table leaf's cell paragraphs and an embedded document's own content are leaf-local payload this walk does not rewrite — an embedded document is its own whole document context.
+
+Two guarantees worth depending on. First, `effectivePackage(factored)` deep-equals `effectivePackage(unfactored)`: a serialisation that factored properties into style refs and one that inlined them everywhere resolve to the same effective tree, so consumers comparing or hashing content never see the producer's compression choices. To get that property for hashes, resolve first — `leafContentHash` over the leaves of `buildOutline(effectivePackage(pkg))` names the document, not the factoring. Second, resolution runs loudly: a ref the styles table does not carry is malformed, and `resolveStyleChain` throws rather than silently skipping. A styles-free package is returned as the same object — nothing anywhere needs rewriting.
+
+## Helpers
+
+```ts
+import { buildOutline, effectivePackage, flattenOutline, leafContentHash, outlineLeafText } from 'document-outline.js';
+
+const outline = buildOutline(pkg);      // OutlineChild[] — the TOC projection
+const resolved = effectivePackage(pkg); // style refs consumed, table dropped
+flattenOutline(outline);                // every leaf payload, in document order
+outlineLeafText(aLeaf);                 // the leaf's own text (paragraph runs, table cells,
+                                        // image altText, formula LaTeX; '' for textless leaves)
+leafContentHash(aLeaf);                 // stable content hash — see the recipe below
+```
+
+Heading and list paragraphs are represented by their group nodes and are not duplicated as leaves, so a tree of groups flattens to the non-paragraph content plus every unlevelled paragraph; a group's own text is always its `text` field. `leafContentHash` hashes the leaf as given and deliberately does not fold style resolution in — a leaf alone does not know its ancestor group refs, so effective-property resolution can only happen with the whole package in hand. The resolve-then-hash route is `effectivePackage(pkg)` first, then hash the resolved leaves; hash the raw leaf only when you truly mean the literal object.
+
+### The hash recipe
+
+`leafContentHash` (via `stableContentHash`) is a published contract — changing any step changes every hash ever issued:
+
+1. Strip `$schema` keys recursively from the value (arrays mapped, plain objects rebuilt without the key). Serialised dumps carry a release-pinned `$schema` CDN URI stamped by `document-schema.js`'s serialisation helper; the label is transport metadata about which schema version produced the JSON, not content, and no content field is named `$schema` — so a dump and its parsed-then-rehashed original agree.
+2. Canonicalise the result: rebuild every plain object with its own keys sorted ascending by UTF-16 code unit (arrays keep their order, primitives pass through) — so independently constructed, structurally identical content is byte-identical from here on regardless of field-construction order.
+3. `JSON.stringify` the canonicalised value (no spacing; `undefined`-valued optional fields drop out, so "absent" and "explicitly undefined" hash the same).
+4. UTF-8 encode with `TextEncoder`.
+5. SHA-256, hand-rolled over `Uint8Array` (Worker-isomorphic; no `node:crypto`, no async `SubtleCrypto`) and pinned against the FIPS 180-4 example vectors in `hash.test.ts`.
+6. Hex-encode the digest, lowercase.
+
+The result is deterministic across processes and platforms, equal exactly when the leaf's content is equal, and different for different content up to SHA-256 collision resistance.
+
+## Where decompose and flatten went
+
+The phase-1 `decompose`/`flatten` pair and its property-tested bijection — the lossless tree↔flat transform this package once carried as the vehicle for the `DocumentPackage` promotion — now live in [documents.js](https://github.com/ExaDev/documents.js)'s package boundary. Schema 4.0.0 made `DocumentPackage` itself tree-form, so the grouping semantics have one home next to the codecs that produce and consume packages, and the tree types (`PackageNode`, `PackageGroup`, `SectionGroupNode`, …) import from `document-schema.js`. If you hold a flat `ContentDocument` and need the tree, or need the exact container-boundary-preserving inverse of the TOC projection above, that is documents.js's surface now.
+
+## Conventions
+
+- Worker-isomorphic (see the [family-wide convention](https://github.com/ExaDev/documents.js/blob/main/README.md#conventions)): runtime `src/` must not import `node:*`, a bare Node builtin, or use the `Buffer` global — enforced by a `no-restricted-imports`/`no-restricted-globals` ESLint rule and exercised in CI by running a test suite inside an actual `workerd` isolate (`pnpm test:workers`).
+- Only `src/index.ts` may be named `index.*` — a custom ESLint rule (`local/no-non-barrel-index`) rejects any other module using an `index` basename, since that would be a hidden entry point the `exports` map in `package.json` doesn't advertise.
+- `OutlineNodeSchema` follows document-schema.js's `z.custom` hand-written-guard pattern (`ContentBlock` is the precedent): `z.lazy()` collapses recursive schemas' static type to `unknown` in the pinned zod 4, so the recursion lives in a plain function guard instead.
+- Releases are fully automated: a push to `main` runs `semantic-release` in CI, which determines the version from Conventional Commit messages and publishes to npm via OIDC trusted publishing (no local `NPM_TOKEN` needed). There is no manual publish step.
+
+## Install
+
+```sh
+pnpm add document-outline.js
+# or
+npm install document-outline.js
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,509 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let document_schema_js = require("document-schema.js");
+let zod = require("zod");
+//#region src/outline/build.ts
+function buildOutline(pkg) {
+	switch (pkg.kind) {
+		case "wordprocessing": return wordprocessingOutline(pkg.children);
+		case "presentation": return presentationOutline(pkg.children);
+		case "spreadsheet": return spreadsheetOutline(pkg.children);
+		case "drawing": return drawingOutline(pkg.children);
+		case "formula": return formulaOutline(pkg.children[0]);
+	}
+}
+function wordprocessingOutline(sections) {
+	const root = [];
+	const headingStack = [];
+	const listStack = [];
+	const headingScope = () => headingStack.at(-1)?.children ?? root;
+	const walk = (children) => {
+		for (const child of children) if ((0, document_schema_js.isHeadingGroupNode)(child)) {
+			listStack.length = 0;
+			const level = child.node.headingLevel;
+			for (let top = headingStack.at(-1); top !== void 0 && top.level >= level; top = headingStack.at(-1)) headingStack.pop();
+			const node = {
+				text: paragraphText(child.node),
+				level,
+				children: []
+			};
+			const parent = headingStack.at(-1);
+			(parent !== void 0 ? parent.children : root).push(node);
+			headingStack.push(node);
+			walk(child.children);
+		} else if ((0, document_schema_js.isListGroupNode)(child)) {
+			openListGroup(listStack, headingScope(), paragraphText(child.node), child.node.list.level);
+			walk(child.children);
+		} else if (child.kind === "paragraph") {
+			listStack.length = 0;
+			headingScope().push(child);
+		} else {
+			const parent = listStack.at(-1);
+			(parent !== void 0 ? parent.children : headingScope()).push(child);
+		}
+	};
+	for (const section of sections) walk(section.children);
+	return root;
+}
+function presentationOutline(slides) {
+	return slides.map((slide, index) => {
+		const group = {
+			text: `Slide ${String(index + 1)}`,
+			level: 1,
+			children: []
+		};
+		const listStack = [];
+		const walk = (children) => {
+			for (const child of children) if ((0, document_schema_js.isListGroupNode)(child)) {
+				openListGroup(listStack, group.children, paragraphText(child.node), child.node.list.level);
+				walk(child.children);
+			} else if (child.kind === "paragraph") {
+				listStack.length = 0;
+				group.children.push(child);
+			} else {
+				const parent = listStack.at(-1);
+				(parent !== void 0 ? parent.children : group.children).push(child);
+			}
+		};
+		for (const shape of slide.children) walk(shape.children);
+		return group;
+	});
+}
+function spreadsheetOutline(sheets) {
+	return sheets.map((sheet) => ({
+		text: sheet.node.name,
+		level: 1,
+		children: [...sheet.children]
+	}));
+}
+function drawingOutline(pages) {
+	return pages.map((page, index) => ({
+		text: `Page ${String(index + 1)}`,
+		level: 1,
+		children: page.children.flatMap((child) => (0, document_schema_js.isShapeGroupNode)(child) ? flattenShapeChildren(child) : [child])
+	}));
+}
+function flattenShapeChildren(group) {
+	return flattenListFlow(group.children);
+}
+function flattenListFlow(children) {
+	const leaves = [];
+	for (const child of children) if ((0, document_schema_js.isListGroupNode)(child)) leaves.push(child.node, ...flattenListFlow(child.children));
+	else leaves.push(child);
+	return leaves;
+}
+function formulaOutline(formula) {
+	return [{
+		text: formula.presentation?.latex ?? "",
+		level: 1,
+		children: [formula]
+	}];
+}
+function openListGroup(listStack, scopeChildren, text, level) {
+	for (let top = listStack.at(-1); top !== void 0 && top.level >= level; top = listStack.at(-1)) listStack.pop();
+	const node = {
+		text,
+		level,
+		children: []
+	};
+	const parent = listStack.at(-1);
+	(parent !== void 0 ? parent.children : scopeChildren).push(node);
+	listStack.push(node);
+}
+function paragraphText(paragraph) {
+	return paragraph.runs.map((run) => run.text).join("");
+}
+//#endregion
+//#region src/outline/effective.ts
+function effectivePackage(pkg) {
+	const styles = pkg.styles;
+	if (styles === void 0) return pkg;
+	switch (pkg.kind) {
+		case "wordprocessing": return withoutStyles({
+			...pkg,
+			children: pkg.children.map((group) => resolveSectionGroup(styles, [], group))
+		});
+		case "presentation": return withoutStyles({
+			...pkg,
+			children: pkg.children.map((group) => resolveSlideGroup(styles, [], group))
+		});
+		case "spreadsheet": return withoutStyles({
+			...pkg,
+			children: pkg.children.map(resolveSheetGroup)
+		});
+		case "drawing": return withoutStyles({
+			...pkg,
+			children: pkg.children.map((group) => resolveDrawPageGroup(styles, [], group))
+		});
+		case "formula": return withoutStyles({ ...pkg });
+	}
+}
+function withoutStyles(pkg) {
+	const copy = { ...pkg };
+	delete copy.styles;
+	return copy;
+}
+function chainWithRef(chain, group) {
+	return group.style === void 0 ? chain : [...chain, group.style];
+}
+function resolveSectionGroup(styles, chain, group) {
+	const children = resolveSectionChildren(styles, chainWithRef(chain, group), group.children);
+	if (group.style === void 0 && children === group.children) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveSlideGroup(styles, chain, group) {
+	const own = chainWithRef(chain, group);
+	let changed = group.style !== void 0;
+	const children = [];
+	for (const shape of group.children) {
+		const resolved = resolveShapeGroup(styles, own, shape);
+		changed ||= resolved !== shape;
+		children.push(resolved);
+	}
+	if (!changed) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveSheetGroup(group) {
+	return group.style === void 0 ? group : {
+		node: group.node,
+		children: group.children
+	};
+}
+function resolveDrawPageGroup(styles, chain, group) {
+	const own = chainWithRef(chain, group);
+	let changed = group.style !== void 0;
+	const children = [];
+	for (const child of group.children) {
+		const resolved = isShapeGroup(child) ? resolveShapeGroup(styles, own, child) : child;
+		changed ||= resolved !== child;
+		children.push(resolved);
+	}
+	if (!changed) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveShapeGroup(styles, chain, group) {
+	const children = resolveListChildren(styles, chainWithRef(chain, group), group.children);
+	if (group.style === void 0 && children === group.children) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveHeadingGroup(styles, chain, group) {
+	const own = chainWithRef(chain, group);
+	const entry = own.length > 0 ? (0, document_schema_js.resolveStyleChain)(styles, own) : void 0;
+	let anchor = group.node;
+	if (entry !== void 0) {
+		const applied = applyEntry(entry, group.node);
+		assertResolvedHeadingAnchor(applied);
+		anchor = applied;
+	}
+	const children = resolveSectionChildren(styles, own, group.children);
+	if (group.style === void 0 && anchor === group.node && children === group.children) return group;
+	return {
+		node: anchor,
+		children
+	};
+}
+function resolveListGroup(styles, chain, group) {
+	const own = chainWithRef(chain, group);
+	const entry = own.length > 0 ? (0, document_schema_js.resolveStyleChain)(styles, own) : void 0;
+	let anchor = group.node;
+	if (entry !== void 0) {
+		const applied = applyEntry(entry, group.node);
+		assertResolvedListAnchor(applied);
+		anchor = applied;
+	}
+	const children = resolveListChildren(styles, own, group.children);
+	if (group.style === void 0 && anchor === group.node && children === group.children) return group;
+	return {
+		node: anchor,
+		children
+	};
+}
+function assertResolvedHeadingAnchor(paragraph) {
+	if (paragraph.headingLevel === void 0) throw new Error("effectivePackage: resolution dropped a heading anchor's headingLevel");
+}
+function assertResolvedListAnchor(paragraph) {
+	if (paragraph.list === void 0) throw new Error("effectivePackage: resolution dropped a list anchor's list membership");
+}
+function resolveSectionChildren(styles, chain, children) {
+	let changed = false;
+	const out = [];
+	for (const child of children) {
+		let resolved;
+		if ((0, document_schema_js.isHeadingGroupNode)(child)) resolved = resolveHeadingGroup(styles, chain, child);
+		else if ((0, document_schema_js.isListGroupNode)(child)) resolved = resolveListGroup(styles, chain, child);
+		else if (child.kind === "paragraph") resolved = resolveParagraphLeaf(styles, chain, child);
+		else resolved = child;
+		changed ||= resolved !== child;
+		out.push(resolved);
+	}
+	return changed ? out : children;
+}
+function resolveListChildren(styles, chain, children) {
+	let changed = false;
+	const out = [];
+	for (const child of children) {
+		let resolved;
+		if ((0, document_schema_js.isListGroupNode)(child)) resolved = resolveListGroup(styles, chain, child);
+		else if (child.kind === "paragraph") resolved = resolveParagraphLeaf(styles, chain, child);
+		else resolved = child;
+		changed ||= resolved !== child;
+		out.push(resolved);
+	}
+	return changed ? out : children;
+}
+function resolveParagraphLeaf(styles, chain, leaf) {
+	if (chain.length === 0) return leaf;
+	return applyEntry((0, document_schema_js.resolveStyleChain)(styles, chain), leaf);
+}
+function applyEntry(entry, paragraph) {
+	const withParagraph = (0, document_schema_js.applyParagraphStyleProperties)(entry.paragraph, paragraph);
+	const runProperties = entry.run;
+	if (runProperties === void 0) return withParagraph;
+	return {
+		...withParagraph,
+		runs: withParagraph.runs.map((run) => (0, document_schema_js.applyRunStyleProperties)(runProperties, run))
+	};
+}
+function isShapeGroup(child) {
+	return "node" in child;
+}
+//#endregion
+//#region src/outline/node.ts
+function isOutlineLeaf(value) {
+	return (0, document_schema_js.isPackageLeaf)(value);
+}
+function isOutlineChild(value) {
+	return isOutlineNode(value) || isOutlineLeaf(value);
+}
+function isOutlineNode(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	if (!("text" in value) || typeof value.text !== "string") return false;
+	if (!("level" in value) || typeof value.level !== "number" || !Number.isFinite(value.level)) return false;
+	if (!("children" in value) || !Array.isArray(value.children)) return false;
+	return value.children.every(isOutlineChild);
+}
+const OutlineNodeSchema = zod.z.custom(isOutlineNode);
+//#endregion
+//#region src/outline/hash.ts
+function stableContentHash(value) {
+	return sha256Hex(new TextEncoder().encode(JSON.stringify(canonicalise(stripSchemaKeys(value)))));
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stripSchemaKeys(value) {
+	if (Array.isArray(value)) return value.map(stripSchemaKeys);
+	if (isRecord(value)) {
+		const stripped = {};
+		for (const [key, entry] of Object.entries(value)) {
+			if (key === "$schema") continue;
+			stripped[key] = stripSchemaKeys(entry);
+		}
+		return stripped;
+	}
+	return value;
+}
+function canonicalise(value) {
+	if (Array.isArray(value)) return value.map(canonicalise);
+	if (isRecord(value)) {
+		const sorted = {};
+		for (const key of Object.keys(value).sort()) sorted[key] = canonicalise(value[key]);
+		return sorted;
+	}
+	return value;
+}
+function sha256Hex(bytes) {
+	const digest = sha256(bytes);
+	let hex = "";
+	for (const byte of digest) hex += byte.toString(16).padStart(2, "0");
+	return hex;
+}
+const K = [
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+];
+function rotr(x, n) {
+	return (x >>> n | x << 32 - n) >>> 0;
+}
+function sha256(bytes) {
+	const bitLength = bytes.length * 8;
+	const paddedLength = (bytes.length + 8 >> 6) + 1 << 6;
+	const padded = new Uint8Array(paddedLength);
+	padded.set(bytes);
+	padded[bytes.length] = 128;
+	const view = new DataView(padded.buffer);
+	view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
+	view.setUint32(paddedLength - 4, bitLength >>> 0);
+	let h0 = 1779033703;
+	let h1 = 3144134277;
+	let h2 = 1013904242;
+	let h3 = 2773480762;
+	let h4 = 1359893119;
+	let h5 = 2600822924;
+	let h6 = 528734635;
+	let h7 = 1541459225;
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	for (let offset = 0; offset < paddedLength; offset += 64) {
+		for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4);
+		for (let i = 16; i < 64; i++) {
+			const w15 = w[i - 15];
+			const w2 = w[i - 2];
+			const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+			const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+			w[i] = w[i - 16] + s0 + w[i - 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 i = 0; i < 64; i++) {
+			const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const temp1 = h + s1 + ch + K[i] + w[i] >>> 0;
+			const temp2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 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;
+	}
+	const digest = /* @__PURE__ */ new Uint8Array(32);
+	const out = new DataView(digest.buffer);
+	out.setUint32(0, h0);
+	out.setUint32(4, h1);
+	out.setUint32(8, h2);
+	out.setUint32(12, h3);
+	out.setUint32(16, h4);
+	out.setUint32(20, h5);
+	out.setUint32(24, h6);
+	out.setUint32(28, h7);
+	return digest;
+}
+//#endregion
+//#region src/outline/helpers.ts
+function flattenOutline(children) {
+	const leaves = [];
+	const walk = (subtree) => {
+		for (const child of subtree) if (isOutlineNode(child)) walk(child.children);
+		else leaves.push(child);
+	};
+	walk(children);
+	return leaves;
+}
+function outlineLeafText(leaf) {
+	if ("runs" in leaf) return leaf.runs.map((run) => run.text).join("");
+	if ("rows" in leaf) return leaf.rows.map((row) => row.cells.map((cell) => blockTexts(cell.blocks).join(" ")).join(" ")).join("\n");
+	if ("base64" in leaf) return leaf.altText ?? "";
+	if ("mathml" in leaf) return leaf.presentation?.latex ?? "";
+	return "";
+}
+function blockTexts(blocks) {
+	const parts = [];
+	for (const block of blocks) {
+		if (block.kind === "paragraph") parts.push(block.runs.map((run) => run.text).join(""));
+		if (block.kind === "table") parts.push(...block.rows.flatMap((row) => row.cells.map((cell) => blockTexts(cell.blocks).join(" "))));
+	}
+	return parts;
+}
+function leafContentHash(leaf) {
+	return stableContentHash(leaf);
+}
+//#endregion
+exports.OutlineNodeSchema = OutlineNodeSchema;
+exports.buildOutline = buildOutline;
+exports.effectivePackage = effectivePackage;
+exports.flattenOutline = flattenOutline;
+exports.isOutlineChild = isOutlineChild;
+exports.isOutlineLeaf = isOutlineLeaf;
+exports.isOutlineNode = isOutlineNode;
+exports.leafContentHash = leafContentHash;
+exports.outlineLeafText = outlineLeafText;

package/dist/index.d.cts

@@ -0,0 +1,27 @@
+import { DocumentPackage, PackageLeaf } from "document-schema.js";
+import { z } from "zod";
+//#region src/outline/node.d.ts
+type OutlineLeaf = PackageLeaf;
+type OutlineChild = OutlineNode | OutlineLeaf;
+interface OutlineNode {
+  readonly text: string;
+  readonly level: number;
+  children: OutlineChild[];
+}
+declare function isOutlineLeaf(value: unknown): value is OutlineLeaf;
+declare function isOutlineChild(value: unknown): value is OutlineChild;
+declare function isOutlineNode(value: unknown): value is OutlineNode;
+declare const OutlineNodeSchema: z.ZodCustom<OutlineNode, OutlineNode>;
+//#endregion
+//#region src/outline/build.d.ts
+declare function buildOutline(pkg: DocumentPackage): OutlineChild[];
+//#endregion
+//#region src/outline/effective.d.ts
+declare function effectivePackage(pkg: DocumentPackage): DocumentPackage;
+//#endregion
+//#region src/outline/helpers.d.ts
+declare function flattenOutline(children: readonly OutlineChild[]): OutlineLeaf[];
+declare function outlineLeafText(leaf: OutlineLeaf): string;
+declare function leafContentHash(leaf: OutlineLeaf): string;
+//#endregion
+export { OutlineChild, OutlineLeaf, OutlineNode, OutlineNodeSchema, buildOutline, effectivePackage, flattenOutline, isOutlineChild, isOutlineLeaf, isOutlineNode, leafContentHash, outlineLeafText };

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import { DocumentPackage, PackageLeaf } from "document-schema.js";
+import { z } from "zod";
+//#region src/outline/node.d.ts
+type OutlineLeaf = PackageLeaf;
+type OutlineChild = OutlineNode | OutlineLeaf;
+interface OutlineNode {
+  readonly text: string;
+  readonly level: number;
+  children: OutlineChild[];
+}
+declare function isOutlineLeaf(value: unknown): value is OutlineLeaf;
+declare function isOutlineChild(value: unknown): value is OutlineChild;
+declare function isOutlineNode(value: unknown): value is OutlineNode;
+declare const OutlineNodeSchema: z.ZodCustom<OutlineNode, OutlineNode>;
+//#endregion
+//#region src/outline/build.d.ts
+declare function buildOutline(pkg: DocumentPackage): OutlineChild[];
+//#endregion
+//#region src/outline/effective.d.ts
+declare function effectivePackage(pkg: DocumentPackage): DocumentPackage;
+//#endregion
+//#region src/outline/helpers.d.ts
+declare function flattenOutline(children: readonly OutlineChild[]): OutlineLeaf[];
+declare function outlineLeafText(leaf: OutlineLeaf): string;
+declare function leafContentHash(leaf: OutlineLeaf): string;
+//#endregion
+export { OutlineChild, OutlineLeaf, OutlineNode, OutlineNodeSchema, buildOutline, effectivePackage, flattenOutline, isOutlineChild, isOutlineLeaf, isOutlineNode, leafContentHash, outlineLeafText };

package/dist/index.js

@@ -0,0 +1,500 @@
+import { applyParagraphStyleProperties, applyRunStyleProperties, isHeadingGroupNode, isListGroupNode, isPackageLeaf, isShapeGroupNode, resolveStyleChain } from "document-schema.js";
+import { z } from "zod";
+//#region src/outline/build.ts
+function buildOutline(pkg) {
+	switch (pkg.kind) {
+		case "wordprocessing": return wordprocessingOutline(pkg.children);
+		case "presentation": return presentationOutline(pkg.children);
+		case "spreadsheet": return spreadsheetOutline(pkg.children);
+		case "drawing": return drawingOutline(pkg.children);
+		case "formula": return formulaOutline(pkg.children[0]);
+	}
+}
+function wordprocessingOutline(sections) {
+	const root = [];
+	const headingStack = [];
+	const listStack = [];
+	const headingScope = () => headingStack.at(-1)?.children ?? root;
+	const walk = (children) => {
+		for (const child of children) if (isHeadingGroupNode(child)) {
+			listStack.length = 0;
+			const level = child.node.headingLevel;
+			for (let top = headingStack.at(-1); top !== void 0 && top.level >= level; top = headingStack.at(-1)) headingStack.pop();
+			const node = {
+				text: paragraphText(child.node),
+				level,
+				children: []
+			};
+			const parent = headingStack.at(-1);
+			(parent !== void 0 ? parent.children : root).push(node);
+			headingStack.push(node);
+			walk(child.children);
+		} else if (isListGroupNode(child)) {
+			openListGroup(listStack, headingScope(), paragraphText(child.node), child.node.list.level);
+			walk(child.children);
+		} else if (child.kind === "paragraph") {
+			listStack.length = 0;
+			headingScope().push(child);
+		} else {
+			const parent = listStack.at(-1);
+			(parent !== void 0 ? parent.children : headingScope()).push(child);
+		}
+	};
+	for (const section of sections) walk(section.children);
+	return root;
+}
+function presentationOutline(slides) {
+	return slides.map((slide, index) => {
+		const group = {
+			text: `Slide ${String(index + 1)}`,
+			level: 1,
+			children: []
+		};
+		const listStack = [];
+		const walk = (children) => {
+			for (const child of children) if (isListGroupNode(child)) {
+				openListGroup(listStack, group.children, paragraphText(child.node), child.node.list.level);
+				walk(child.children);
+			} else if (child.kind === "paragraph") {
+				listStack.length = 0;
+				group.children.push(child);
+			} else {
+				const parent = listStack.at(-1);
+				(parent !== void 0 ? parent.children : group.children).push(child);
+			}
+		};
+		for (const shape of slide.children) walk(shape.children);
+		return group;
+	});
+}
+function spreadsheetOutline(sheets) {
+	return sheets.map((sheet) => ({
+		text: sheet.node.name,
+		level: 1,
+		children: [...sheet.children]
+	}));
+}
+function drawingOutline(pages) {
+	return pages.map((page, index) => ({
+		text: `Page ${String(index + 1)}`,
+		level: 1,
+		children: page.children.flatMap((child) => isShapeGroupNode(child) ? flattenShapeChildren(child) : [child])
+	}));
+}
+function flattenShapeChildren(group) {
+	return flattenListFlow(group.children);
+}
+function flattenListFlow(children) {
+	const leaves = [];
+	for (const child of children) if (isListGroupNode(child)) leaves.push(child.node, ...flattenListFlow(child.children));
+	else leaves.push(child);
+	return leaves;
+}
+function formulaOutline(formula) {
+	return [{
+		text: formula.presentation?.latex ?? "",
+		level: 1,
+		children: [formula]
+	}];
+}
+function openListGroup(listStack, scopeChildren, text, level) {
+	for (let top = listStack.at(-1); top !== void 0 && top.level >= level; top = listStack.at(-1)) listStack.pop();
+	const node = {
+		text,
+		level,
+		children: []
+	};
+	const parent = listStack.at(-1);
+	(parent !== void 0 ? parent.children : scopeChildren).push(node);
+	listStack.push(node);
+}
+function paragraphText(paragraph) {
+	return paragraph.runs.map((run) => run.text).join("");
+}
+//#endregion
+//#region src/outline/effective.ts
+function effectivePackage(pkg) {
+	const styles = pkg.styles;
+	if (styles === void 0) return pkg;
+	switch (pkg.kind) {
+		case "wordprocessing": return withoutStyles({
+			...pkg,
+			children: pkg.children.map((group) => resolveSectionGroup(styles, [], group))
+		});
+		case "presentation": return withoutStyles({
+			...pkg,
+			children: pkg.children.map((group) => resolveSlideGroup(styles, [], group))
+		});
+		case "spreadsheet": return withoutStyles({
+			...pkg,
+			children: pkg.children.map(resolveSheetGroup)
+		});
+		case "drawing": return withoutStyles({
+			...pkg,
+			children: pkg.children.map((group) => resolveDrawPageGroup(styles, [], group))
+		});
+		case "formula": return withoutStyles({ ...pkg });
+	}
+}
+function withoutStyles(pkg) {
+	const copy = { ...pkg };
+	delete copy.styles;
+	return copy;
+}
+function chainWithRef(chain, group) {
+	return group.style === void 0 ? chain : [...chain, group.style];
+}
+function resolveSectionGroup(styles, chain, group) {
+	const children = resolveSectionChildren(styles, chainWithRef(chain, group), group.children);
+	if (group.style === void 0 && children === group.children) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveSlideGroup(styles, chain, group) {
+	const own = chainWithRef(chain, group);
+	let changed = group.style !== void 0;
+	const children = [];
+	for (const shape of group.children) {
+		const resolved = resolveShapeGroup(styles, own, shape);
+		changed ||= resolved !== shape;
+		children.push(resolved);
+	}
+	if (!changed) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveSheetGroup(group) {
+	return group.style === void 0 ? group : {
+		node: group.node,
+		children: group.children
+	};
+}
+function resolveDrawPageGroup(styles, chain, group) {
+	const own = chainWithRef(chain, group);
+	let changed = group.style !== void 0;
+	const children = [];
+	for (const child of group.children) {
+		const resolved = isShapeGroup(child) ? resolveShapeGroup(styles, own, child) : child;
+		changed ||= resolved !== child;
+		children.push(resolved);
+	}
+	if (!changed) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveShapeGroup(styles, chain, group) {
+	const children = resolveListChildren(styles, chainWithRef(chain, group), group.children);
+	if (group.style === void 0 && children === group.children) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveHeadingGroup(styles, chain, group) {
+	const own = chainWithRef(chain, group);
+	const entry = own.length > 0 ? resolveStyleChain(styles, own) : void 0;
+	let anchor = group.node;
+	if (entry !== void 0) {
+		const applied = applyEntry(entry, group.node);
+		assertResolvedHeadingAnchor(applied);
+		anchor = applied;
+	}
+	const children = resolveSectionChildren(styles, own, group.children);
+	if (group.style === void 0 && anchor === group.node && children === group.children) return group;
+	return {
+		node: anchor,
+		children
+	};
+}
+function resolveListGroup(styles, chain, group) {
+	const own = chainWithRef(chain, group);
+	const entry = own.length > 0 ? resolveStyleChain(styles, own) : void 0;
+	let anchor = group.node;
+	if (entry !== void 0) {
+		const applied = applyEntry(entry, group.node);
+		assertResolvedListAnchor(applied);
+		anchor = applied;
+	}
+	const children = resolveListChildren(styles, own, group.children);
+	if (group.style === void 0 && anchor === group.node && children === group.children) return group;
+	return {
+		node: anchor,
+		children
+	};
+}
+function assertResolvedHeadingAnchor(paragraph) {
+	if (paragraph.headingLevel === void 0) throw new Error("effectivePackage: resolution dropped a heading anchor's headingLevel");
+}
+function assertResolvedListAnchor(paragraph) {
+	if (paragraph.list === void 0) throw new Error("effectivePackage: resolution dropped a list anchor's list membership");
+}
+function resolveSectionChildren(styles, chain, children) {
+	let changed = false;
+	const out = [];
+	for (const child of children) {
+		let resolved;
+		if (isHeadingGroupNode(child)) resolved = resolveHeadingGroup(styles, chain, child);
+		else if (isListGroupNode(child)) resolved = resolveListGroup(styles, chain, child);
+		else if (child.kind === "paragraph") resolved = resolveParagraphLeaf(styles, chain, child);
+		else resolved = child;
+		changed ||= resolved !== child;
+		out.push(resolved);
+	}
+	return changed ? out : children;
+}
+function resolveListChildren(styles, chain, children) {
+	let changed = false;
+	const out = [];
+	for (const child of children) {
+		let resolved;
+		if (isListGroupNode(child)) resolved = resolveListGroup(styles, chain, child);
+		else if (child.kind === "paragraph") resolved = resolveParagraphLeaf(styles, chain, child);
+		else resolved = child;
+		changed ||= resolved !== child;
+		out.push(resolved);
+	}
+	return changed ? out : children;
+}
+function resolveParagraphLeaf(styles, chain, leaf) {
+	if (chain.length === 0) return leaf;
+	return applyEntry(resolveStyleChain(styles, chain), leaf);
+}
+function applyEntry(entry, paragraph) {
+	const withParagraph = applyParagraphStyleProperties(entry.paragraph, paragraph);
+	const runProperties = entry.run;
+	if (runProperties === void 0) return withParagraph;
+	return {
+		...withParagraph,
+		runs: withParagraph.runs.map((run) => applyRunStyleProperties(runProperties, run))
+	};
+}
+function isShapeGroup(child) {
+	return "node" in child;
+}
+//#endregion
+//#region src/outline/node.ts
+function isOutlineLeaf(value) {
+	return isPackageLeaf(value);
+}
+function isOutlineChild(value) {
+	return isOutlineNode(value) || isOutlineLeaf(value);
+}
+function isOutlineNode(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	if (!("text" in value) || typeof value.text !== "string") return false;
+	if (!("level" in value) || typeof value.level !== "number" || !Number.isFinite(value.level)) return false;
+	if (!("children" in value) || !Array.isArray(value.children)) return false;
+	return value.children.every(isOutlineChild);
+}
+const OutlineNodeSchema = z.custom(isOutlineNode);
+//#endregion
+//#region src/outline/hash.ts
+function stableContentHash(value) {
+	return sha256Hex(new TextEncoder().encode(JSON.stringify(canonicalise(stripSchemaKeys(value)))));
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stripSchemaKeys(value) {
+	if (Array.isArray(value)) return value.map(stripSchemaKeys);
+	if (isRecord(value)) {
+		const stripped = {};
+		for (const [key, entry] of Object.entries(value)) {
+			if (key === "$schema") continue;
+			stripped[key] = stripSchemaKeys(entry);
+		}
+		return stripped;
+	}
+	return value;
+}
+function canonicalise(value) {
+	if (Array.isArray(value)) return value.map(canonicalise);
+	if (isRecord(value)) {
+		const sorted = {};
+		for (const key of Object.keys(value).sort()) sorted[key] = canonicalise(value[key]);
+		return sorted;
+	}
+	return value;
+}
+function sha256Hex(bytes) {
+	const digest = sha256(bytes);
+	let hex = "";
+	for (const byte of digest) hex += byte.toString(16).padStart(2, "0");
+	return hex;
+}
+const K = [
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+];
+function rotr(x, n) {
+	return (x >>> n | x << 32 - n) >>> 0;
+}
+function sha256(bytes) {
+	const bitLength = bytes.length * 8;
+	const paddedLength = (bytes.length + 8 >> 6) + 1 << 6;
+	const padded = new Uint8Array(paddedLength);
+	padded.set(bytes);
+	padded[bytes.length] = 128;
+	const view = new DataView(padded.buffer);
+	view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
+	view.setUint32(paddedLength - 4, bitLength >>> 0);
+	let h0 = 1779033703;
+	let h1 = 3144134277;
+	let h2 = 1013904242;
+	let h3 = 2773480762;
+	let h4 = 1359893119;
+	let h5 = 2600822924;
+	let h6 = 528734635;
+	let h7 = 1541459225;
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	for (let offset = 0; offset < paddedLength; offset += 64) {
+		for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4);
+		for (let i = 16; i < 64; i++) {
+			const w15 = w[i - 15];
+			const w2 = w[i - 2];
+			const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+			const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+			w[i] = w[i - 16] + s0 + w[i - 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 i = 0; i < 64; i++) {
+			const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const temp1 = h + s1 + ch + K[i] + w[i] >>> 0;
+			const temp2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 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;
+	}
+	const digest = /* @__PURE__ */ new Uint8Array(32);
+	const out = new DataView(digest.buffer);
+	out.setUint32(0, h0);
+	out.setUint32(4, h1);
+	out.setUint32(8, h2);
+	out.setUint32(12, h3);
+	out.setUint32(16, h4);
+	out.setUint32(20, h5);
+	out.setUint32(24, h6);
+	out.setUint32(28, h7);
+	return digest;
+}
+//#endregion
+//#region src/outline/helpers.ts
+function flattenOutline(children) {
+	const leaves = [];
+	const walk = (subtree) => {
+		for (const child of subtree) if (isOutlineNode(child)) walk(child.children);
+		else leaves.push(child);
+	};
+	walk(children);
+	return leaves;
+}
+function outlineLeafText(leaf) {
+	if ("runs" in leaf) return leaf.runs.map((run) => run.text).join("");
+	if ("rows" in leaf) return leaf.rows.map((row) => row.cells.map((cell) => blockTexts(cell.blocks).join(" ")).join(" ")).join("\n");
+	if ("base64" in leaf) return leaf.altText ?? "";
+	if ("mathml" in leaf) return leaf.presentation?.latex ?? "";
+	return "";
+}
+function blockTexts(blocks) {
+	const parts = [];
+	for (const block of blocks) {
+		if (block.kind === "paragraph") parts.push(block.runs.map((run) => run.text).join(""));
+		if (block.kind === "table") parts.push(...block.rows.flatMap((row) => row.cells.map((cell) => blockTexts(cell.blocks).join(" "))));
+	}
+	return parts;
+}
+function leafContentHash(leaf) {
+	return stableContentHash(leaf);
+}
+//#endregion
+export { OutlineNodeSchema, buildOutline, effectivePackage, flattenOutline, isOutlineChild, isOutlineLeaf, isOutlineNode, leafContentHash, outlineLeafText };

package/package.json

@@ -1,5 +1,93 @@
 {
   "name": "document-outline.js",
-  "version": "0.0.0",
-  "private": false
+  "version": "1.0.0",
+  "description": "Utilities for consumers holding a tree-form DocumentPackage - the TOC outline projection, effective-property resolution, and flatten/leaf-text/stable-hash helpers, the outline package for the documents.js family.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExaDev/document-outline.js.git"
+  },
+  "homepage": "https://github.com/ExaDev/document-outline.js#readme",
+  "bugs": {
+    "url": "https://github.com/ExaDev/document-outline.js/issues"
+  },
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/index.d.ts",
+        "require": "./dist/index.d.cts"
+      },
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./*": {
+      "types": {
+        "import": "./dist/*.d.ts",
+        "require": "./dist/*.d.cts"
+      },
+      "import": "./dist/*.js",
+      "require": "./dist/*.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "turbo run _build",
+    "_build": "tsdown",
+    "prepublishOnly": "pnpm run lint && pnpm run typecheck && tsdown && publint && attw --pack",
+    "lint": "turbo run _lint",
+    "_lint": "eslint . --fix --cache --max-warnings 0",
+    "lint:check": "eslint . --max-warnings 0",
+    "typecheck": "turbo run _typecheck",
+    "_typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.node.json",
+    "test": "turbo run _test",
+    "_test": "vitest run",
+    "test:watch": "vitest",
+    "test:workers": "turbo run _test:workers",
+    "_test:workers": "vitest run --config vitest.workers.config.ts",
+    "prepare": "husky"
+  },
+  "packageManager": "pnpm@11.6.0",
+  "dependencies": {
+    "document-schema.js": "^4.0.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@cloudflare/vitest-pool-workers": "^0.20.1",
+    "@commitlint/cli": "^21.2.1",
+    "@commitlint/config-conventional": "^21.2.0",
+    "@eslint/js": "^10.0.1",
+    "@semantic-release/changelog": "^7.0.0",
+    "@semantic-release/git": "^11.0.1",
+    "@types/node": "^26.1.2",
+    "eslint": "^10.8.0",
+    "globals": "^17.8.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.2.0",
+    "publint": "^0.3.21",
+    "semantic-release": "^25.0.8",
+    "tsdown": "^0.22.13",
+    "turbo": "^2.10.8",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.65.0",
+    "vitest": "^4.1.10"
+  },
+  "lint-staged": {
+    "*.ts": "eslint --fix"
+  }
 }