@superbee/core 0.2.0-pre.16 → 0.2.0-pre.17

package/README.md

@@ -173,6 +173,103 @@ target this bundle's edition), `RecipeAssetConflict` (`recipe`, `key`), `RecipeE
 `RecipeEvolutionInterrupted` (`reason`, `completed`, `pending`, `cause`) and
 `RecipeEvolutionPostcondition` (`reason`, `completed`).
 
+## Record overlay
+
+`@superbee/core/record-overlay` is the write half of binding documents to external records. A
+Source Feed policy names the fields a feed owns; the caller fetches and diffs its records and hands
+the changes to the planner. It uses no Node globals or builtins, so it runs in Node, a browser or a
+Worker over any storage backend.
+
+```ts
+import { MemoryBackend } from "@superbee/core/memory-backend";
+import { buildKindRegistry } from "@superbee/core/kinds";
+import { applyRecordOverlay, buildSourceIndex, planRecordOverlay, readOverlayPolicy } from "@superbee/core/record-overlay";
+
+const bundle = { root: "memory://guide", backend: new MemoryBackend() };
+const registry = buildKindRegistry(conventionDocs);
+const guide = { bundle, registry, okfVersion: "0.2" as const };
+const policy = readOverlayPolicy(sourceFeedDoc, { targetKind: registry.kinds.get("Event") });
+const overlays = await buildSourceIndex(bundle, { type: policy.target_kind });
+const plan = await planRecordOverlay({ content: guide, ops: guide, policy, changes, observedAt, overlays });
+const receipt = await applyRecordOverlay(plan, { content: guide, ops: guide, policy, actor: "process:calendar-sync", overlays });
+```
+
+For each owned field the plan compares the last accepted feed value, the new feed value and the
+document's value: a document that already says the new value is left alone, one that still says
+the old value is written, and anything else is an `OVERLAY_DOC_CONFLICT` with a Signal, so an
+editor's override is never overwritten. Each step carries the version it was planned against.
+`applyRecordOverlay` writes every step through `mutateDocument` with a guard core builds itself and
+runs on the fresh read: an owned-field write reaches documents of the policy's target Kind only,
+may change only owned and derived fields, never the body, and needs the record's `sources`
+identity; a Signal may be created only as a new, unclaimed document of the attention Kind under its
+path, and updated only in a fixed set of fields plus one appended observation line. Signal writes
+are bound to the provider of the policy the caller passes, never to a field of the plan, and an id
+held by another provider's Signal is refused. A Signal's text must be the planner's rendering of
+its own fields and the run (its observation line, links to the plan's feed and to documents, the
+adoption hint): every plan the planner makes passes, and other text is a held `INVALID_INPUT` row,
+so a mismatch is visible and planned again rather than dropped. Nothing of the
+target Kind is created and nothing is deleted. A feed never owns its target's work state: the
+progress storage fields and the target Kind's claim fields are refused like `status`. The
+attention Kind (default `Signal`) must declare a claim owner and state field and the fields
+`change_kind`, `observed_at`, `provider`, `external_id` and `diff_summary`.
+
+Site rules are hooks with safe defaults: `textGate` (identity), `interval` (none, so a disappeared
+record is always raised), `correlate`, `sourceProperties` (an upsert of the record's `sources`
+entry in the same write, OKF v0.2 only), `assertCandidate` (site candidate checks after the core
+guards) and `deriveFields` (fields such as `updated_at` written in the same version). Refusals are
+receipt rows with a `REFUSAL_CODES` code; `RETRYABLE` and `HOLD_STORE` say which leave a record to be
+planned again. A value core's write policy refuses (an OKF v0.2 field type, for example) is a held
+`INVALID_INPUT` row, so one bad record never stops the rest of a run. A malformed plan (an unknown
+step, a non-canonical target, written values that are not JSON data with finite numbers, prototype
+keys, non-scalar or identity `sources` properties), actor or bundle edition throws `OverlayRefusal`
+before any write, and so does a plan with owned-field steps whose policy names no declared target
+Kind or whose owned or derived list names a field a feed can never own.
+
+`SourceIndex` holds one head read for a whole run. It is bounded to that run: an edited or deleted
+overlay is still caught at write time, but a second document given an identity during the run is
+only refused as ambiguous on the next run.
+
+## Bundle health
+
+`@superbee/core/bundle-health` computes the health report behind `superbee status` from a core
+`Bundle` on any backend: malformed documents, Kind lint and conformance debt, registry warnings,
+unresolved links, orphans, freshness and invalid timestamps, trust tiers, the two graph lints, the
+View surface, cross-bundle links, the OKF v0.1 upgrade finding and legacy naming. It uses no Node
+globals or builtins, so it runs in Node, a browser or a Worker. The caller presents the report;
+the CLI adds row caps, help text and its home and sync blocks.
+
+```ts
+import { MemoryBackend } from "@superbee/core/memory-backend";
+import { bundleHealth } from "@superbee/core/bundle-health";
+
+const bundle = { root: "memory://guide", backend: new MemoryBackend() };
+const report = await bundleHealth(bundle, { now: new Date() });
+const gate = { malformed: report.malformed.length, kind_warnings: report.kindLint.length, unresolved_links: report.unresolvedLinks.length };
+```
+
+The report reads only: one Kind registry load, one lenient query, two prefix-scoped blob listings
+and one root-index read, with every finding derived in memory. A document whose frontmatter does
+not parse is a `malformed` row (the root index first), never a thrown error. Top-level keys are
+camelCase; rows keep snake_case keys (`age_ms`, `bundle_id`, `incompatible_values`) and arrive
+whole, in report order, for the caller to cap. Sections whose presence depends on the bundle are
+null when absent: `conformanceDebt` without any declared Kind, `trust` outside a non-empty v0.2
+bundle, `crossBundle` without `docs/dependencies` or any `okf:` link, `okfUpgrade` outside a v0.1
+bundle with a workflow-status collision. `crossLinkTypeViolations` is always an array, because a
+local edge under a qualified declaration needs no dependencies. The stored values in
+`invalidStaleAfter`, `invalidTimestamps` and `invalidLegacyTimestamps` are made JSON-safe;
+`missingExpectedLinks[].status` is the raw stored value.
+
+Nothing outside the bundle is read unless the caller binds it. `bindings` is a map of bound copies
+by alias, or a hook core calls exactly once, after every read and with its own parse of
+`docs/dependencies` (a self alias already dropped as `DEP_SELF`, using `selfBundleId` when
+`docs/bundle` declares no id). Whatever the hook throws propagates unchanged. Each binding's
+verdict comes from core's resolver, and `dependencies[].bound` is the binding's `label`.
+
+`bundleKindFindings(documents, okfVersion, { actor, producer })` answers a different question:
+which Kind problems a strict host write would refuse, preparing each document as its first edit,
+so a timestamp or actor the write supplies is no finding. The CLI's publish preview runs it; the
+report's `kindLint` stays advisory. Both use core's one validator, `validateAgainstKind`.
+
 ## Hosted client
 
 `@superbee/core/hosted-client` is the headless client of a hosted Superbee's sync routes
