@authorbot/schemas 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joe Mattie
+
+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/dist/annotation.d.ts

@@ -0,0 +1,172 @@
+import { z } from "zod";
+/** Annotation lifecycle states (contract section 4, design section 9.4). */
+export declare const ANNOTATION_STATUSES: readonly ["open", "work_item_created", "accepted", "resolved", "rejected", "withdrawn", "superseded", "orphaned", "needs_reanchor"];
+export declare const annotationStatusSchema: z.ZodEnum<{
+    open: "open";
+    work_item_created: "work_item_created";
+    accepted: "accepted";
+    resolved: "resolved";
+    rejected: "rejected";
+    withdrawn: "withdrawn";
+    superseded: "superseded";
+    orphaned: "orphaned";
+    needs_reanchor: "needs_reanchor";
+}>;
+export type AnnotationStatus = z.infer<typeof annotationStatusSchema>;
+export declare const ANNOTATION_KINDS: readonly ["comment", "suggestion"];
+export declare const annotationKindSchema: z.ZodEnum<{
+    comment: "comment";
+    suggestion: "suggestion";
+}>;
+export type AnnotationKind = z.infer<typeof annotationKindSchema>;
+/**
+ * Range target selector (design section 10.1). Selector field names are
+ * camelCase exactly as in the design payload: `blockId`, `textPosition`,
+ * `textQuote`. Positions are offsets into the normalized plain-text stream of
+ * the block, not raw HTML offsets.
+ */
+export declare const textPositionSchema: z.ZodObject<{
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+}, z.core.$strict>;
+export type TextPosition = z.infer<typeof textPositionSchema>;
+/** Contract 2b §2.2: quote context is at most 32 characters each side. */
+export declare const MAX_QUOTE_CONTEXT = 32;
+/**
+ * Server-side ceiling for `textQuote.exact` (a selection within a single
+ * semantic block, so far below the 32 KiB body limit). Enforced here so an
+ * attacker-chosen selector can never smuggle megabytes into the annotations
+ * row and the committed `.authorbot/annotations/<id>/annotation.md` artifact.
+ */
+export declare const MAX_QUOTE_EXACT: number;
+export declare const textQuoteSchema: z.ZodObject<{
+    exact: z.ZodString;
+    prefix: z.ZodOptional<z.ZodString>;
+    suffix: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TextQuote = z.infer<typeof textQuoteSchema>;
+export declare const rangeTargetSchema: z.ZodObject<{
+    blockId: z.ZodString;
+    textPosition: z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strict>;
+    textQuote: z.ZodObject<{
+        exact: z.ZodString;
+        prefix: z.ZodOptional<z.ZodString>;
+        suffix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RangeTarget = z.infer<typeof rangeTargetSchema>;
+export declare const blockTargetSchema: z.ZodObject<{
+    blockId: z.ZodString;
+}, z.core.$strict>;
+export type BlockTarget = z.infer<typeof blockTargetSchema>;
+/**
+ * Annotation frontmatter `.authorbot/annotations/<id>/annotation.md` —
+ * `authorbot.annotation/v1` (contract section 4). `target` is required for
+ * `range` and `block` scopes and forbidden for `chapter` scope.
+ */
+export declare const annotationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    scope: z.ZodLiteral<"range">;
+    target: z.ZodObject<{
+        blockId: z.ZodString;
+        textPosition: z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+        }, z.core.$strict>;
+        textQuote: z.ZodObject<{
+            exact: z.ZodString;
+            prefix: z.ZodOptional<z.ZodString>;
+            suffix: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    schema: z.ZodLiteral<"authorbot.annotation/v1">;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        comment: "comment";
+        suggestion: "suggestion";
+    }>;
+    chapter_id: z.ZodString;
+    chapter_revision: z.ZodNumber;
+    author: z.ZodString;
+    status: z.ZodEnum<{
+        open: "open";
+        work_item_created: "work_item_created";
+        accepted: "accepted";
+        resolved: "resolved";
+        rejected: "rejected";
+        withdrawn: "withdrawn";
+        superseded: "superseded";
+        orphaned: "orphaned";
+        needs_reanchor: "needs_reanchor";
+    }>;
+    created_at: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    scope: z.ZodLiteral<"block">;
+    target: z.ZodObject<{
+        blockId: z.ZodString;
+    }, z.core.$strict>;
+    schema: z.ZodLiteral<"authorbot.annotation/v1">;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        comment: "comment";
+        suggestion: "suggestion";
+    }>;
+    chapter_id: z.ZodString;
+    chapter_revision: z.ZodNumber;
+    author: z.ZodString;
+    status: z.ZodEnum<{
+        open: "open";
+        work_item_created: "work_item_created";
+        accepted: "accepted";
+        resolved: "resolved";
+        rejected: "rejected";
+        withdrawn: "withdrawn";
+        superseded: "superseded";
+        orphaned: "orphaned";
+        needs_reanchor: "needs_reanchor";
+    }>;
+    created_at: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    scope: z.ZodLiteral<"chapter">;
+    schema: z.ZodLiteral<"authorbot.annotation/v1">;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        comment: "comment";
+        suggestion: "suggestion";
+    }>;
+    chapter_id: z.ZodString;
+    chapter_revision: z.ZodNumber;
+    author: z.ZodString;
+    status: z.ZodEnum<{
+        open: "open";
+        work_item_created: "work_item_created";
+        accepted: "accepted";
+        resolved: "resolved";
+        rejected: "rejected";
+        withdrawn: "withdrawn";
+        superseded: "superseded";
+        orphaned: "orphaned";
+        needs_reanchor: "needs_reanchor";
+    }>;
+    created_at: z.ZodString;
+}, z.core.$strict>], "scope">;
+export type Annotation = z.infer<typeof annotationSchema>;
+/**
+ * Reply frontmatter `.authorbot/annotations/<id>/replies/<reply-id>.md` —
+ * `authorbot.reply/v1`. The contract pins only the schema ID; fields follow
+ * the Reply entity of design section 9.1 (ID, annotation ID, optional parent
+ * reply, author, timestamps). The reply body is the Markdown content itself.
+ */
+export declare const replySchema: z.ZodObject<{
+    schema: z.ZodLiteral<"authorbot.reply/v1">;
+    id: z.ZodString;
+    annotation_id: z.ZodString;
+    parent_reply_id: z.ZodOptional<z.ZodString>;
+    author: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type Reply = z.infer<typeof replySchema>;
+//# sourceMappingURL=annotation.d.ts.map

package/dist/annotation.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { actorRefSchema, timestampSchema, uuidv7Schema } from "./primitives.js";
+/** Annotation lifecycle states (contract section 4, design section 9.4). */
+export const ANNOTATION_STATUSES = [
+    "open",
+    "work_item_created",
+    "accepted",
+    "resolved",
+    "rejected",
+    "withdrawn",
+    "superseded",
+    "orphaned",
+    "needs_reanchor",
+];
+export const annotationStatusSchema = z.enum(ANNOTATION_STATUSES);
+export const ANNOTATION_KINDS = ["comment", "suggestion"];
+export const annotationKindSchema = z.enum(ANNOTATION_KINDS);
+/**
+ * Range target selector (design section 10.1). Selector field names are
+ * camelCase exactly as in the design payload: `blockId`, `textPosition`,
+ * `textQuote`. Positions are offsets into the normalized plain-text stream of
+ * the block, not raw HTML offsets.
+ */
+export const textPositionSchema = z.strictObject({
+    start: z.number().int().min(0),
+    end: z.number().int().min(0),
+});
+/** Contract 2b §2.2: quote context is at most 32 characters each side. */
+export const MAX_QUOTE_CONTEXT = 32;
+/**
+ * Server-side ceiling for `textQuote.exact` (a selection within a single
+ * semantic block, so far below the 32 KiB body limit). Enforced here so an
+ * attacker-chosen selector can never smuggle megabytes into the annotations
+ * row and the committed `.authorbot/annotations/<id>/annotation.md` artifact.
+ */
+export const MAX_QUOTE_EXACT = 8 * 1024;
+export const textQuoteSchema = z.strictObject({
+    exact: z.string().min(1).max(MAX_QUOTE_EXACT),
+    prefix: z.string().max(MAX_QUOTE_CONTEXT).optional(),
+    suffix: z.string().max(MAX_QUOTE_CONTEXT).optional(),
+});
+export const rangeTargetSchema = z.strictObject({
+    blockId: uuidv7Schema,
+    textPosition: textPositionSchema,
+    textQuote: textQuoteSchema,
+});
+export const blockTargetSchema = z.strictObject({
+    blockId: uuidv7Schema,
+});
+const annotationBaseFields = {
+    schema: z.literal("authorbot.annotation/v1"),
+    id: uuidv7Schema,
+    kind: annotationKindSchema,
+    chapter_id: uuidv7Schema,
+    chapter_revision: z.number().int().min(1),
+    author: actorRefSchema,
+    status: annotationStatusSchema,
+    created_at: timestampSchema,
+};
+/**
+ * Annotation frontmatter `.authorbot/annotations/<id>/annotation.md` —
+ * `authorbot.annotation/v1` (contract section 4). `target` is required for
+ * `range` and `block` scopes and forbidden for `chapter` scope.
+ */
+export const annotationSchema = z.discriminatedUnion("scope", [
+    z.strictObject({
+        ...annotationBaseFields,
+        scope: z.literal("range"),
+        target: rangeTargetSchema,
+    }),
+    z.strictObject({
+        ...annotationBaseFields,
+        scope: z.literal("block"),
+        target: blockTargetSchema,
+    }),
+    z.strictObject({
+        ...annotationBaseFields,
+        scope: z.literal("chapter"),
+    }),
+]);
+/**
+ * Reply frontmatter `.authorbot/annotations/<id>/replies/<reply-id>.md` —
+ * `authorbot.reply/v1`. The contract pins only the schema ID; fields follow
+ * the Reply entity of design section 9.1 (ID, annotation ID, optional parent
+ * reply, author, timestamps). The reply body is the Markdown content itself.
+ */
+export const replySchema = z.strictObject({
+    schema: z.literal("authorbot.reply/v1"),
+    id: uuidv7Schema,
+    annotation_id: uuidv7Schema,
+    parent_reply_id: uuidv7Schema.optional(),
+    author: actorRefSchema,
+    created_at: timestampSchema,
+    updated_at: timestampSchema.optional(),
+});
+//# sourceMappingURL=annotation.js.map

package/dist/attribution.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const attributionEntrySchema: z.ZodObject<{
+    revision: z.ZodNumber;
+    actor: z.ZodString;
+    work_item_id: z.ZodOptional<z.ZodString>;
+    commit: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AttributionEntry = z.infer<typeof attributionEntrySchema>;
+/**
+ * Attribution record `.authorbot/attribution/<chapter-id>.yml` —
+ * `authorbot.attribution/v1` (contract section 4). At least one entry: the
+ * file only exists once a chapter revision has an author to attribute.
+ */
+export declare const attributionSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"authorbot.attribution/v1">;
+    chapter_id: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        revision: z.ZodNumber;
+        actor: z.ZodString;
+        work_item_id: z.ZodOptional<z.ZodString>;
+        commit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Attribution = z.infer<typeof attributionSchema>;
+//# sourceMappingURL=attribution.d.ts.map

package/dist/attribution.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { actorRefSchema, commitShaSchema, uuidv7Schema } from "./primitives.js";
+export const attributionEntrySchema = z.strictObject({
+    revision: z.number().int().min(1),
+    actor: actorRefSchema,
+    work_item_id: uuidv7Schema.optional(),
+    commit: commitShaSchema.optional(),
+});
+/**
+ * Attribution record `.authorbot/attribution/<chapter-id>.yml` —
+ * `authorbot.attribution/v1` (contract section 4). At least one entry: the
+ * file only exists once a chapter revision has an author to attribute.
+ */
+export const attributionSchema = z.strictObject({
+    schema: z.literal("authorbot.attribution/v1"),
+    chapter_id: uuidv7Schema,
+    entries: z.array(attributionEntrySchema).min(1),
+});
+//# sourceMappingURL=attribution.js.map

package/dist/book.d.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+/**
+ * The four annotation policy modes (Phase 7 contract "Restricting"). Declared
+ * here rather than imported from `@authorbot/domain` because `@authorbot/schemas`
+ * is the leaf package every other one depends on and must not gain a dependency
+ * on the domain rules; `annotation-policy.test.ts` in the domain suite pins the
+ * two lists equal.
+ */
+export declare const ANNOTATION_POLICY_MODES: readonly ["open", "approval-gated", "collaborators-only", "locked"];
+export declare const annotationPolicySchema: z.ZodEnum<{
+    open: "open";
+    "approval-gated": "approval-gated";
+    "collaborators-only": "collaborators-only";
+    locked: "locked";
+}>;
+export type AnnotationPolicyMode = (typeof ANNOTATION_POLICY_MODES)[number];
+/**
+ * Book config `book.yml` — `authorbot.book/v1` (design section 8.2).
+ * Optional sections default at load time; the schema does not inject defaults.
+ */
+export declare const bookConfigSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"authorbot.book/v1">;
+    id: z.ZodString;
+    title: z.ZodString;
+    slug: z.ZodString;
+    language: z.ZodString;
+    license: z.ZodOptional<z.ZodString>;
+    repository: z.ZodOptional<z.ZodObject<{
+        default_branch: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    content: z.ZodOptional<z.ZodObject<{
+        chapters_glob: z.ZodOptional<z.ZodString>;
+        raw_html: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    planning: z.ZodOptional<z.ZodObject<{
+        method: z.ZodOptional<z.ZodString>;
+        outline: z.ZodOptional<z.ZodString>;
+        timeline: z.ZodOptional<z.ZodString>;
+        characters_glob: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    publication: z.ZodOptional<z.ZodObject<{
+        chapter_url: z.ZodOptional<z.ZodString>;
+        api_url: z.ZodOptional<z.ZodString>;
+        show_revision: z.ZodOptional<z.ZodBoolean>;
+        show_attribution: z.ZodOptional<z.ZodBoolean>;
+        show_public_annotations: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    collaboration: z.ZodOptional<z.ZodObject<{
+        annotation_policy: z.ZodOptional<z.ZodEnum<{
+            open: "open";
+            "approval-gated": "approval-gated";
+            "collaborators-only": "collaborators-only";
+            locked: "locked";
+        }>>;
+    }, z.core.$strict>>;
+    governance: z.ZodOptional<z.ZodObject<{
+        rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            version: z.ZodNumber;
+            trigger: z.ZodOptional<z.ZodEnum<{
+                vote_changed: "vote_changed";
+            }>>;
+            when: z.ZodUnion<readonly [z.ZodObject<{
+                all: z.ZodArray<z.ZodObject<{
+                    metric: z.ZodString;
+                    operator: z.ZodEnum<{
+                        gte: "gte";
+                        gt: "gt";
+                        lte: "lte";
+                        lt: "lt";
+                        eq: "eq";
+                        neq: "neq";
+                    }>;
+                    value: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                any: z.ZodArray<z.ZodObject<{
+                    metric: z.ZodString;
+                    operator: z.ZodEnum<{
+                        gte: "gte";
+                        gt: "gt";
+                        lte: "lte";
+                        lt: "lt";
+                        eq: "eq";
+                        neq: "neq";
+                    }>;
+                    value: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>]>;
+            action: z.ZodObject<{
+                type: z.ZodLiteral<"create_work_item">;
+                work_type: z.ZodEnum<{
+                    revise_range: "revise_range";
+                    revise_block: "revise_block";
+                    revise_chapter: "revise_chapter";
+                    write_chapter: "write_chapter";
+                    resolve_conflict: "resolve_conflict";
+                    planning: "planning";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type BookConfig = z.infer<typeof bookConfigSchema>;
+//# sourceMappingURL=book.d.ts.map

package/dist/book.js

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { rulesMapSchema } from "./instance.js";
+import { slugSchema, uuidv7Schema } from "./primitives.js";
+/**
+ * The four annotation policy modes (Phase 7 contract "Restricting"). Declared
+ * here rather than imported from `@authorbot/domain` because `@authorbot/schemas`
+ * is the leaf package every other one depends on and must not gain a dependency
+ * on the domain rules; `annotation-policy.test.ts` in the domain suite pins the
+ * two lists equal.
+ */
+export const ANNOTATION_POLICY_MODES = [
+    "open",
+    "approval-gated",
+    "collaborators-only",
+    "locked",
+];
+export const annotationPolicySchema = z.enum(ANNOTATION_POLICY_MODES);
+/**
+ * Book config `book.yml` — `authorbot.book/v1` (design section 8.2).
+ * Optional sections default at load time; the schema does not inject defaults.
+ */
+export const bookConfigSchema = z.strictObject({
+    schema: z.literal("authorbot.book/v1"),
+    id: uuidv7Schema,
+    title: z.string().min(1),
+    slug: slugSchema,
+    /** BCP 47-style language tag, e.g. `en` or `en-US`. */
+    language: z
+        .string()
+        .regex(/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{1,8})*$/, "must be a language tag like en-US"),
+    license: z.string().min(1).optional(),
+    repository: z
+        .strictObject({
+        default_branch: z.string().min(1).optional(),
+    })
+        .optional(),
+    content: z
+        .strictObject({
+        chapters_glob: z.string().min(1).optional(),
+        raw_html: z.boolean().optional(),
+    })
+        .optional(),
+    planning: z
+        .strictObject({
+        /** Method-neutral label (design section 1.2), e.g. `custom`, `snowflake`. */
+        method: z.string().min(1).optional(),
+        outline: z.string().min(1).optional(),
+        timeline: z.string().min(1).optional(),
+        characters_glob: z.string().min(1).optional(),
+    })
+        .optional(),
+    publication: z
+        .strictObject({
+        chapter_url: z.string().min(1).optional(),
+        /**
+         * Collaboration API base URL (Phase 2b contract §1); enables the
+         * annotation islands at build time. `authorbot build --api-url`
+         * overrides.
+         */
+        api_url: z.string().min(1).optional(),
+        show_revision: z.boolean().optional(),
+        show_attribution: z.boolean().optional(),
+        show_public_annotations: z.boolean().optional(),
+    })
+        .optional(),
+    /**
+     * Collaboration access (Phase 7 contract "Restricting").
+     *
+     * `annotation_policy` is who may comment and suggest, and whether what they
+     * write appears immediately: `open`, `approval-gated`, `collaborators-only`
+     * (the default when the section is absent), or `locked`. It lives in
+     * `book.yml` — versioned, diffable, reviewable — because it is an editorial
+     * decision about the book, made deliberately and changed rarely.
+     *
+     * The emergency controls deliberately do NOT live here. Freeze and
+     * pause-agents are operational state in the database (migration 0007
+     * explains why at length): they must take effect on the next request rather
+     * than the next commit, and they must work when the repository does not.
+     */
+    collaboration: z
+        .strictObject({
+        annotation_policy: annotationPolicySchema.optional(),
+    })
+        .optional(),
+    /**
+     * Governance rules (Phase 6 contract section 3.6, amending Phase 3 section
+     * 3). Rules live here — versioned, diffable, and reviewable alongside the
+     * prose they govern, and therefore editable from the Settings view. The
+     * `RULES_JSON` environment variable remains a *bootstrap default* for a book
+     * that has not set them; once `governance.rules` exists it wins outright.
+     *
+     * Absent and `{}` are deliberately different: absent means "not configured,
+     * fall back to the environment/design default", while an explicit empty map
+     * is rejected below because a book with zero rules would silently never
+     * promote anything.
+     */
+    governance: z
+        .strictObject({
+        rules: rulesMapSchema
+            .refine((rules) => Object.keys(rules).length > 0, "governance.rules must define at least one rule (omit the section to use the default)")
+            .optional(),
+    })
+        .optional(),
+});
+//# sourceMappingURL=book.js.map

package/dist/build.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+/**
+ * One chapter as recorded in the build manifest (Phase 1 contract section 3,
+ * design section 17.2).
+ */
+export declare const buildManifestChapterSchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    revision: z.ZodNumber;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        proposed: "proposed";
+        published: "published";
+        archived: "archived";
+    }>;
+}, z.core.$strict>;
+export type BuildManifestChapter = z.infer<typeof buildManifestChapterSchema>;
+/**
+ * Build manifest `authorbot-build.json` — `authorbot.build/v1` (Phase 1
+ * contract section 3). `commit` is null when the build ran outside a git
+ * work tree; `chapters` lists every chapter included in the build.
+ */
+export declare const buildManifestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"authorbot.build/v1">;
+    commit: z.ZodNullable<z.ZodString>;
+    built_at: z.ZodString;
+    publisher_version: z.ZodString;
+    base_url: z.ZodOptional<z.ZodString>;
+    chapters: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        revision: z.ZodNumber;
+        title: z.ZodString;
+        status: z.ZodEnum<{
+            draft: "draft";
+            proposed: "proposed";
+            published: "published";
+            archived: "archived";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type BuildManifest = z.infer<typeof buildManifestSchema>;
+//# sourceMappingURL=build.d.ts.map

package/dist/build.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { chapterStatusSchema } from "./chapter.js";
+import { commitShaSchema, slugSchema, timestampSchema, uuidv7Schema, } from "./primitives.js";
+/**
+ * One chapter as recorded in the build manifest (Phase 1 contract section 3,
+ * design section 17.2).
+ */
+export const buildManifestChapterSchema = z.strictObject({
+    id: uuidv7Schema,
+    slug: slugSchema,
+    revision: z.number().int().min(1),
+    title: z.string().min(1),
+    status: chapterStatusSchema,
+});
+/**
+ * Build manifest `authorbot-build.json` — `authorbot.build/v1` (Phase 1
+ * contract section 3). `commit` is null when the build ran outside a git
+ * work tree; `chapters` lists every chapter included in the build.
+ */
+export const buildManifestSchema = z.strictObject({
+    schema: z.literal("authorbot.build/v1"),
+    commit: commitShaSchema.nullable(),
+    built_at: timestampSchema,
+    publisher_version: z.string().min(1),
+    base_url: z.string().min(1).optional(),
+    chapters: z.array(buildManifestChapterSchema),
+});
+//# sourceMappingURL=build.js.map

package/dist/chapter.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+/** Chapter lifecycle states (contract section 4, design section 9.3). */
+export declare const CHAPTER_STATUSES: readonly ["draft", "proposed", "published", "archived"];
+export declare const chapterStatusSchema: z.ZodEnum<{
+    draft: "draft";
+    proposed: "proposed";
+    published: "published";
+    archived: "archived";
+}>;
+export type ChapterStatus = z.infer<typeof chapterStatusSchema>;
+/**
+ * Chapter frontmatter — `authorbot.chapter/v1` (design section 8.3,
+ * contract section 4).
+ */
+export declare const chapterFrontmatterSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"authorbot.chapter/v1">;
+    id: z.ZodString;
+    slug: z.ZodString;
+    title: z.ZodString;
+    order: z.ZodNumber;
+    status: z.ZodEnum<{
+        draft: "draft";
+        proposed: "proposed";
+        published: "published";
+        archived: "archived";
+    }>;
+    revision: z.ZodNumber;
+    published_at: z.ZodOptional<z.ZodString>;
+    authors: z.ZodArray<z.ZodObject<{
+        actor: z.ZodString;
+    }, z.core.$strict>>;
+    summary: z.ZodOptional<z.ZodString>;
+    timeline_refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    character_refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ChapterFrontmatter = z.infer<typeof chapterFrontmatterSchema>;
+//# sourceMappingURL=chapter.d.ts.map