@wildo-ai/saas-models 1.1.4 → 1.1.5

package/dist/esm/compliance/documents/governed-documents.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"governed-documents.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/compliance/documents/governed-documents.shared.schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"governed-documents.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/compliance/documents/governed-documents.shared.schemas.ts"],"names":[],"mappings":"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"}

package/dist/esm/compliance/documents/governed-documents.shared.schemas.js

@@ -1,4 +1,7 @@
 import { z } from "zod";
+// Side-effect import: this module calls `.systemEnum()` at load, so the decorators must be installed first —
+// never by the importer's luck (#966). A named import used only as a type would be elided and install nothing.
+import "@wildo-ai/zod-decorators";
 /**
  * What a GOVERNED DOCUMENT is: its classes, audiences, review and publication vocabulary, its
  * identities, its governance scope, its public content, and the release and publication events that
@@ -27,10 +30,12 @@ import { z } from "zod";
  *
  * ## What replaces it
  *
- * Nothing yet, deliberately. A governed document is a FILE in the application's specifications
- * package; publishing one is a decision recorded by a commit. When an application actually has a
- * document to serve, the serving is rebuilt from those files — a read, not a custody protocol. The
- * vocabulary below is what survives, and it is the half every other layer actually consumes.
+ * A read over committed files, not a custody protocol. A governed document is a FILE in the
+ * application's specifications package, and a release is a record the application commits — since
+ * 2026-09-12 carrying the text it publishes (`GovernedDocumentReleaseSchema.content`, #968), so the
+ * commit that introduced the record is what binds a release to its words. What a public page serves
+ * is `GovernedDocumentPublicDocument`: a release with its text, or the latest draft of a document
+ * never released, chosen by `resolveInForcePublicDocument`. No digest, no bundle, no receipt.
  */
 /** Exact media type of the canonical browser-safe governed-document JSON bytes. */
 export const GOVERNED_DOCUMENT_PUBLIC_CONTENT_MEDIA_TYPE = "application/vnd.wildo.governed-document.public+json;version=1";
@@ -139,6 +144,109 @@ export var GovernedDocumentInteractionKind;
     GovernedDocumentInteractionKind["CONSENT_GIVEN"] = "CONSENT_GIVEN";
     GovernedDocumentInteractionKind["CONSENT_WITHDRAWN"] = "CONSENT_WITHDRAWN";
 })(GovernedDocumentInteractionKind || (GovernedDocumentInteractionKind = {}));
