@tryvitris/website-harness 0.0.0-stage → 0.1.0-beta.6

package/bin/types/src/engine/index.d.ts

@@ -0,0 +1,70 @@
+import { type ChangePlanRecord, type ChangeRequestRecord, type ChangeResultRecord, type SiteIdentity, type SourceRevision } from "./contracts.ts";
+export { sourceRevision, changedSourceFiles } from "./revision.ts";
+export { generateEditManifest, publicEditManifest } from "../editing/manifest.ts";
+export type { SiteIdentity, SourceRevision, ChangeRequestRecord, ChangePlanRecord, ChangeResultRecord } from "./contracts.ts";
+export interface SiteInspection {
+    identity: SiteIdentity;
+    revision: SourceRevision;
+    legacyIdentity: boolean;
+    pendingRequestId?: string;
+}
+export declare function inspectSite(siteRoot: string): SiteInspection;
+export interface PreparedChange {
+    status: "prepared";
+    request: ChangeRequestRecord;
+    plan: ChangePlanRecord;
+    baselineRevision: SourceRevision;
+    preparedRevision: SourceRevision;
+    baselinePath: string;
+    impactedNodes: string[];
+}
+export declare function prepareChange(siteRoot: string, rawRequest: unknown, rawPlan: unknown): PreparedChange;
+export interface SetTextOperation {
+    kind: "set_text";
+    file: string;
+    elementId: string;
+    text: string;
+}
+export interface ReplaceMediaOperation {
+    kind: "replace_media";
+    file: string;
+    elementId: string;
+    src: string;
+}
+export interface SetThemeTokenOperation {
+    kind: "set_theme_token";
+    file: "theme/defaults.json";
+    token: string;
+    value: string;
+}
+export interface MoveSectionOperation {
+    kind: "move_section";
+    file: string;
+    sectionId: string;
+    beforeSectionId: string;
+}
+export type SourceOperation = SetTextOperation | ReplaceMediaOperation | SetThemeTokenOperation | MoveSectionOperation;
+export interface AppliedChange {
+    status: "draft";
+    requestId: string;
+    beforeRevision: SourceRevision;
+    afterRevision: SourceRevision;
+    changedFiles: string[];
+}
+export declare function applyOperations(siteRoot: string, requestId: string, operations: SourceOperation[], manifestRevision?: string): AppliedChange;
+export declare function buildSiteDraft(siteRoot: string): Promise<{
+    sourceRevision: SourceRevision;
+    buildDigest: string;
+    output: string;
+}>;
+export declare function verifyChange(siteRoot: string, requestId: string): Promise<ChangeResultRecord>;
+/** Restores a failed or abandoned candidate only while its exact source revision still matches. */
+export declare function discardChange(siteRoot: string, requestId: string, candidateRevision: string): {
+    status: "already_discarded";
+    revision: SourceRevision;
+    restoredFiles: never[];
+} | {
+    status: "discarded";
+    revision: SourceRevision;
+    restoredFiles: string[];
+};

package/bin/types/src/engine/revision.d.ts

@@ -0,0 +1,5 @@
+import { type SourceRevision } from "./contracts.ts";
+/** Canonical authored inputs; previews, task packets, receipts, and Git metadata are derived. */
+export declare const AUTHORITATIVE_INPUTS: readonly ["pages", "components", "theme", "media", "public", "preserved", "onboarding", "site.json", "launch.json", "package.json", "package-lock.json", "agent/overrides", "agent/site-memory.json"];
+export declare function sourceRevision(siteRoot: string): SourceRevision;
+export declare function changedSourceFiles(before: SourceRevision, after: SourceRevision): string[];

package/bin/types/src/forms/cloudflare.d.ts