@@ -256,14 +353,20 @@ Each write has one request identity and carries the client's binding, a digest o
 client mints once (its `within` clients share it). When an answer is lost (a transport failure or
 a deadline after sending), the client looks the identity up on the host and reports what the host
 recorded. The host's outcome route tells a request it never received ("absent") from one still in
-progress ("pending"), but the shared transport reports both as "no outcome yet". On that answer
-`write` sends the same identity once more, which the host applies at most once. Absence counts as
+progress ("pending"), and the shared transport keeps the two apart. On either answer `write`
+sends the same identity once more, which the host applies at most once; after "pending", an
+earlier delivery is known to be held. Absence counts as
 evidence only within the retention window the host serves in its capabilities
 (`operationsRetentionMs`, less an hour's margin); past it, the result stays `unknown` and nothing
 is resent. The client measures an intent's age by its own clock against the host's window, so that
 margin holds only while the client's clock is within an hour of the host's. A resend refused before
 it reaches the host's execution (no credential, access withdrawn, a spent quota) leaves the result
-`unknown` too, since the first delivery may still commit. When the lookups themselves fail, or the caller's `signal` aborts after sending, the
+`unknown` too, since the first delivery may still commit; after a "pending" lookup, so does any
+refusal before execution, a gateway's `400` included. The result's `refusal` (`{ code, message }`)
+names that refusal, so an app can say why the write is waiting (for example, access withdrawn)
+while it stays held; only the call that met the refusal reports it. Absence alone never settles
+such a write: a delayed first delivery is authorized when it arrives, so it can still commit once
+access returns. When the lookups themselves fail, or the caller's `signal` aborts after sending, the
 result is `unknown`.
 
 An `unknown` write can be resolved later in two ways:
@@ -271,7 +374,7 @@ An `unknown` write can be resolved later in two ways:
 - `lookupWrite(requestId)` makes one outcome lookup and never sends the write. When the host holds
   no outcome yet (absent or pending), the answer stays `unknown`.
 - `settleWrite(requestId)` looks the identity up and, when the host never recorded it within its
-  retention window, sends the same identity once more, as `write` would have.
+  retention window or holds it pending, sends the same identity once more, as `write` would have.
 
 Both answer `{ status: "unrecorded", requestId }` when the intent store holds no write under that
 identity: it was never recorded there, or it already settled and left the store. Both return

package/dist/bundle-health/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `@superbee/core/bundle-health`: the health report behind `superbee status`, computed from a core
+ * `Bundle` on any backend. The caller resolves what lives outside the bundle (bound copies of its
+ * dependencies, the clock, a fallback bundle id) and presents the report; the `superbee` CLI is one
+ * such caller. It also holds `bundleKindFindings`, the one rule for the Kind problems a strict host
+ * write would refuse, which publish preview and hosted bundle creation run. Storage-neutral: no Node
+ * globals or builtins.
+ */
+export { bundleHealth } from "./report.js";
+export type { BindDependencies, BundleHealthOptions, BundleHealthReport, CrossBundleHealth, CrossLinkTypeViolationRow, CrossUnresolvedRow, DanglingEntryRow, DependencyProblemRow, DependencyRow, DocTypeRow, FieldValueRow, InvalidRegistrationRow, KindLintRow, LegacyNamingFindings, LinkTypeViolationRow, MalformedRow, MissingExpectedRow, OkfUpgradeFinding, StaleRow, StatusFieldRow, UnresolvedLinkRow, ValueRow, ViewSurfaceHealth, } from "./report.js";
+export { bundleKindFindings, bundleKindRegistry, documentKindFinding, isRegistryConvention } from "./kind-findings.js";
+export type { BundleKindFindings, KindFinding, KindWriteIdentity } from "./kind-findings.js";
+export { LEGACY_PAGE_TYPE_NAME, isLegacyPageDoc } from "./legacy-page.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/bundle-health/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bundle-health/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EACV,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,yBAAyB,EACzB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,EACb,UAAU,EACV,aAAa,EACb,sBAAsB,EACtB,WAAW,EACX,oBAAoB,EACpB,oBAAoB,EACpB,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,QAAQ,EACR,cAAc,EACd,iBAAiB,EACjB,QAAQ,EACR,iBAAiB,GAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACvH,YAAY,EAAE,kBAAkB,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC7F,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/bundle-health/index.js

@@ -0,0 +1,12 @@
+/**
+ * `@superbee/core/bundle-health`: the health report behind `superbee status`, computed from a core
+ * `Bundle` on any backend. The caller resolves what lives outside the bundle (bound copies of its
+ * dependencies, the clock, a fallback bundle id) and presents the report; the `superbee` CLI is one
+ * such caller. It also holds `bundleKindFindings`, the one rule for the Kind problems a strict host
+ * write would refuse, which publish preview and hosted bundle creation run. Storage-neutral: no Node
+ * globals or builtins.
+ */
+export { bundleHealth } from "./report.js";
+export { bundleKindFindings, bundleKindRegistry, documentKindFinding, isRegistryConvention } from "./kind-findings.js";
+export { LEGACY_PAGE_TYPE_NAME, isLegacyPageDoc } from "./legacy-page.js";
+//# sourceMappingURL=index.js.map

package/dist/bundle-health/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bundle-health/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA0B3C,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAEvH,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/bundle-health/kind-findings.d.ts

@@ -0,0 +1,44 @@
+import { type KindRegistry } from "../kinds.js";
+import type { OkfDocument } from "../types.js";
+import type { ValidationWarning } from "../validation.js";
+/**
+ * Who the checked first edit is attributed to. `producer` defaults to `actor`, as a write's does.
+ * On OKF v0.2 a `person:` actor cannot be a producer, so a v0.2 call with a `person:` actor must
+ * pass a `process:` (or `<producer>/<version>`) producer, or the check throws `OkfActorError`.
+ */
+export interface KindWriteIdentity {
+    actor: string;
+    producer?: string;
+}
+export interface KindFinding {
+    readonly id: string;
+    readonly governs: string;
+    readonly violations: readonly ValidationWarning[];
+    /** Core's own sentence: `'<id>' does not satisfy the '<Kind>' kind: …`. */
+    readonly message: string;
+}
+export interface BundleKindFindings {
+    /** Registry warnings: every strict write to the bundle refuses while any is present. */
+    readonly conventions: readonly ValidationWarning[];
+    /** Documents whose first strict edit would refuse for their Kind. */
+    readonly documents: readonly KindFinding[];
+}
+/** Whether `loadKinds` builds the Kind registry from this document: a `Convention` under `conventions/`. */
+export declare function isRegistryConvention(doc: OkfDocument): boolean;
+/** The Kind registry a bundle holding `documents` loads, built with `loadKinds`' own filter and builder. */
+export declare function bundleKindRegistry(documents: readonly OkfDocument[], okfVersion: "0.1" | "0.2"): KindRegistry;
+/**
+ * The Kind problem a strict write would refuse the first edit of one stored document over, or
+ * null. The document is prepared as its first edit: the stored document as the existing one and a
+ * body one line longer as the candidate, so unchanged values keep the leniency an edit gives them.
+ * An edit refused for another reason (a malformed standard field it changes) is not a Kind problem.
+ */
+export declare function documentKindFinding(doc: OkfDocument, registry: KindRegistry, okfVersion: "0.1" | "0.2", write: KindWriteIdentity): KindFinding | null;
+/**
+ * The Kind problems in `documents` (as stored) that strict writes would refuse over: the warnings
+ * of the registry their conventions build, and each document's own finding against it, in input
+ * order. Each document is checked on its own, so a bundle checked in parts against the same
+ * registry finds exactly this.
+ */
+export declare function bundleKindFindings(documents: readonly OkfDocument[], okfVersion: "0.1" | "0.2", write: KindWriteIdentity): BundleKindFindings;
+//# sourceMappingURL=kind-findings.d.ts.map

package/dist/bundle-health/kind-findings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind-findings.d.ts","sourceRoot":"","sources":["../../src/bundle-health/kind-findings.ts"],"names":[],"mappings":"AAaA,OAAO,EAA0D,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAExG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAClD,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,wFAAwF;IACxF,QAAQ,CAAC,WAAW,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACnD,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,SAAS,WAAW,EAAE,CAAC;CAC5C;AAED,4GAA4G;AAC5G,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAE9D;AAED,4GAA4G;AAC5G,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,WAAW,EAAE,EAAE,UAAU,EAAE,KAAK,GAAG,KAAK,GAAG,YAAY,CAE7G;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,YAAY,EACtB,UAAU,EAAE,KAAK,GAAG,KAAK,EACzB,KAAK,EAAE,iBAAiB,GACvB,WAAW,GAAG,IAAI,CAuBpB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,SAAS,WAAW,EAAE,EACjC,UAAU,EAAE,KAAK,GAAG,KAAK,EACzB,KAAK,EAAE,iBAAiB,GACvB,kBAAkB,CAQpB"}

package/dist/bundle-health/kind-findings.js

@@ -0,0 +1,68 @@
+/**
+ * The Kind problems a strict host write would refuse a bundle over, before the bundle exists. A
+ * strict write refuses while the Kind registry has any warning, and it prepares and validates its
+ * candidate with `prepareDocumentMutationCandidate`, which supplies the timestamp, actor and v0.2
+ * metadata a write adds. This is the one rule for "what would the host refuse": the CLI's publish
+ * preview runs it, and a host's bundle creation runs it with its own producer.
+ *
+ * It asks a different question from the health report's Kind lint (`kindLint`,
+ * `conformanceDebt`), which reports what is wrong with each stored document as advice. Both run
+ * core's one validator, `validateAgainstKind`.
+ */
+import { KindConformanceError, prepareDocumentMutationCandidate } from "../document-mutation.js";
+import { InvalidInputError, OkfActorError } from "../errors.js";
+import { buildKindRegistry, CONVENTION_TYPE, CONVENTIONS_PREFIX } from "../kinds.js";
+import { matchesFilter } from "../query-filter.js";
+/** Whether `loadKinds` builds the Kind registry from this document: a `Convention` under `conventions/`. */
+export function isRegistryConvention(doc) {
+    return matchesFilter(doc, { prefix: CONVENTIONS_PREFIX, type: CONVENTION_TYPE });
+}
+/** The Kind registry a bundle holding `documents` loads, built with `loadKinds`' own filter and builder. */
+export function bundleKindRegistry(documents, okfVersion) {
+    return buildKindRegistry(documents.filter(isRegistryConvention), [], { okfVersion });
+}
+/**
+ * The Kind problem a strict write would refuse the first edit of one stored document over, or
+ * null. The document is prepared as its first edit: the stored document as the existing one and a
+ * body one line longer as the candidate, so unchanged values keep the leniency an edit gives them.
+ * An edit refused for another reason (a malformed standard field it changes) is not a Kind problem.
+ */
+export function documentKindFinding(doc, registry, okfVersion, write) {
+    try {
+        prepareDocumentMutationCandidate(doc, { frontmatter: doc.frontmatter, body: `${doc.body ?? ""}\n` }, {
+            strict: true,
+            persistActor: true,
+            ...(write.producer === undefined ? {} : { producer: write.producer }),
+            id: doc.id,
+            registry,
+            okfVersion,
+            actor: write.actor,
+        });
+    }
+    catch (error) {
+        if (error instanceof KindConformanceError) {
+            return { id: doc.id, governs: error.governs, violations: error.violations, message: error.message };
+        }
+        if (error instanceof InvalidInputError && !(error instanceof OkfActorError))
+            return null;
+        throw error;
+    }
+    return null;
+}
+/**
+ * The Kind problems in `documents` (as stored) that strict writes would refuse over: the warnings
+ * of the registry their conventions build, and each document's own finding against it, in input
+ * order. Each document is checked on its own, so a bundle checked in parts against the same
+ * registry finds exactly this.
+ */
+export function bundleKindFindings(documents, okfVersion, write) {
+    const registry = bundleKindRegistry(documents, okfVersion);
+    const found = [];
+    for (const doc of documents) {
+        const finding = documentKindFinding(doc, registry, okfVersion, write);
+        if (finding)
+            found.push(finding);
+    }
+    return { conventions: registry.warnings, documents: found };
+}
+//# sourceMappingURL=kind-findings.js.map

package/dist/bundle-health/kind-findings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind-findings.js","sourceRoot":"","sources":["../../src/bundle-health/kind-findings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,oBAAoB,EAAE,gCAAgC,EAAE,MAAM,yBAAyB,CAAC;AACjG,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,kBAAkB,EAAqB,MAAM,aAAa,CAAC;AACxG,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AA6BnD,4GAA4G;AAC5G,MAAM,UAAU,oBAAoB,CAAC,GAAgB;IACnD,OAAO,aAAa,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,kBAAkB,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC;AACnF,CAAC;AAED,4GAA4G;AAC5G,MAAM,UAAU,kBAAkB,CAAC,SAAiC,EAAE,UAAyB;IAC7F,OAAO,iBAAiB,CAAC,SAAS,CAAC,MAAM,CAAC,oBAAoB,CAAC,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;AACvF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CACjC,GAAgB,EAChB,QAAsB,EACtB,UAAyB,EACzB,KAAwB;IAExB,IAAI,CAAC;QACH,gCAAgC,CAC9B,GAAG,EACH,EAAE,WAAW,EAAE,GAAG,CAAC,WAAW,EAAE,IAAI,EAAE,GAAG,GAAG,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,EAC7D;YACE,MAAM,EAAE,IAAI;YACZ,YAAY,EAAE,IAAI;YAClB,GAAG,CAAC,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC;YACrE,EAAE,EAAE,GAAG,CAAC,EAAE;YACV,QAAQ;YACR,UAAU;YACV,KAAK,EAAE,KAAK,CAAC,KAAK;SACnB,CACF,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,oBAAoB,EAAE,CAAC;YAC1C,OAAO,EAAE,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;QACtG,CAAC;QACD,IAAI,KAAK,YAAY,iBAAiB,IAAI,CAAC,CAAC,KAAK,YAAY,aAAa,CAAC;YAAE,OAAO,IAAI,CAAC;QACzF,MAAM,KAAK,CAAC;IACd,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAChC,SAAiC,EACjC,UAAyB,EACzB,KAAwB;IAExB,MAAM,QAAQ,GAAG,kBAAkB,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IAC3D,MAAM,KAAK,GAAkB,EAAE,CAAC;IAChC,KAAK,MAAM,GAAG,IAAI,SAAS,EAAE,CAAC;QAC5B,MAAM,OAAO,GAAG,mBAAmB,CAAC,GAAG,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;QACtE,IAAI,OAAO;YAAE,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IACD,OAAO,EAAE,WAAW,EAAE,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;AAC9D,CAAC"}

package/dist/bundle-health/legacy-page.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The retired `Page` kind name and `bridge` access-field spelling, for the `legacyNaming` section of
+ * the bundle health report. The runtime no longer recognizes either name: Page-typed documents do
+ * not register, and a bridge-only document resolves to `access: none`. Legacy folder locations
+ * remain valid.
+ *
+ * These literals cannot come from the live grammar in `page.ts`: diagnostics must recognize stock
+ * the runtime deliberately rejects, and a retired name must never track a live export. This module
+ * imports nothing; `legacy-constants-tripwire.test.ts` in the CLI pins its literals equal to
+ * core's legacy prefixes and to the recipe lifecycle's retired name by assertion.
+ */
+/** The retired legacy kind name, frozen as a historical fact. */
+export declare const LEGACY_PAGE_TYPE_NAME = "Page";
+/**
+ * True when this frontmatter declares the legacy kind name: `type` exactly `"Page"`, the same exact
+ * match core's grammar applies (`isPageTypeName`). No trimming: a value that reaches a consumer with
+ * surrounding whitespace was deliberately quoted and was never a registration.
+ */
+export declare function isLegacyPageDoc(frontmatter: Record<string, unknown>): boolean;
+/**
+ * True when a View-kind document (current `View` or legacy `Page` spelling) carries its own legacy
+ * `bridge` field. `bridge` is only the View kind's legacy capability spelling, so a document of any
+ * other type carrying it is ordinary data and is never flagged.
+ */
+export declare function hasLegacyBridgeField(frontmatter: Record<string, unknown>): boolean;
+/** True when this frontmatter is a Convention governing exactly the retired `Page` name. */
+export declare function isLegacyPageConvention(frontmatter: Record<string, unknown>): boolean;
+/** The legacy id prefixes, frozen as historical facts (they mirror the legacy locations core still accepts). */
+export declare const LEGACY_PAGE_REGISTRY_PREFIX = "pages-registry/";
+export declare const LEGACY_PAGE_BLOB_PREFIX = "pages/";
+/**
+ * Store-aware classifiers: a registry document is legacy only under `pages-registry/` in the
+ * document store, an entry only under `pages/` in the blob store. A concept document at `pages/x`
+ * is not a legacy item. A `true` here is reported as information, never acted on.
+ */
+export declare function isLegacyRegistryDocId(id: string): boolean;
+/** See {@link isLegacyRegistryDocId}: the blob-store half. */
+export declare function isLegacyEntryBlobKey(key: string): boolean;
+//# sourceMappingURL=legacy-page.d.ts.map

package/dist/bundle-health/legacy-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-page.d.ts","sourceRoot":"","sources":["../../src/bundle-health/legacy-page.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,iEAAiE;AACjE,eAAO,MAAM,qBAAqB,SAAS,CAAC;AAE5C;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAE7E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAGlF;AAED,4FAA4F;AAC5F,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAEpF;AAED,gHAAgH;AAChH,eAAO,MAAM,2BAA2B,oBAAoB,CAAC;AAC7D,eAAO,MAAM,uBAAuB,WAAW,CAAC;AAEhD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,8DAA8D;AAC9D,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEzD"}

package/dist/bundle-health/legacy-page.js

@@ -0,0 +1,50 @@
+/**
+ * The retired `Page` kind name and `bridge` access-field spelling, for the `legacyNaming` section of
+ * the bundle health report. The runtime no longer recognizes either name: Page-typed documents do
+ * not register, and a bridge-only document resolves to `access: none`. Legacy folder locations
+ * remain valid.
+ *
+ * These literals cannot come from the live grammar in `page.ts`: diagnostics must recognize stock
+ * the runtime deliberately rejects, and a retired name must never track a live export. This module
+ * imports nothing; `legacy-constants-tripwire.test.ts` in the CLI pins its literals equal to
+ * core's legacy prefixes and to the recipe lifecycle's retired name by assertion.
+ */
+/** The retired legacy kind name, frozen as a historical fact. */
+export const LEGACY_PAGE_TYPE_NAME = "Page";
+/**
+ * True when this frontmatter declares the legacy kind name: `type` exactly `"Page"`, the same exact
+ * match core's grammar applies (`isPageTypeName`). No trimming: a value that reaches a consumer with
+ * surrounding whitespace was deliberately quoted and was never a registration.
+ */
+export function isLegacyPageDoc(frontmatter) {
+    return frontmatter["type"] === LEGACY_PAGE_TYPE_NAME;
+}
+/**
+ * True when a View-kind document (current `View` or legacy `Page` spelling) carries its own legacy
+ * `bridge` field. `bridge` is only the View kind's legacy capability spelling, so a document of any
+ * other type carrying it is ordinary data and is never flagged.
+ */
+export function hasLegacyBridgeField(frontmatter) {
+    const viewKind = frontmatter["type"] === LEGACY_PAGE_TYPE_NAME || frontmatter["type"] === "View";
+    return viewKind && Object.hasOwn(frontmatter, "bridge");
+}
+/** True when this frontmatter is a Convention governing exactly the retired `Page` name. */
+export function isLegacyPageConvention(frontmatter) {
+    return frontmatter["type"] === "Convention" && frontmatter["governs"] === LEGACY_PAGE_TYPE_NAME;
+}
+/** The legacy id prefixes, frozen as historical facts (they mirror the legacy locations core still accepts). */
+export const LEGACY_PAGE_REGISTRY_PREFIX = "pages-registry/";
+export const LEGACY_PAGE_BLOB_PREFIX = "pages/";
+/**
+ * Store-aware classifiers: a registry document is legacy only under `pages-registry/` in the
+ * document store, an entry only under `pages/` in the blob store. A concept document at `pages/x`
+ * is not a legacy item. A `true` here is reported as information, never acted on.
+ */
+export function isLegacyRegistryDocId(id) {
+    return id.startsWith(LEGACY_PAGE_REGISTRY_PREFIX);
+}
+/** See {@link isLegacyRegistryDocId}: the blob-store half. */
+export function isLegacyEntryBlobKey(key) {
+    return key.startsWith(LEGACY_PAGE_BLOB_PREFIX);
+}
+//# sourceMappingURL=legacy-page.js.map

package/dist/bundle-health/legacy-page.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-page.js","sourceRoot":"","sources":["../../src/bundle-health/legacy-page.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,iEAAiE;AACjE,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAE5C;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,WAAoC;IAClE,OAAO,WAAW,CAAC,MAAM,CAAC,KAAK,qBAAqB,CAAC;AACvD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,WAAoC;IACvE,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,CAAC,KAAK,qBAAqB,IAAI,WAAW,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC;IACjG,OAAO,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;AAC1D,CAAC;AAED,4FAA4F;AAC5F,MAAM,UAAU,sBAAsB,CAAC,WAAoC;IACzE,OAAO,WAAW,CAAC,MAAM,CAAC,KAAK,YAAY,IAAI,WAAW,CAAC,SAAS,CAAC,KAAK,qBAAqB,CAAC;AAClG,CAAC;AAED,gHAAgH;AAChH,MAAM,CAAC,MAAM,2BAA2B,GAAG,iBAAiB,CAAC;AAC7D,MAAM,CAAC,MAAM,uBAAuB,GAAG,QAAQ,CAAC;AAEhD;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,EAAU;IAC9C,OAAO,EAAE,CAAC,UAAU,CAAC,2BAA2B,CAAC,CAAC;AACpD,CAAC;AAED,8DAA8D;AAC9D,MAAM,UAAU,oBAAoB,CAAC,GAAW;IAC9C,OAAO,GAAG,CAAC,UAAU,CAAC,uBAAuB,CAAC,CAAC;AACjD,CAAC"}

package/dist/bundle-health/report.d.ts

@@ -0,0 +1,202 @@
+import { type BundleBinding, type UnresolvedReason } from "../cross-bundle.js";
+import { type ParsedDependencies } from "../dependencies.js";
+import type { Bundle } from "../types.js";
+import type { ValidationWarning } from "../validation.js";
+import { type TrustTierCounts } from "../verification.js";
+/**
+ * Binds declared dependencies: called once, after every read has completed and `docs/dependencies`
+ * has been parsed, with that parse. Returns the bound copies by alias.
+ */
+export type BindDependencies = (declared: ParsedDependencies) => Promise<ReadonlyMap<string, BundleBinding>>;
+export interface BundleHealthOptions {
+    /** The instant freshness is judged at. Default: the current time, taken after the reads. */
+    now?: Date;
+    /**
+     * Bound copies of declared dependencies, by alias: a map, or a hook called exactly once, after
+     * every read has completed and `docs/dependencies` has been parsed, with that parse. Default: none,
+     * so nothing outside the bundle is read. Whatever the hook throws propagates unchanged.
+     */
+    bindings?: ReadonlyMap<string, BundleBinding> | BindDependencies;
+    /** This bundle's id when `docs/bundle` declares none. */
+    selfBundleId?: string;
+}
+/** A document whose frontmatter does not parse; the root index comes first when it is one. */
+export interface MalformedRow {
+    id: string;
+    reason: string;
+}
+/** One Kind violation of one document. */
+export interface KindLintRow {
+    id: string;
+    field: string;
+    code: string;
+}
+/** A document and its `type` ("" when absent or not a string). */
+export interface DocTypeRow {
+    id: string;
+    type: string;
+}
+export interface UnresolvedLinkRow {
+    from: string;
+    href: string;
+}
+/** A resolved local edge whose text is a declared link type its source or target does not conform to. */
+export interface LinkTypeViolationRow {
+    from: string;
+    to: string;
+    text: string;
+    expected: string;
+}
+/**
+ * A qualified link whose text is a declared type it does not conform to, or a local link under a
+ * qualified declaration (`links: {pours: "beers:Beer"}`).
+ */
+export interface CrossLinkTypeViolationRow {
+    from: string;
+    href: string;
+    text: string;
+    expected: string;
+}
+/**
+ * A Kind instance lacking a declared inbound expectation. `status` is present when the Kind declares
+ * a `status` field, and is the raw stored value (any YAML value, or undefined when unset).
+ */
+export interface MissingExpectedRow {
+    id: string;
+    status?: unknown;
+    missing: string[];
+}
+/** A stale document: past its `stale_after` instant (a string by construction), or older than its Kind's horizon. */
+export interface StaleRow {
+    id: string;
+    age_ms?: number;
+    horizon_ms?: number;
+    stale_after?: string;
+}
+/** An unreadable `stale_after`; `value` is the stored value made JSON-safe. */
+export interface ValueRow {
+    id: string;
+    type: string;
+    value: unknown;
+}
+/** An invalid timestamp field occurrence; `value` is the stored value made JSON-safe. */
+export interface FieldValueRow {
+    id: string;
+    type: string;
+    field: string;
+    value: unknown;
+}
+export interface DanglingEntryRow {
+    id: string;
+    entry: string;
+}
+/** A View-typed document failing the registration grammar; `problem` names the failing legs, joined by `+`. */
+export interface InvalidRegistrationRow {
+    id: string;
+    problem: string;
+}
+export interface ViewSurfaceHealth {
+    /** View-typed documents (legacy locations included). */
+    typed: number;
+    danglingEntries: DanglingEntryRow[];
+    invalidRegistrations: InvalidRegistrationRow[];
+}
+export interface CrossUnresolvedRow {
+    from: string;
+    href: string;
+    reason: UnresolvedReason;
+    detail: string;
+}
+export interface DependencyRow {
+    alias: string;
+    bundle_id: string;
+    /** `unbound` without a binding; otherwise the bound copy's verdict from core's resolver. */
+    state: "unbound" | "ok" | UnresolvedReason;
+    /** The binding's label, or null when the alias is unbound. */
+    bound: string | null;
+    pin: string | null;
+}
+/** A `docs/dependencies` defect (a `DEP_*` code). */
+export interface DependencyProblemRow {
+    code: string;
+    alias: string | null;
+    detail: string;
+}
+export interface CrossBundleHealth {
+    /** Every qualified (`okf:`) link, malformed ones included. */
+    links: number;
+    /** Qualified links whose declared alias has no binding. */
+    unchecked: number;
+    unresolved: CrossUnresolvedRow[];
+    dependencies: DependencyRow[];
+    problems: DependencyProblemRow[];
+}
+/** One Kind declaring a workflow `status` that collides with the OKF v0.2 lifecycle vocabulary. */
+export interface StatusFieldRow {
+    kind: string;
+    convention: string;
+    declaration: "unbounded" | "enumerated";
+    incompatible_values: string[];
+    observed_incompatible_values: string[];
+    affected_documents: number;
+}
+export interface OkfUpgradeFinding {
+    statusFieldRows: StatusFieldRow[];
+    affectedDocuments: number;
+}
+export interface LegacyNamingFindings {
+    pageTyped: {
+        id: string;
+    }[];
+    bridgeField: {
+        id: string;
+    }[];
+    pageConvention: {
+        id: string;
+    }[];
+    legacyPrefix: {
+        id: string;
+        store: "doc" | "blob";
+    }[];
+}
+export interface BundleHealthReport {
+    /** The root index's declared edition; undefined when absent or unreadable. */
+    okfVersion: string | undefined;
+    docs: number;
+    kinds: number;
+    malformed: MalformedRow[];
+    kindLint: KindLintRow[];
+    /** One row per governed document with a frontmatter-level violation; null when the bundle declares no Kind. */
+    conformanceDebt: DocTypeRow[] | null;
+    registryWarnings: ValidationWarning[];
+    unresolvedLinks: UnresolvedLinkRow[];
+    orphans: DocTypeRow[];
+    linkTypeViolations: LinkTypeViolationRow[];
+    /** Independent of `crossBundle`: a local edge under a qualified declaration needs no dependencies. */
+    crossLinkTypeViolations: CrossLinkTypeViolationRow[];
+    /** In triage order. */
+    missingExpectedLinks: MissingExpectedRow[];
+    /** Terminal instances skipped before the inbound-expectation lint evaluated them. */
+    terminalSkipped: number;
+    stale: StaleRow[];
+    noTimestamp: DocTypeRow[];
+    invalidStaleAfter: ValueRow[];
+    invalidTimestamps: FieldValueRow[];
+    invalidLegacyTimestamps: FieldValueRow[];
+    /** Null on v0.1, an undeclared edition, or an empty bundle. */
+    trust: TrustTierCounts | null;
+    views: ViewSurfaceHealth;
+    /** Null without `docs/dependencies` and without any `okf:` link. */
+    crossBundle: CrossBundleHealth | null;
+    /** Present only on a v0.1 bundle with a workflow-status collision. */
+    okfUpgrade: OkfUpgradeFinding | null;
+    legacyNaming: LegacyNamingFindings;
+}
+/**
+ * Compute the health report for `bundle`. Read-only: it reads through the bundle's backend and
+ * never writes. It throws only what it propagates: `InvalidInputError` for a backend-less bundle in
+ * a runtime with no default, backend errors other than `MalformedDocumentError` (a finding), and
+ * whatever the `bindings` hook throws.
+ */
+export declare function bundleHealth(bundle: Bundle, options?: BundleHealthOptions): Promise<BundleHealthReport>;
+//# sourceMappingURL=report.d.ts.map

package/dist/bundle-health/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../src/bundle-health/report.ts"],"names":[],"mappings":"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"}