+/** @wildo_source:part:start saas.models.governed-document-acceptance-mode facet:layer:shared facet:audience:app-developer */
+/**
+ * HOW an application asks a registrant to accept the documents it requires accepting — the three
+ * shapes courts actually distinguish, declared once per application (#1258).
+ *
+ * Declared on `compliance.governedDocumentAcceptanceMode` in the application's own
+ * `backend-api/src/saas-config.backend.ts`, beside `governedDocumentReleases` and `publicDocuments`.
+ *
+ * It is a RENDERING posture, not a server-side gate. The backend records whichever accepted release
+ * ids a registration carries and does not know which mode produced them, so a client that does not
+ * use the form is bound by none of the three. That is the honest scope: what the mode decides is how
+ * strong a notice a person is given and what the form withholds until they act — the things a
+ * registration screen can actually control.
+ *
+ * ## Why this is a declared CHOICE rather than one shipped behaviour
+ *
+ * Registration shipped with exactly one shape — an unticked box gating the submit button — and no
+ * way to ask for another. That is the strongest of the three and it is the right DEFAULT, but it is
+ * not the right answer for every application: a product whose terms are a one-paragraph acceptable-use
+ * statement and a product whose terms carry an arbitration clause are not asking the same thing of the
+ * same person, and the framework should let each say which it is asking.
+ *
+ * ## The enforceability ladder, which is what the members are ordered by
+ *
+ * Enforceability turns on whether the person had REASONABLE NOTICE of the terms and took an action
+ * MANIFESTING ASSENT to them. Clickwrap — an affirmative act aimed at the terms themselves — is the
+ * shape courts uphold most consistently; sign-in-wrap, where the act is the registration and the
+ * notice sits beside it, is upheld when the notice is conspicuous and fails when it is buried;
+ * browsewrap, where nothing but a footer link exists, is the shape that routinely fails. This
+ * vocabulary offers the first two and does NOT offer the third, because an application that asks for
+ * nothing is already representable by declaring no release that permits `CONTRACT_ACCEPTED`.
+ *
+ * (Drawn from the settled shape of US and EU practice on online contract formation, not from a single
+ * cited authority. Not legal advice — an operator's counsel decides which their terms warrant.)
+ *
+ * ## Every member DOES something, deliberately
+ *
+ * Each one changes what the registration form renders and what it refuses. A member that only named a
+ * posture without changing behaviour is the defect removed from this lane one commit earlier, when a
+ * stored privacy-level field was deleted for meaning nothing at any call site.
+ */
+export var GovernedDocumentAcceptanceMode;
+(function (GovernedDocumentAcceptanceMode) {
+    /**
+     * SIGN-IN-WRAP — "by registering you agree to our terms and privacy policy", beside the button.
+     *
+     * No checkbox and no separate act: submitting the registration IS the act of assent, so the
+     * accepted release ids still travel with it and the interaction is still recorded. What changes is
+     * that nothing is withheld — the button is available from the first keystroke.
+     *
+     * The notice is rendered immediately above the submit control rather than in a footer, because
+     * conspicuousness is the whole of what distinguishes this from the browsewrap shape that fails.
+     */
+    GovernedDocumentAcceptanceMode["IMPLIED_BY_REGISTERING"] = "IMPLIED_BY_REGISTERING";
+    /**
+     * CLICKWRAP — an unticked box the person ticks, with the submit control unavailable until they do.
+     *
+     * The DEFAULT, and the framework default may not silently weaken: an application that declared
+     * nothing shipped this behaviour before the vocabulary existed, and must keep shipping it.
+     *
+     * The box is never pre-ticked. A pre-ticked box is not an affirmative act, so it undermines the one
+     * property this mode exists to provide — the same reason the consent gate's own optional purposes
+     * start unticked.
+     */
+    GovernedDocumentAcceptanceMode["EXPLICIT_CHECKBOX"] = "EXPLICIT_CHECKBOX";
+    /**
+     * CLICKWRAP WITH A READING GATE — the document is shown, and the box cannot be ticked until the
+     * reader has scrolled to the end of it.
+     *
+     * The strongest available notice: the terms are not merely linked, they are placed in front of the
+     * person and the affirmative act is unavailable until they have passed over all of them.
+     *
+     * Two things it deliberately does NOT claim. It does not claim the person READ the document — no
+     * mechanism can — only that the text was presented in full and the act came after. And it does not
+     * replace the public document page: the pane shows the same content that page serves, and links to
+     * it, because the page is where the document is rendered with its own typography.
+     */
+    GovernedDocumentAcceptanceMode["EXPLICIT_AFTER_READING"] = "EXPLICIT_AFTER_READING";
+})(GovernedDocumentAcceptanceMode || (GovernedDocumentAcceptanceMode = {}));
+/**
+ * Does this mode require a SEPARATE affirmative act before the registration may be submitted?
+ *
+ * Two readers, one answer: the form disables its submit control on it, and the same form decides on
+ * it whether the accepted release ids travel with the request. Those had to agree — a submit the
+ * person could press without the ids being sent records nothing while reporting success — so the
+ * predicate is named once here rather than spelled twice at the two call sites.
+ *
+ * Written as "anything but implied" deliberately: a fourth mode added tomorrow is treated as needing
+ * the act until somebody says otherwise, which is the direction that fails safe. The inverse spelling
+ * ({@link GovernedDocumentAcceptanceMode.EXPLICIT_CHECKBOX} or `EXPLICIT_AFTER_READING`) would let a
+ * new member fall through to "registering is enough" silently.
+ */
+export const governedDocumentAcceptanceRequiresExplicitAct = (mode) => mode !== GovernedDocumentAcceptanceMode.IMPLIED_BY_REGISTERING;
+/**
+ * Must the document be placed in front of the reader, and the affirmative act withheld until they
+ * have passed over all of it?
+ *
+ * Named rather than compared inline for the same reason as its sibling, and spelled the other way
+ * round for the same fail-safe reason read in the other direction: a new mode does NOT acquire a
+ * reading gate nobody asked for.
+ */
+export const governedDocumentAcceptanceRequiresReading = (mode) => mode === GovernedDocumentAcceptanceMode.EXPLICIT_AFTER_READING;
+/** @wildo_source:part:end saas.models.governed-document-acceptance-mode */
 export var GovernedDocumentChangeAction;
 (function (GovernedDocumentChangeAction) {
     GovernedDocumentChangeAction["NO_PUBLIC_ACTION"] = "NO_PUBLIC_ACTION";
@@ -169,6 +277,34 @@ export const GovernedDocumentApprovalDecisionIdentitySchema = z.strictObject({
     decisionRef: GovernedDocumentRefSchema,
     decisionVersion: GovernedDocumentPositiveSafeIntegerSchema,
 });
+/**
+ * Whether a release has been APPROVED yet — and it is a MARK, never a gate on producing one.
+ *
+ * Wildo is agent-first: the mechanism composes the artifact and says what is true about it. Approval
+ * is a workflow act that happens at the END, so requiring it in order to compose a release would put
+ * a compliance workflow in front of the application-creation mechanism — which is the one thing that
+ * must never block. `approvalDecisions` was `.min(1)` until 2026-09-11, and that single constraint
+ * meant an unapproved release could not be REPRESENTED at all: an application either forged an
+ * approval identity or had no release, and the honest third answer did not exist.
+ *
+ * What replaces the refusal is this field. A release always exists and always states its own
+ * standing, so nothing downstream has to infer it and nothing can mistake a draft for a published
+ * document. Arming the gate that actually withholds an UNAPPROVED release from a real reader belongs
+ * to Gate 3 ("an application may face a real user"), per `one-source-of-truth.md` D5: critical gate
+ * points stay MARKED in every mechanism so they can be switched on when the posture changes.
+ */
+export var GovernedDocumentReleaseApprovalState;
+(function (GovernedDocumentReleaseApprovalState) {
+    /** At least one approval decision is retained. The release may be served as a published document. */
+    GovernedDocumentReleaseApprovalState["APPROVED"] = "APPROVED";
+    /**
+     * Composed, coherent, and NOT approved.
+     *
+     * A true record of a real draft — not a defect and not a placeholder. It is what an application
+     * holds between drafting and approval, which for most of its life is where it is.
+     */
+    GovernedDocumentReleaseApprovalState["UNAPPROVED"] = "UNAPPROVED";
+})(GovernedDocumentReleaseApprovalState || (GovernedDocumentReleaseApprovalState = {}));
 /**
  * Exact private materiality-decision identity retained when one release
  * replaces another. The full decision and authority evidence remain in
@@ -204,7 +340,8 @@ export const GovernedDocumentMaterialityAuthorityIdentitySchema = z.strictObject
  */
 export const GovernedDocumentGovernanceScopeSchema = z
     .strictObject({
-    subjectKind: z.enum(GovernedDocumentGovernanceSubjectKind),
+    // Declared so any surface wording this scope reads the one authored vocabulary (#966).
+    subjectKind: z.enum(GovernedDocumentGovernanceSubjectKind).systemEnum("GovernedDocumentGovernanceSubjectKind"),
     subjectRef: GovernedDocumentRefSchema,
     scopeRef: GovernedDocumentRefSchema,
     scopeVersion: GovernedDocumentPositiveSafeIntegerSchema,
@@ -231,22 +368,63 @@ export const GovernedDocumentGovernanceScopeSchema = z
     }
 });
 /**
- * Browser-safe public projection of approved semantic document content.
+ * Whether a published clause states something the application has ESTABLISHED — the one fact about a
+ * draft's completeness a READER is owed.
+ *
+ * It is the public projection of the candidate's `ComplianceStatementCompleteness`
+ * (`@wildo-ai/saas-specifications`): `DERIVED` becomes `ESTABLISHED`, and each of the three `NEEDS_*`
+ * members becomes `NOT_YET_ESTABLISHED`. Coarser ON PURPOSE, the way the public release projection
+ * withholds `governanceScope`: which party closes a gap (a framework change, an operator decision, an
+ * application configuration) and how (`closedBy` — issue refs, owners) is the publisher's custody.
+ * What a person reading the document is owed is that this statement is not yet established, and what
+ * is missing.
+ *
+ * Decided 2026-09-12 (wildo-ai/wildo-ai#968): an unestablished clause is MARKED on the page. Omitting it
+ * would narrow the document (#454 rejects that), and refusing the whole document would put a workflow
+ * fact in front of the page. Projecting it as plain text would state as settled what the drafter wrote
+ * down as unsettled.
+ */
+export var GovernedDocumentPublicClauseStanding;
+(function (GovernedDocumentPublicClauseStanding) {
+    GovernedDocumentPublicClauseStanding["ESTABLISHED"] = "ESTABLISHED";
+    GovernedDocumentPublicClauseStanding["NOT_YET_ESTABLISHED"] = "NOT_YET_ESTABLISHED";
+})(GovernedDocumentPublicClauseStanding || (GovernedDocumentPublicClauseStanding = {}));
+/**
+ * Browser-safe public projection of governed document content.
  *
  * Internal fact, authority, source-policy and review evidence stays in the
  * candidate/release records. Public routes render this exact projection as
  * text; `bodyMarkdown` is never trusted as raw HTML.
+ *
+ * Carried `clauseVersion` (and its section `sectionVersion`) until 2026-09-12 (#968). Nothing read
+ * either, no draft carries one, and a clause's revision history is the commits that changed it — so a
+ * required integer here could only be stamped, which would assert a history nothing tracks.
  */
-export const GovernedDocumentPublicClauseSchema = z.strictObject({
+export const GovernedDocumentPublicClauseSchema = z
+    .strictObject({
     clauseRef: GovernedDocumentRefSchema,
-    clauseVersion: GovernedDocumentPositiveSafeIntegerSchema,
     order: GovernedDocumentPositiveSafeIntegerSchema,
     bodyMarkdown: z.string().trim().min(1),
+    standing: z.enum(GovernedDocumentPublicClauseStanding),
+    /**
+     * What is missing, in the reader's terms — the drafter's own `needs` text. Present exactly when the
+     * clause is `NOT_YET_ESTABLISHED`: a marked clause that does not say what it lacks tells a reader
+     * nothing they can use, and an established clause carrying one would contradict itself.
+     */
+    missingInformation: z.string().trim().min(1).optional(),
+})
+    .superRefine((clause, context) => {
+    const marked = clause.standing === GovernedDocumentPublicClauseStanding.NOT_YET_ESTABLISHED;
+    if (marked && clause.missingInformation === undefined) {
+        context.addIssue({ code: "custom", message: "a clause that is not yet established must say what is missing", path: ["missingInformation"] });
+    }
+    if (!marked && clause.missingInformation !== undefined) {
+        context.addIssue({ code: "custom", message: "an established clause cannot carry missing information", path: ["missingInformation"] });
+    }
 });
 export const GovernedDocumentPublicSectionSchema = z
     .strictObject({
     sectionRef: GovernedDocumentRefSchema,
-    sectionVersion: GovernedDocumentPositiveSafeIntegerSchema,
     order: GovernedDocumentPositiveSafeIntegerSchema,
     title: z.string().trim().min(1),
     clauses: z.array(GovernedDocumentPublicClauseSchema).min(1),
@@ -308,18 +486,24 @@ export const GovernedDocumentReleaseCommonSchema = z
     locale: z.string().trim().min(2),
     jurisdictionRefs: z.array(GovernedDocumentRefSchema),
     /*
-     * The release names its content's MEDIA TYPE and nothing more.
+     * The content's MEDIA TYPE. The content itself is carried by `GovernedDocumentReleaseSchema.content`.
      *
      * It carried `candidateDigest`, `contentDigest` and `contentArtifactRef` until 2026-08-28 — a
      * seal binding the release to exact bytes in a content-addressed store. The store and the
-     * verifier are gone with the rest of the digest machinery; the binding a reader needs is the
-     * commit that introduced both the release and its content file.
+     * verifier are gone with the rest of the digest machinery and are not coming back: since
+     * 2026-09-12 (#968) the release holds its published text directly, and the commit that
+     * introduced the release record is what a reader audits.
      */
     contentMediaType: z.string().trim().min(1),
     issuedAt: GovernedDocumentIsoDateTimeSchema,
     effectiveAt: GovernedDocumentIsoDateTimeSchema,
     expiresAt: GovernedDocumentIsoDateTimeSchema.optional(),
-    approvalDecisions: z.array(GovernedDocumentApprovalDecisionIdentitySchema).min(1),
+    /**
+     * NOT `.min(1)`: see {@link GovernedDocumentReleaseApprovalState}. An unapproved release carries
+     * none, and says so in `approvalState` rather than being unrepresentable.
+     */
+    approvalDecisions: z.array(GovernedDocumentApprovalDecisionIdentitySchema),
+    approvalState: z.enum(GovernedDocumentReleaseApprovalState),
     replacesRelease: GovernedDocumentReleaseIdentitySchema.optional(),
     materialityDecision: GovernedDocumentMaterialityDecisionIdentitySchema.optional(),
 })
@@ -329,6 +513,17 @@ export const GovernedDocumentReleaseCommonSchema = z
     addUniqueSortedIssue(release.allowedInteractionKinds, context, ["allowedInteractionKinds"], "allowedInteractionKinds");
     addUniqueSortedIssue(release.jurisdictionRefs, context, ["jurisdictionRefs"], "jurisdictionRefs");
     addUniqueSortedIssue(release.approvalDecisions.map((decision) => `${decision.decisionRef}@${decision.decisionVersion}`), context, ["approvalDecisions"], "approvalDecisions");
+    /*
+     * The state and the evidence must agree. APPROVED with nothing retained would be a claim with no
+     * basis; UNAPPROVED while holding decisions would hide an approval that happened. Neither is a
+     * workflow gate — both are the record contradicting itself.
+     */
+    if (release.approvalState === GovernedDocumentReleaseApprovalState.APPROVED && release.approvalDecisions.length === 0) {
+        context.addIssue({ code: "custom", message: "an APPROVED release must retain at least one approval decision", path: ["approvalDecisions"] });
+    }
+    if (release.approvalState === GovernedDocumentReleaseApprovalState.UNAPPROVED && release.approvalDecisions.length > 0) {
+        context.addIssue({ code: "custom", message: "an UNAPPROVED release must retain no approval decision", path: ["approvalDecisions"] });
+    }
     if (Date.parse(release.effectiveAt) < Date.parse(release.issuedAt)) {
         context.addIssue({ code: "custom", message: "effectiveAt cannot precede issuedAt", path: ["effectiveAt"] });
     }
@@ -368,10 +563,104 @@ export const GovernedDocumentReleaseCommonSchema = z
         });
     }
 });