@@ -0,0 +1,24 @@
+export type Widget = {
+    sitekey: string;
+    name: string;
+    domains: string[];
+    secret?: string;
+};
+export type CloudflareAccess = {
+    account: string;
+    token: string;
+};
+export declare function cloudflareRequest<T>(access: CloudflareAccess, path: string, method?: string, body?: unknown): Promise<T>;
+export declare function listWidgets(access: CloudflareAccess): Promise<Widget[]>;
+export declare function allocateWidget(widgets: Widget[], hostnames: string[]): {
+    widget?: Widget;
+    domains: string[];
+    name: string;
+};
+export declare function reconcileWidget(access: CloudflareAccess, hostnames: string[], apply: boolean): Promise<{
+    sitekey?: string;
+    secretRef?: string;
+    plan: ReturnType<typeof allocateWidget>;
+}>;
+export declare function validateSecretMap(value: unknown): Record<string, string>;
+export declare function provisionWidgetSecrets(access: CloudflareAccess, worker: string, existing: unknown): Promise<void>;

package/bin/types/src/forms/config.d.ts

@@ -0,0 +1,34 @@
+/** Shared, bounded contract. Recipients and secret references never enter public assets. */
+export type FormField = {
+    name: string;
+    label?: string;
+    type: 'text' | 'email' | 'tel' | 'textarea' | 'select' | 'checkbox' | 'radio';
+    required?: boolean;
+    minLength?: number;
+    maxLength: number;
+    options?: string[];
+    map?: 'name' | 'email' | 'phone' | 'message';
+};
+export type FormConfig = {
+    id: string;
+    mode: 'disabled' | 'test' | 'live';
+    origins: string[];
+    fields: FormField[];
+    recipients: string[];
+    turnstile: {
+        sitekey: string;
+        secretRef: string;
+        action: string;
+    };
+};
+export type PublicForm = {
+    id: string;
+    pagePath: string;
+    index?: number;
+    sitekey: string;
+    action: string;
+};
+export declare const safeId: (s: unknown) => s is string;
+export declare const safeEmail: (s: unknown) => s is string;
+export declare function approvedOrigin(value: string): string;
+export declare function validateFormConfig(value: unknown): FormConfig;

package/bin/types/src/forms/frontend.d.ts

@@ -0,0 +1,9 @@
+import { type FormField, type PublicForm } from './config.ts';
+export type FormInventory = {
+    index: number;
+    eligible: boolean;
+    fields: FormField[];
+    unsupported: string[];
+};
+export declare function inspectForms(html: string): FormInventory[];
+export declare function connectForms(html: string, backend: string, pagePath: string, forms: PublicForm[]): string;

package/bin/types/src/html.d.ts

@@ -0,0 +1,3 @@
+export declare function escapeHtml(value: string): string;
+export declare function escapeAttr(value: string): string;
+export declare function json(value: unknown): string;

package/bin/types/src/icons/catalog.d.ts

@@ -0,0 +1,28 @@
+import type { StudioVariant } from './studio.ts';
+export declare const ICON_VERSION = 5;
+export declare const BASE_ICON_VARIANTS: readonly ["light", "regular", "solid", "duotone"];
+export declare const ICON_VARIANTS: readonly ["light", "regular", "solid", "duotone", "soft", "block", "cutout", "imprint", "sketch"];
+export type IconVariant = typeof ICON_VARIANTS[number];
+export type IconDefinition = {
+    name: string;
+    category: string;
+    keywords: readonly string[];
+    outline: string;
+    solid: string;
+    duotone: {
+        primary: string;
+        secondary: string;
+    };
+    families?: Readonly<Partial<Record<StudioVariant, string>>>;
+    /** Revision in which geometry was redrawn, not a human approval or taste label. */
+    refinedVersion?: number;
+    /** Latest rendered industry review; retained drawings are not marked redrawn. */
+    reviewedVersion?: number;
+};
+export declare const icons: readonly IconDefinition[];
+export declare const iconNames: readonly string[];
+export declare const iconAliases: Readonly<Record<string, string>>;
+export declare function getIcon(name: string): IconDefinition | undefined;
+export declare function availableIconVariants(name: string): readonly IconVariant[];
+export declare const iconVariantCount: number;
+export declare function searchIcons(query?: string, category?: string): readonly IconDefinition[];

package/bin/types/src/icons/coverage.d.ts

@@ -0,0 +1,12 @@
+export type IconIndustry = {
+    id: string;
+    label: string;
+    /** Names and aliases used by the hosted Vitris template catalog. */
+    terms: readonly string[];
+    categories: readonly string[];
+    extras: readonly string[];
+};
+export declare const iconIndustries: readonly IconIndustry[];
+export declare const iconsForIndustry: (industry: IconIndustry) => import("./catalog.ts").IconDefinition[];
+export declare const industriesForIcon: (name: string) => IconIndustry[];
+export declare const findIconIndustry: (name: string) => IconIndustry | undefined;

package/bin/types/src/icons/drawing.d.ts

@@ -0,0 +1,7 @@
+/** Original Vitris geometric drawing helpers. No third-party path data. */
+export declare const p: (d: string) => string;
+export declare const c: (x: number, y: number, r: number) => string;
+export declare const r: (x: number, y: number, w: number, h: number, radius?: number) => string;
+export declare const line: (d: string) => string;
+export declare const hole: (d: string) => string;
+export declare const ring: (x: number, y: number, radius: number, inner: number) => string;

package/bin/types/src/icons/duotone.d.ts

@@ -0,0 +1,4 @@
+export declare function originalDuotone(name: string, solid: string): {
+    primary: string;
+    secondary: string;
+};

package/bin/types/src/icons/index.d.ts

@@ -0,0 +1,37 @@
+import type { IconVariant } from './catalog.ts';
+export { icons, iconNames, iconAliases, getIcon, ICON_VERSION, ICON_VARIANTS, BASE_ICON_VARIANTS, availableIconVariants, iconVariantCount } from './catalog.ts';
+export { STUDIO_VARIANTS, studioFamilyInfo, studioIconNames, coreStudioIconNames, industryStudioIconNames } from './studio.ts';
+export type { IconDefinition, IconVariant } from './catalog.ts';
+export { iconIndustries, iconsForIndustry, industriesForIcon, findIconIndustry } from './coverage.ts';
+export type { IconIndustry } from './coverage.ts';
+export { industryIconReviews, INDUSTRY_REVIEW_VERSION, industryReviewCount } from './industry-review.ts';
+export type { IndustryIconReview } from './industry-review.ts';
+export { industryStudioReviews } from './studio-industry-review.ts';
+export type { IndustryStudioReview } from './studio-industry-review.ts';
+/** Build-time selection guidance. Never sent to a published page by renderIcon. */
+export declare function inspectIcon(name: string): {
+    review: import("./industry-review.ts").IndustryIconReview | null;
+    studioReview: import("./studio-industry-review.ts").IndustryStudioReview | null;
+    usage: string;
+    refinedVersion?: number | undefined;
+    name: string;
+    category: string;
+    variants: readonly ("soft" | "block" | "cutout" | "imprint" | "sketch" | "solid" | "duotone" | "light" | "regular")[];
+};
+/** Exact industry aliases also resolve to curated groups (e.g. OB-GYN, SaaS). */
+export declare function searchIcons(query?: string, category?: string): readonly import("./catalog.ts").IconDefinition[];
+export type IconOptions = {
+    variant?: IconVariant;
+    /** Decorative by default. Give meaningful images a label, and controls their own label. */
+    label?: string;
+    labelledby?: string;
+    className?: string;
+    id?: string;
+    width?: string;
+    height?: string;
+    describedby?: string;
+    data?: Record<string, string>;
+};
+/** Build-time renderer. Never include this module or the catalog in a client island. */
+export declare function renderIcon(name: string, options?: IconOptions): string;
+export declare const iconCss = ".vitris-icon{display:inline-block;pointer-events:none;vertical-align:-.125em;flex-shrink:0}.btn-arrow:has(.vitris-icon)::after{content:none}";

package/bin/types/src/icons/industry-refinements-v4.d.ts