-/** Immutable historical/public issued release. Its content branch remains byte-exact v1. */
+/**
+ * An issued release — and, since 2026-09-12, the TEXT it publishes (wildo-ai/wildo-ai#968).
+ *
+ * ## Why the release carries its content
+ *
+ * A release says which drafted content takes effect, and until #968 it could not say WHICH text: the
+ * sealed content binding went with the digest machinery on 2026-08-28, leaving only "the commit that
+ * introduced both the release and its content file". But a draft keeps changing after it is released,
+ * so pairing a release with "the draft of the same document" at read time shows every release — the
+ * one in force, the one it superseded, the one scheduled next — the SAME, current text. Two releases
+ * of one document could not differ at all.
+ *
+ * So the release holds its own published text, captured when it is composed. Retrieving "release N of
+ * a document" is one read. Intermediate drafts are NOT kept here — their history is the commits that
+ * changed the draft — and neither is anything the public projection withholds: `content` is already
+ * the browser-safe shape (no fact refs, no source policies, no `closedBy`).
+ *
+ * ## The text is only frozen if the RECORD is
+ *
+ * This field makes the binding representable; committing the record as data is what keeps it. An
+ * application that recomposes its releases from the live draft on every import would carry today's
+ * draft in every release, which is the defect above one layer later.
+ *
+ * ## What it refuses
+ *
+ * Content in a language or for jurisdictions the release does not name: publishing `fr-FR` text under
+ * an `en-GB` release is a false legal statement, the same lie `GovernedDocumentPublicDocumentSchema`
+ * refuses.
+ */
 export const GovernedDocumentReleaseSchema = GovernedDocumentReleaseCommonSchema.safeExtend({
     schemaVersion: z.literal(1),
+    content: GovernedDocumentPublicContentSchema,
+    /*
+     * Pinned, because it now names the shape of `content` rather than an external rendering: a release
+     * whose text is the structured public JSON and whose media type said `text/html` would contradict
+     * itself, and the public projection already accepts nothing else.
+     */
+    contentMediaType: z.literal(GOVERNED_DOCUMENT_PUBLIC_CONTENT_MEDIA_TYPE),
+}).superRefine((release, context) => {
+    if (release.content.locale !== release.locale) {
+        context.addIssue({ code: "custom", message: "release content locale must match the release", path: ["content", "locale"] });
+    }
+    if (release.content.jurisdictionRefs.join("\u0000") !== release.jurisdictionRefs.join("\u0000")) {
+        context.addIssue({ code: "custom", message: "release content jurisdictions must match the release", path: ["content", "jurisdictionRefs"] });
+    }
 });