@@ -0,0 +1,4 @@
+import type { IconDefinition } from './catalog.ts';
+type Masters = Pick<IconDefinition, 'outline' | 'solid' | 'duotone'>;
+export declare const industryRefinementsV4: Readonly<Record<string, Masters>>;
+export {};

package/bin/types/src/icons/industry-review.d.ts

@@ -0,0 +1,11 @@
+export type IndustryIconReview = {
+    version: number;
+    decision: 'redrawn' | 'retained';
+    geometrySha256: string;
+    minSize: 16 | 24 | 32;
+    compactAlternative: string | null;
+    note: string;
+};
+export declare const industryIconReviews: Readonly<Record<string, IndustryIconReview>>;
+export declare const INDUSTRY_REVIEW_VERSION = 4;
+export declare const industryReviewCount: number;

package/bin/types/src/icons/industry.d.ts

@@ -0,0 +1,2 @@
+import type { IconDefinition } from './catalog.ts';
+export declare const industryIcons: readonly IconDefinition[];

package/bin/types/src/icons/refinements.d.ts

@@ -0,0 +1,5 @@
+import type { IconDefinition } from './catalog.ts';
+type Masters = Pick<IconDefinition, 'outline' | 'solid' | 'duotone'>;
+export declare const refinedIndustryMasters: Readonly<Record<string, Masters>>;
+export declare const refinedIndustryNames: readonly string[];
+export {};

package/bin/types/src/icons/studio-industry-review.d.ts

@@ -0,0 +1,9 @@
+import type { StudioVariant } from './studio.ts';
+export type IndustryStudioReview = {
+    version: number;
+    rationale: string;
+    note: string;
+    minSizes: Readonly<Record<StudioVariant, number>>;
+    geometrySha256: Readonly<Record<StudioVariant, string>>;
+};
+export declare const industryStudioReviews: Readonly<Record<string, IndustryStudioReview>>;

package/bin/types/src/icons/studio-industry.d.ts

@@ -0,0 +1,5 @@
+import type { StudioVariant } from './studio.ts';
+type Masters = Record<StudioVariant, string>;
+export declare const industryStudioIcons: Readonly<Record<string, Readonly<Masters>>>;
+export declare const industryStudioIconNames: readonly string[];
+export {};

package/bin/types/src/icons/studio.d.ts

@@ -0,0 +1,34 @@
+export { industryStudioIconNames } from './studio-industry.ts';
+export declare const STUDIO_VARIANTS: readonly ["soft", "block", "cutout", "imprint", "sketch"];
+export type StudioVariant = typeof STUDIO_VARIANTS[number];
+export declare const studioFamilyInfo: {
+    readonly soft: {
+        readonly label: "Soft";
+        readonly description: "Open squircle curves, generous counters, rounded terminals. Friendly interfaces and approachable services.";
+        readonly layered: false;
+    };
+    readonly block: {
+        readonly label: "Block";
+        readonly description: "Heavy transparent frames, broad feet and a deliberate lower-right extrusion. Bold editorial accents.";
+        readonly layered: false;
+    };
+    readonly cutout: {
+        readonly label: "Cutout";
+        readonly description: "Separated solid pieces, curved cut-ins and clear geometric gaps. Graphic feature illustrations.";
+        readonly layered: false;
+    };
+    readonly imprint: {
+        readonly label: "Imprint";
+        readonly description: "Organic color shapes with a few carefully placed ink lines. Warm, informal storytelling.";
+        readonly layered: true;
+    };
+    readonly sketch: {
+        readonly label: "Sketch";
+        readonly description: "Individually drawn pencil-like curves, restrained asymmetry and intentional pen lifts. Editorial and personal sites.";
+        readonly layered: false;
+    };
+};
+type Masters = Record<StudioVariant, string>;
+export declare const coreStudioIconNames: readonly string[];
+export declare const studioIcons: Readonly<Record<string, Readonly<Masters>>>;
+export declare const studioIconNames: readonly string[];

package/bin/types/src/integrations/cloudflare-pages.d.ts

@@ -0,0 +1,10 @@
+import type { HostingAdapter } from "./hosting.ts";
+export declare function ensurePreservePreviewProject(project: string, branch: string, signal?: AbortSignal): Promise<void>;
+export declare function cloudflarePagesAdapter(opts: {
+    siteRoot: string;
+    project: string;
+    previewBranch?: string;
+    signal?: AbortSignal;
+    onLog?: (line: string) => void;
+    ensurePreviewProject?: boolean;
+}): HostingAdapter;

package/bin/types/src/integrations/deployment-smoke.d.ts

@@ -0,0 +1,11 @@
+export declare function deploymentSmoke(url: string, opts?: {
+    signal?: AbortSignal;
+    onLog?: (line: string) => void;
+    preserved?: boolean;
+    attempts?: number;
+    retryDelayMs?: number;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    message: string;
+}>;

package/bin/types/src/integrations/hosting.d.ts

@@ -0,0 +1,33 @@
+import { type ReleaseRecord } from "../engine/contracts.ts";
+export interface VerifiedArtifact {
+    schemaVersion: 1;
+    sourceRevision: string;
+    artifactDigest: string;
+    compilerDigest: string;
+    harnessVersion: string;
+    environment: "preview" | "production";
+    policyId: string;
+    outputDirectory: string;
+    checkedAt: string;
+}
+export interface DeploymentReceipt {
+    provider: string;
+    environment: string;
+    deploymentId: string;
+    url?: string;
+    artifactDigest: string;
+    issuedAt: string;
+}
+export interface HostingAdapter {
+    id: string;
+    deployPreview(artifact: VerifiedArtifact): Promise<DeploymentReceipt>;
+    publish(artifact: VerifiedArtifact): Promise<DeploymentReceipt>;
+    status?(deploymentId: string): Promise<DeploymentReceipt>;
+    attachDomain?(deploymentId: string, domain: string): Promise<DeploymentReceipt>;
+    rollback?(deploymentId: string): Promise<DeploymentReceipt>;
+}
+export declare function prepareVerifiedRelease(siteRoot: string, environment?: "preview" | "production"): Promise<VerifiedArtifact>;
+export declare function deployVerifiedArtifact(siteRoot: string, artifact: VerifiedArtifact, adapter: HostingAdapter): Promise<{
+    release: ReleaseRecord;
+    deployment: DeploymentReceipt;
+}>;

package/bin/types/src/integrations/wrangler-command.d.ts

@@ -0,0 +1,5 @@
+/** Launch the actual JS entry point: .cmd cannot be spawned without a shell on Windows. */
+export declare function wranglerCommand(siteRoot: string, args: string[]): {
+    command: string;
+    args: string[];
+};

package/bin/types/src/knowledge/artifact-order.d.ts

@@ -0,0 +1 @@
+export declare function compareArtifactPaths(a: string, b: string): number;

package/bin/types/src/knowledge/artifact.d.ts

@@ -0,0 +1,11 @@
+export type ArtifactEntry = {
+    path: string;
+    bytes: number;
+    sha256: string;
+};
+export type ArtifactManifest = {
+    schemaVersion: 1;
+    files: ArtifactEntry[];
+    sha256: string;
+};
+export declare function artifactManifest(distDirectory: string): ArtifactManifest;

package/bin/types/src/knowledge/composition.d.ts

@@ -0,0 +1,54 @@
+export type CompositionLesson = {
+    id: string;
+    version: 1;
+    release: string;
+    title: string;
+    summary: string;
+    principle: string;
+    scope: string[];
+    tasks: string[];
+    stages: string[];
+    evidenceNeeds: {
+        kind: "fact" | "media" | "route" | "interaction-model";
+        role?: string;
+        minimum?: number;
+        mandatory: boolean;
+    }[];
+    applicability: {
+        positiveSignals: string[];
+        exclusions: string[];
+        uncertainty: string;
+    };
+    relationshipGroup: string;
+    relationships: string[];
+    bodyPath: string;
+    sourceIds: string[];
+    requirementIds: string[];
+    demonstrationIds: string[];
+    reviewProbeIds: string[];
+    contentHash: string;
+};
+export type CompositionExample = {
+    id: string;
+    lessonId: string;
+    role: "application-a" | "application-b" | "counterexample";
+    scenario: string;
+    provenance: string;
+    fixturePath: string | null;
+    captureHandles: string[];
+    inspectionStatus: "pending" | "inspected";
+    sourceHash: string;
+};
+export type CompositionPack = {
+    kernel: string;
+    release: string;
+    manifestHash: string;
+    lessons: CompositionLesson[];
+    examples: CompositionExample[];
+    sources: {
+        id: string;
+    }[];
+    body: (id: string) => string;
+};
+/** Loads only files named and verified by the pinned manifest. Any integrity error is fatal. */
+export declare function loadCompositionPack(siteOrKernel: string, requestedRelease?: string): CompositionPack;

package/bin/types/src/knowledge/contracts.d.ts

@@ -0,0 +1,111 @@
+/** Typed knowledge records. A source, a requirement, a lesson, and a business fact are not interchangeable. */
+export declare const KNOWLEDGE_RELEASE = "2026-09-22";
+export declare const LAUNCH_POLICY_ID = "vitris-launch-2026-09-22";
+export type SourceKind = "standard" | "official-platform" | "research-usability" | "inspected-example" | "original-teaching" | "project-policy";
+export type ReviewStatus = "live-checked" | "cited-not-rechecked";
+export type KnowledgeSource = {
+    id: string;
+    publisher: string;
+    title: string;
+    url: string;
+    sourceKind: SourceKind;
+    versionDate?: string;
+    lastReviewed: string | null;
+    reviewStatus: ReviewStatus;
+    reviewOwner: string;
+    sectionAnchors: string[];
+    summary: string;
+    summarySha256: string;
+    reuseNotes: string;
+    supersedes?: string[];
+};
+export type AuthorityClass = "standard" | "official-platform" | "research-heuristic" | "project-policy" | "teaching";
+export type CoverageStatus = "documented" | "verifier-implemented" | "fixture-tested" | "pilot-validated";
+export type SeverityPolicy = "blocker" | "warning" | "manual-pending";
+export type KnowledgeRequirement = {
+    id: string;
+    version: number;
+    domains: string[];
+    title: string;
+    instruction: string;
+    rationale: string;
+    authorityIds: string[];
+    authorityClass: AuthorityClass;
+    applicability: string;
+    stages: string[];
+    verificationMethod: string;
+    verifierId: string | null;
+    severityPolicy: SeverityPolicy;
+    exceptions: string[];
+    repairOwner: string;
+    implementationStatus: CoverageStatus;
+    widget?: string;
+};
+export type LessonAlternative = {
+    id: string;
+    summary: string;
+};
+export type LessonExtension = {
+    id: string;
+    version: number;
+    evidenceClass: "original-synthetic" | "inspected-reference";
+    uncertainty: string;
+    requirementIds: string[];
+    alternatives: LessonAlternative[];
+    inspection: string;
+};
+export type ReplacementRecord = {
+    id: string;
+    fromVersion: number;
+    toVersion: number;
+    note: string;
+};
+export type AssetProvenance = {
+    id: string;
+    path: string;
+    creator: string;
+    license: string;
+    acquired: string;
+    sha256: string;
+    origin: "generated" | "photographed" | "diagrammatic" | "unknown";
+    permittedUses: Array<"teaching" | "production">;
+};
+export type FindingStatus = "pass" | "fail" | "warning" | "unknown" | "not-applicable" | "tool-error" | "stale" | "waived";
+export type QualityFinding = {
+    id: string;
+    requirementId: string;
+    domain: string;
+    severity: "serious" | "warning" | "note";
+    confidence: "confirmed" | "suspected" | "unknown";
+    status: FindingStatus;
+    page?: string;
+    component?: string;
+    evidence: string;
+    verifier: string;
+    verifierVersion: string;
+    sourceHash?: string;
+    buildHash?: string;
+    policyHash?: string;
+    knowledgeHash?: string;
+    repairOwner: string;
+    suggestedRepair?: string;
+    verifiedAt: string;
+    applicability?: string;
+};
+export type LaunchOverride = {
+    findingId: string;
+    buildHash: string;
+    policyHash: string;
+    reason: string;
+    scope: string;
+};
+export type LaunchEvidence = {
+    trusted: boolean;
+    buildHash: string;
+    policyHash: string;
+    knowledgeRelease: string;
+    browserVerifier: "ok" | "unavailable" | "stale";
+    findings: QualityFinding[];
+    overrides?: LaunchOverride[];
+    manualCoverage: "pending" | "recorded";
+};

package/bin/types/src/knowledge/explain.d.ts

@@ -0,0 +1,6 @@
+export declare function explainStage(root: string, stage: string): {
+    text: string;
+    release: string;
+    lessonIds: string[];
+    requirementIds: string[];
+};

package/bin/types/src/knowledge/pack.d.ts

@@ -0,0 +1,32 @@
+import type { AssetProvenance, KnowledgeRequirement, KnowledgeSource, LessonExtension, ReplacementRecord } from "./contracts.ts";
+export type KnowledgePack = {
+    kernel: string;
+    release: string;
+    sources: KnowledgeSource[];
+    requirements: KnowledgeRequirement[];
+    extensions: LessonExtension[];
+    replacements: ReplacementRecord[];
+    assets: AssetProvenance[];
+    errors: string[];
+};
+export declare function knowledgeV2Dir(kernel: string): string;
+export declare function verifyKnowledgeV2(kernel: string): string[];
+export declare function loadKnowledgeV2(siteOrKernel: string): KnowledgePack | undefined;
+export declare function lessonExtension(pack: KnowledgePack | undefined, id: string): LessonExtension | undefined;
+export declare function sourceFreshness(source: KnowledgeSource, now: Date, intervalDays: number): "current" | "due-for-maintenance" | "not-reviewed";
+export declare function coverageReport(pack: KnowledgePack): {
+    release: string;
+    requirements: {
+        id: string;
+        authorityClass: string;
+        implementationStatus: string;
+        verifierId: string | null;
+    }[];
+    missingClassification: string[];
+};
+/** v1 lesson ids stay valid. v2 records the version they map to. */
+export declare function migrateLessonId(pack: KnowledgePack, id: string, version: number): {
+    id: string;
+    version: number;
+    migrated: boolean;
+};

package/bin/types/src/knowledge/selection.d.ts

@@ -0,0 +1,18 @@
+import type { KnowledgeRequirement } from "./contracts.ts";
+import type { LessonSelection, SelectionSignals } from "../agent/design-knowledge.ts";
+export type StageSignals = SelectionSignals & {
+    widgets?: string[];
+    contactPath?: boolean;
+};
+export declare function requirementApplies(requirement: KnowledgeRequirement, signals: StageSignals, stage: string): boolean;
+/** Mandatory requirements stay even when the advisory lesson budget is zero. */
+export declare function selectStageKnowledge(input: {
+    requirements: KnowledgeRequirement[];
+    lessons: LessonSelection[];
+    signals: StageSignals;
+    stage: string;
+    lessonLimit?: number;
+}): {
+    requirements: KnowledgeRequirement[];
+    lessons: LessonSelection[];
+};

package/bin/types/src/knowledge/site-widgets.d.ts

@@ -0,0 +1,6 @@
+import type { Storyboard } from "../agent/artifacts.ts";
+/** Derive widget use from the planned sections and components reachable from pages. */
+export declare function siteWidgets(root: string, story?: Storyboard): {
+    widgets: string[];
+    sourceFiles: string[];
+};