+/**
+ * The governed documents an application SERVES as public pages, named once for every layer.
+ *
+ * These two live HERE, in the shared wire layer, and not with their four governance siblings in
+ * `saas-specifications/_core/compliance-documents` — because these are the only two a BROWSER has
+ * to name. `AppRouter` mounts `/privacy` and `/terms` and must say which document each serves, and
+ * `saas-frontend-lib` neither depends on `saas-specifications` nor should: that is the design-time
+ * layer. The alternative was a second copy of two strings in the router, which is exactly the
+ * closed-vocabulary-with-no-named-source shape `CLAUDE.md` refuses.
+ *
+ * `required-document-set.schemas.ts` imports them rather than re-declaring them, so the composer
+ * and the page agree about which document they are talking about by construction.
+ */
+export const PUBLIC_GOVERNED_DOCUMENT_REFS = Object.freeze({
+    PRIVACY_NOTICE: "document:public.privacy-notice",
+    SERVICE_TERMS: "document:public.service-terms",
+});
+/**
+ * Which public page serves which governed document — the pairing every surface that links to one needs.
+ *
+ * TOTAL over {@link PUBLIC_GOVERNED_DOCUMENT_REFS} by its type, so a third public document added to
+ * that vocabulary is a compile error here rather than a document with no page. A hand-kept list of
+ * pairings is the thing that rots; a total over the vocabulary is the thing that cannot.
+ *
+ * ## Why the PATH lives here and not with the frontend's other routes
+ *
+ * The same reason the refs beside it do, and it took a SECOND reader to make it obvious. `AppRouter`
+ * MOUNTS these paths; the consent panel LINKS to the privacy notice from `presets-components`, and
+ * the registration form links to each required document from `saas-frontend-lib`. Only the router can
+ * reach that package's internal route module, so the panel would have hard-coded a copy — the
+ * closed-vocabulary-with-no-named-source shape `CLAUDE.md` refuses, and a copy nothing renders is the
+ * one that drifts. `CommonRoutePaths.privacy` / `.terms` are derived from this, so the router still
+ * spells its routes in one place and that place agrees with the links.
+ *
+ * A MARKETING WEBSITE is deliberately NOT one of the readers, although an earlier version of this
+ * note claimed it was. `saas-website` may import only `@wildo-ai/saas-models/public-runtime` under
+ * bundle discipline, and this is not exported there — so the claim named a reader that could not
+ * reach it. If a website ever needs these paths, carve them into `public-runtime` through the K-2
+ * protocol rather than restoring the sentence.
+ */
+export const PUBLIC_GOVERNED_DOCUMENT_ROUTE_PATHS = Object.freeze({
+    [PUBLIC_GOVERNED_DOCUMENT_REFS.PRIVACY_NOTICE]: "/privacy",
+    [PUBLIC_GOVERNED_DOCUMENT_REFS.SERVICE_TERMS]: "/terms",
+});
+/**
+ * The page serving this document, or `undefined` when it has none.
+ *
+ * A governed document an application requires acceptance of need NOT be one of the two public pages
+ * — an application may require a data-processing agreement served elsewhere entirely — so a caller
+ * gets `undefined` and omits the link rather than being handed a route that leads nowhere.
+ */
+export const resolvePublicGovernedDocumentRoutePath = (documentRef) => PUBLIC_GOVERNED_DOCUMENT_ROUTE_PATHS[documentRef];
 /** Locator kind is explicit so a channel cannot reinterpret an arbitrary string. */
 export var GovernedDocumentPublicationLocatorKind;
 (function (GovernedDocumentPublicationLocatorKind) {
@@ -453,6 +742,14 @@ export const GovernedDocumentPublicReleaseProjectionSchema = z
     issuedAt: GovernedDocumentIsoDateTimeSchema,
     effectiveAt: GovernedDocumentIsoDateTimeSchema,
     expiresAt: GovernedDocumentIsoDateTimeSchema.optional(),
+    /**
+     * What a person may DO with this release — carried onto the public projection so the serving
+     * surface can tell whether recording a `NOTICE_DELIVERED` (#1258 Step 5) is something the
+     * release actually permits, without a second, wider read of the release's own custody record.
+     * Not new authority: `composeGovernedDocumentInteraction` already refuses an interaction kind a
+     * release does not permit, so a reader without this field could only guess.
+     */
+    allowedInteractionKinds: z.array(z.enum(GovernedDocumentInteractionKind)),
 })
     .superRefine((release, context) => {
     addUniqueSortedIssue(release.jurisdictionRefs, context, ["jurisdictionRefs"], "jurisdictionRefs");
@@ -477,6 +774,97 @@ export const projectGovernedDocumentPublicRelease = (releaseInput) => {
         issuedAt: release.issuedAt,
         effectiveAt: release.effectiveAt,
         ...(release.expiresAt ? { expiresAt: release.expiresAt } : {}),
+        allowedInteractionKinds: release.allowedInteractionKinds,
     });
 };
+/**
+ * A governed document AS A PUBLIC PAGE CAN HOLD IT — the release metadata a reader is entitled to,
+ * paired with the exact content bytes it names. Issue #168.
+ *
+ * ## Why this pair, and why it is one record
+ *
+ * The two halves already existed and had never been joined. `GovernedDocumentPublicReleaseProjection`
+ * answers *which release is this, in what language, for which jurisdictions, in force when* —
+ * deliberately narrower than the internal release, withholding `governanceScope` and
+ * `approvalDecisions` as custody detail. `GovernedDocumentPublicContent` answers *what does it say*.
+ * A page needs both and must not be able to show one release's date above another release's prose,
+ * so they travel together and their agreement is checked here rather than at each reader.
+ *
+ * ## What the guard refuses, and what it deliberately does not
+ *
+ * It refuses a record that would be a LIE: content whose `locale` or `jurisdictionRefs` disagree
+ * with the release naming it, and a media type the release does not declare. Serving an `en-GB`
+ * notice under a release that says `fr-FR` is a false legal statement, and that is the one thing a
+ * public document may never be.
+ *
+ * It does NOT refuse an UNAPPROVED release, and that is the directive'''s own instruction rather than
+ * an oversight: *"Composing a release harms nobody; serving an unapproved one to a real reader is a
+ * legally-binding statement leaving the system. So the filter lives on the READ, defaults to off,
+ * and says at its own site that it is the gate point."* The approval gate is
+ * {@link resolveInForcePublicDocument}'''s `requireApproved`, MARKED there and armed at Gate 3.
+ * Refusing here would make an application unable to REPRESENT a draft notice at all, which is the
+ * shape `.claude/rules/application-creation-directive.md` records as the reference defect.
+ *
+ * The release'''s own `approvalState` is not carried, because this projection deliberately withholds
+ * it (a reader is not told about internal custody). The approval decision is made where the document
+ * is SELECTED, from the authored release, before it reaches a browser.
+ */
+export var GovernedDocumentPublicDocumentKind;
+(function (GovernedDocumentPublicDocumentKind) {
+    /** A composed release and the text that release carries. */
+    GovernedDocumentPublicDocumentKind["RELEASED"] = "RELEASED";
+    /**
+     * The latest draft of a document the application has NEVER released (wildo-ai/wildo-ai#968 decision 5).
+     *
+     * It exists so that neither a missing approval nor a missing release leaves a page with nothing. It
+     * carries no release projection and no approval state because neither exists — inventing either
+     * would claim a release nobody composed — and a page showing one must SAY it is a draft.
+     */
+    GovernedDocumentPublicDocumentKind["UNRELEASED_DRAFT"] = "UNRELEASED_DRAFT";
+})(GovernedDocumentPublicDocumentKind || (GovernedDocumentPublicDocumentKind = {}));
+export const GovernedDocumentReleasedPublicDocumentSchema = z
+    .strictObject({
+    schemaVersion: z.literal(1),
+    kind: z.literal(GovernedDocumentPublicDocumentKind.RELEASED),
+    release: GovernedDocumentPublicReleaseProjectionSchema,
+    content: GovernedDocumentPublicContentSchema,
+    /**
+     * Whether the release this content belongs to has been approved.
+     *
+     * Carried HERE rather than on the release projection because it is a fact about the PUBLISHER'''s
+     * process, not about the document, and the projection is the shape a reader receives. A serving
+     * surface needs it to decide whether it may render at all; it is never displayed.
+     */
+    approvalState: z.enum(GovernedDocumentReleaseApprovalState),
+})
+    .superRefine((document, context) => {
+    if (document.content.locale !== document.release.locale) {
+        context.addIssue({
+            code: "custom",
+            message: "public content locale must match the release that names it",
+            path: ["content", "locale"],
+        });
+    }
+    const releaseJurisdictions = document.release.jurisdictionRefs.join("\u0000");
+    if (document.content.jurisdictionRefs.join("\u0000") !== releaseJurisdictions) {
+        context.addIssue({
+            code: "custom",
+            message: "public content jurisdictions must match the release that names it",
+            path: ["content", "jurisdictionRefs"],
+        });
+    }
+});
+/** See {@link GovernedDocumentPublicDocumentKind.UNRELEASED_DRAFT}. */
+export const GovernedDocumentUnreleasedDraftPublicDocumentSchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    kind: z.literal(GovernedDocumentPublicDocumentKind.UNRELEASED_DRAFT),
+    /** The governed document this is the latest draft of. */
+    documentRef: GovernedDocumentRefSchema,
+    content: GovernedDocumentPublicContentSchema,
+});
+/** A document a public page may render: a composed release, or the latest draft of a never-released document. */
+export const GovernedDocumentPublicDocumentSchema = z.discriminatedUnion("kind", [
+    GovernedDocumentReleasedPublicDocumentSchema,
+    GovernedDocumentUnreleasedDraftPublicDocumentSchema,
+]);
 //# sourceMappingURL=governed-documents.shared.schemas.js.map