@texuli/deck 0.0.0-stage → 0.5.0

package/dist/model/style/schema.js

@@ -0,0 +1,53 @@
+/**
+ * `DeckStyle` (model v2 §3.1, §3.2): every field is optional. The schema
+ * keeps the authored document as written (no defaults injected, so text
+ * twins, patches and migration stay faithful); `DECK_STYLE_DEFAULTS` holds
+ * the documented defaults and `resolveDeckStyle` applies them.
+ */
+import { t } from "../../schema/index.js";
+import { deckBackground } from "../backgrounds/schema.js";
+import { DECK_ASPECTS, deckTransition, line, MEDIA_SRC_PATTERN } from "../shared.js";
+import { deckThemeReference, styleSlug } from "./theme.js";
+export const DECK_DENSITIES = ['compact', 'default', 'comfortable', 'spacious'];
+export const DECK_RADII = ['none', 'small', 'medium', 'large', 'full'];
+/** A ceiling: the host's reduced-motion preference only lowers it. */
+export const DECK_MOTIONS = ['full', 'subtle', 'none'];
+export const DECK_PROGRESS = ['none', 'top', 'bottom'];
+/** `style.logo`: media syntax (an image), at most 512 code points. */
+export const logoSrc = t.string({ min: 1, max: 512, pattern: MEDIA_SRC_PATTERN });
+export const deckStyle = t.object({
+    theme: t.optional(deckThemeReference, {
+        description: 'Catalog id or reference; absent → the host default theme.',
+    }),
+    fontPair: t.optional(styleSlug, {
+        description: 'Font pairing id; unknown → warning, theme font.',
+    }),
+    aspect: t.optional(t.enum(DECK_ASPECTS), { description: "Default '16:9'." }),
+    density: t.optional(t.enum(DECK_DENSITIES), {
+        description: "Default 'default' (0.875 / 1 / 1.125 / 1.25).",
+    }),
+    radius: t.optional(t.enum(DECK_RADII), { description: "Default 'medium'." }),
+    motion: t.optional(t.enum(DECK_MOTIONS), { description: "Default 'full'." }),
+    transition: t.optional(deckTransition, { description: "Default 'fade'." }),
+    background: t.optional(deckBackground, { description: "Default 'solid-color'." }),
+    logo: t.optional(logoSrc),
+    footer: t.optional(line(160)),
+    slideNumbers: t.optional(t.boolean(), { description: 'Default true.' }),
+    progress: t.optional(t.enum(DECK_PROGRESS), { description: "Default 'bottom'." }),
+    codeTheme: t.optional(styleSlug, {
+        description: 'Code highlight theme id; unknown → warning.',
+    }),
+    math: t.optional(t.boolean(), { description: 'Enables `$…$` TeX math. Default false.' }),
+}, { description: 'Deck style: theme, typography, canvas, motion and chrome.' });
+/** The documented defaults for every field that has one. */
+export const DECK_STYLE_DEFAULTS = Object.freeze({
+    aspect: '16:9',
+    density: 'default',
+    radius: 'medium',
+    motion: 'full',
+    transition: 'fade',
+    background: 'solid-color',
+    slideNumbers: true,
+    progress: 'bottom',
+    math: false,
+});

package/dist/model/style/theme.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Theme references (model v2 §3.8). A deck names its theme and the stage
+ * resolves it with `@texuli/tokens`; this L0 module only defines the data:
+ *
+ * - `catalog`: a Texuli library theme id (the string shorthand means this);
+ * - `embedded`: a theme object, bounded JSON here, validated by the stage
+ *   with `defineTheme` (its errors become issues there);
+ * - `seed`: Protoyard's `paletteSeed`, a uint32 the stage turns into a
+ *   generated theme.
+ *
+ * `mode` comes from the reference, else the host, else `light` (so exports
+ * are deterministic). `system` defers to the host.
+ */
+import { type Infer } from '../../schema/index.js';
+export declare const DECK_THEME_MODES: readonly ["light", "dark", "high-contrast", "system"];
+export type DeckThemeMode = (typeof DECK_THEME_MODES)[number];
+/** A concrete mode (what `system` and an absent mode become). */
+export type DeckResolvedThemeMode = Exclude<DeckThemeMode, 'system'>;
+/** Theme, font-pair and code-theme ids: lowercase slugs, 1 to 64 characters. */
+export declare const STYLE_SLUG_PATTERN = "^[a-z0-9][a-z0-9-]{0,63}$";
+export declare const styleSlug: import("../../index.js").StringSchema;
+/** The largest seed (`0xffffffff`). */
+export declare const DECK_THEME_SEED_MAX = 4294967295;
+/** Limits for an embedded theme: generous for a full `ThemeInput`, bounded for hostile input. */
+export declare const EMBEDDED_THEME_LIMITS: Readonly<{
+    depth: 6;
+    maxKeys: 100;
+    maxItems: 64;
+    maxString: 512;
+}>;
+export declare const THEME_CODES: Readonly<{
+    readonly unknownThemeKind: "unknown-theme-kind";
+    readonly embeddedTheme: "embedded-theme";
+    readonly unknownTheme: "unknown-theme";
+}>;
+/** The object form of a theme reference, told apart by `kind`. */
+export declare const deckThemeObject: import("../../index.js").UnionSchema<readonly [import("../../index.js").ObjectSchema<{
+    readonly kind: import("../../index.js").LiteralSchema<"catalog">;
+    readonly id: import("../../index.js").StringSchema;
+    readonly mode: import("../../index.js").OptionalSchema<import("../../index.js").EnumSchema<"dark" | "light" | "high-contrast" | "system">, false>;
+}>, import("../../index.js").ObjectSchema<{
+    readonly kind: import("../../index.js").LiteralSchema<"embedded">;
+    readonly theme: import("../../index.js").RefineSchema<import("../../index.js").JsonValueSchema>;
+    readonly mode: import("../../index.js").OptionalSchema<import("../../index.js").EnumSchema<"dark" | "light" | "high-contrast" | "system">, false>;
+}>, import("../../index.js").ObjectSchema<{
+    readonly kind: import("../../index.js").LiteralSchema<"seed">;
+    readonly seed: import("../../index.js").NumberSchema;
+    readonly mode: import("../../index.js").OptionalSchema<import("../../index.js").EnumSchema<"dark" | "light" | "high-contrast" | "system">, false>;
+}>]>;
+export type DeckThemeReference = Infer<typeof deckThemeObject>;
+/** `style.theme` and `slides[].theme`: a catalog id shorthand or a reference object. */
+export declare const deckThemeReference: import("../../index.js").UnionSchema<readonly [import("../../index.js").StringSchema, import("../../index.js").UnionSchema<readonly [import("../../index.js").ObjectSchema<{
+    readonly kind: import("../../index.js").LiteralSchema<"catalog">;
+    readonly id: import("../../index.js").StringSchema;
+    readonly mode: import("../../index.js").OptionalSchema<import("../../index.js").EnumSchema<"dark" | "light" | "high-contrast" | "system">, false>;
+}>, import("../../index.js").ObjectSchema<{
+    readonly kind: import("../../index.js").LiteralSchema<"embedded">;
+    readonly theme: import("../../index.js").RefineSchema<import("../../index.js").JsonValueSchema>;
+    readonly mode: import("../../index.js").OptionalSchema<import("../../index.js").EnumSchema<"dark" | "light" | "high-contrast" | "system">, false>;
+}>, import("../../index.js").ObjectSchema<{
+    readonly kind: import("../../index.js").LiteralSchema<"seed">;
+    readonly seed: import("../../index.js").NumberSchema;
+    readonly mode: import("../../index.js").OptionalSchema<import("../../index.js").EnumSchema<"dark" | "light" | "high-contrast" | "system">, false>;
+}>]>]>;
+export type DeckThemeInput = Infer<typeof deckThemeReference>;
+/** The object form of a validated reference (a string becomes `{ kind: 'catalog', id }`). */
+export declare function normalizeThemeReference(reference: DeckThemeInput | undefined): DeckThemeReference | undefined;
+/** The mode a deck renders in: the reference's, else the host's, else `light`. */
+export declare function resolveThemeMode(reference: DeckThemeInput | undefined, hostMode?: DeckResolvedThemeMode): DeckResolvedThemeMode;

package/dist/model/style/theme.js

@@ -0,0 +1,84 @@
+/**
+ * Theme references (model v2 §3.8). A deck names its theme and the stage
+ * resolves it with `@texuli/tokens`; this L0 module only defines the data:
+ *
+ * - `catalog`: a Texuli library theme id (the string shorthand means this);
+ * - `embedded`: a theme object, bounded JSON here, validated by the stage
+ *   with `defineTheme` (its errors become issues there);
+ * - `seed`: Protoyard's `paletteSeed`, a uint32 the stage turns into a
+ *   generated theme.
+ *
+ * `mode` comes from the reference, else the host, else `light` (so exports
+ * are deterministic). `system` defers to the host.
+ */
+import { t } from "../../schema/index.js";
+export const DECK_THEME_MODES = ['light', 'dark', 'high-contrast', 'system'];
+/** Theme, font-pair and code-theme ids: lowercase slugs, 1 to 64 characters. */
+export const STYLE_SLUG_PATTERN = '^[a-z0-9][a-z0-9-]{0,63}$';
+export const styleSlug = t.string({ pattern: STYLE_SLUG_PATTERN, max: 64 });
+/** The largest seed (`0xffffffff`). */
+export const DECK_THEME_SEED_MAX = 0xffff_ffff;
+/** Limits for an embedded theme: generous for a full `ThemeInput`, bounded for hostile input. */
+export const EMBEDDED_THEME_LIMITS = Object.freeze({
+    depth: 6,
+    maxKeys: 100,
+    maxItems: 64,
+    maxString: 512,
+});
+export const THEME_CODES = Object.freeze({
+    unknownThemeKind: 'unknown-theme-kind',
+    embeddedTheme: 'embedded-theme',
+    unknownTheme: 'unknown-theme',
+});
+const mode = t.optional(t.enum(DECK_THEME_MODES));
+const catalogTheme = t.object({
+    kind: t.literal('catalog'),
+    id: styleSlug,
+    mode,
+});
+const embeddedTheme = t.object({
+    kind: t.literal('embedded'),
+    theme: t.refine(t.json({ ...EMBEDDED_THEME_LIMITS, text: 'line' }), {
+        code: THEME_CODES.embeddedTheme,
+        description: 'An embedded theme is a JSON object (validated by the stage with defineTheme).',
+        check(value, context) {
+            if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+                context.issue({
+                    message: 'An embedded theme must be an object.',
+                    fix: 'Pass a theme object, or use { kind: "catalog", id } for a library theme.',
+                });
+            }
+        },
+    }),
+    mode,
+});
+const seedTheme = t.object({
+    kind: t.literal('seed'),
+    seed: t.int({ min: 0, max: DECK_THEME_SEED_MAX }),
+    mode,
+});
+/** The object form of a theme reference, told apart by `kind`. */
+export const deckThemeObject = t.union([catalogTheme, embeddedTheme, seedTheme], {
+    discriminator: 'kind',
+    code: THEME_CODES.unknownThemeKind,
+    description: 'A theme reference: catalog id, embedded theme or palette seed.',
+});
+/** `style.theme` and `slides[].theme`: a catalog id shorthand or a reference object. */
+export const deckThemeReference = t.union([styleSlug, deckThemeObject], {
+    description: 'A theme: a catalog id (shorthand), or a reference object.',
+});
+/** The object form of a validated reference (a string becomes `{ kind: 'catalog', id }`). */
+export function normalizeThemeReference(reference) {
+    if (reference === undefined)
+        return undefined;
+    if (typeof reference === 'string')
+        return { kind: 'catalog', id: reference };
+    return { ...reference };
+}
+/** The mode a deck renders in: the reference's, else the host's, else `light`. */
+export function resolveThemeMode(reference, hostMode) {
+    const own = typeof reference === 'object' ? reference.mode : undefined;
+    if (own !== undefined && own !== 'system')
+        return own;
+    return hostMode ?? 'light';
+}

package/dist/schema/builders.d.ts

@@ -0,0 +1,146 @@
+/**
+ * The combinators. Each returns a frozen plain object describing a shape;
+ * `validate` and `toJsonSchema` interpret it, and `Infer` reads its type.
+ * Builders throw `TypeError` on a malformed schema (a developer error, at
+ * module load); validation itself never throws.
+ */
+import { UNSAFE_KEYS } from './internal.js';
+import type { ArraySchema, BooleanSchema, EnumSchema, Infer, JsonValueSchema, LazySchema, LiteralSchema, LiteralValue, NullableSchema, NullSchema, NumberSchema, ObjectSchema, OptionalSchema, RecordSchema, RefineContext, RefineSchema, Schema, Shape, StringSchema, TextMode, UnionSchema } from './types.js';
+export interface Described {
+    description?: string;
+}
+export interface StringOptions extends Described {
+    /** Code points, counted after trimming. */
+    min?: number;
+    /** Code points, counted after trimming. */
+    max?: number;
+    pattern?: RegExp | string;
+    not?: readonly string[];
+    trim?: boolean;
+    text?: TextMode;
+}
+declare function string(options?: StringOptions): StringSchema;
+export interface NumberOptions extends Described {
+    min?: number;
+    max?: number;
+    /** Refuse ±Infinity (default true). */
+    finite?: boolean;
+}
+declare function number(options?: NumberOptions): NumberSchema;
+declare function int(options?: NumberOptions): NumberSchema;
+declare function boolean(options?: Described): BooleanSchema;
+declare function nullValue(options?: Described): NullSchema;
+export interface CodeOptions extends Described {
+    /** The code a mismatch reports instead of `enum`. */
+    code?: string;
+}
+declare function literal<const V extends LiteralValue>(value: V, options?: CodeOptions): LiteralSchema<V>;
+declare function enumOf<const V extends readonly [string, ...string[]]>(values: V, options?: CodeOptions): EnumSchema<V[number]>;
+export interface SizeOptions extends Described {
+    min?: number;
+    max?: number;
+}
+declare function array<I extends Schema>(item: I, options?: SizeOptions): ArraySchema<I>;
+export interface ObjectOptions extends Described {
+    /** `true` (default) reports unknown keys; `false` drops them. */
+    strict?: boolean;
+}
+declare function object<const S extends Shape>(shape: S, options?: ObjectOptions): ObjectSchema<S>;
+export interface RecordOptions extends SizeOptions {
+    /** Validates every key; `__proto__`, `constructor` and `prototype` are always refused. */
+    key?: StringSchema;
+}
+declare function record<V extends Schema>(value: V, options?: RecordOptions): RecordSchema<V>;
+export interface UnionOptions extends Described {
+    /** Pick the option by this key's value (one issue when it is unknown). */
+    discriminator?: string;
+    /** The code an unknown discriminator reports instead of `unknown-kind`. */
+    code?: string;
+}
+declare function union<const O extends readonly [Schema, ...Schema[]]>(options: O, settings?: UnionOptions): UnionSchema<O>;
+declare function nullable<I extends Schema>(inner: I, options?: Described): NullableSchema<I>;
+export interface OptionalOptions<T> extends Described {
+    /** Applied as a fresh copy when the key is missing; must be valid for the inner schema. */
+    default?: T;
+}
+declare function optional<I extends Schema>(inner: I, options: Described & {
+    default: Infer<I>;
+}): OptionalSchema<I, true>;
+declare function optional<I extends Schema>(inner: I, options?: Described): OptionalSchema<I, false>;
+export interface LazyOptions extends Described {
+    /** The `$defs` name in the JSON Schema export. */
+    name?: string;
+    /** How many times this schema may nest along one path. */
+    maxDepth?: number;
+}
+/**
+ * A recursive schema. TypeScript cannot infer a recursive type from a value,
+ * so annotate it: `const Node: Schema<TreeNode> = t.object({ kids: t.array(t.lazy(() => Node)) })`.
+ */
+declare function lazy<T>(get: () => Schema<T>, options?: LazyOptions): LazySchema<T>;
+export interface RefineOptions<T> extends Described {
+    /** The default code of the issues `check` raises (stable kebab-case). */
+    code: string;
+    /** Raise issues through `context.issue`; runs only when the inner schema passed. */
+    check(value: T, context: RefineContext): void;
+}
+/**
+ * A named custom check. The `description` documents the rule and is copied
+ * into the JSON Schema `description`, since JSON Schema cannot express it.
+ */
+declare function refine<I extends Schema>(inner: I, options: RefineOptions<Infer<I>>): RefineSchema<I>;
+export interface JsonOptions extends Described {
+    /** Nested containers allowed (default 4). */
+    depth?: number;
+    /** Keys per object (default 100). */
+    maxKeys?: number;
+    /** Items per array (default 200). */
+    maxItems?: number;
+    /** Code points per string (default 2,000). */
+    maxString?: number;
+    /** Code points per key (default 64). */
+    maxKeyLength?: number;
+    text?: TextMode;
+}
+/** Protoyard's props limits (`DECK_LIMITS`): depth 4, 100 keys, 200 items, 2,000-character strings. */
+export declare const JSON_DEFAULTS: Readonly<{
+    depth: 4;
+    maxKeys: 100;
+    maxItems: 200;
+    maxString: 2000;
+    maxKeyLength: 64;
+}>;
+/** Bounded JSON data: plain objects, arrays, finite numbers, strings, booleans, null. */
+declare function json(options?: JsonOptions): JsonValueSchema;
+/** A copy of `schema` with a description (shown in the JSON Schema). */
+declare function describe<S extends Schema>(schema: S, description: string): S;
+/** An object schema with more (or replaced) fields; keeps strictness unless overridden. */
+declare function extend<S extends Shape, E extends Shape>(base: ObjectSchema<S>, shape: E, options?: ObjectOptions): ObjectSchema<Omit<S, keyof E> & E>;
+declare function pick<S extends Shape, const K extends keyof S & string>(base: ObjectSchema<S>, keys: readonly K[]): ObjectSchema<Pick<S, K>>;
+declare function omit<S extends Shape, const K extends keyof S & string>(base: ObjectSchema<S>, keys: readonly K[]): ObjectSchema<Omit<S, K>>;
+/** The field schema of a discriminated union option, after unwrapping refinements. */
+export declare function objectOf(schema: Schema): ObjectSchema | undefined;
+/** The combinators, as one frozen object: `t.object({ title: t.string({ max: 200 }) })`. */
+export declare const t: Readonly<{
+    string: typeof string;
+    number: typeof number;
+    int: typeof int;
+    boolean: typeof boolean;
+    null: typeof nullValue;
+    literal: typeof literal;
+    enum: typeof enumOf;
+    array: typeof array;
+    object: typeof object;
+    record: typeof record;
+    union: typeof union;
+    nullable: typeof nullable;
+    optional: typeof optional;
+    lazy: typeof lazy;
+    refine: typeof refine;
+    json: typeof json;
+    describe: typeof describe;
+    extend: typeof extend;
+    pick: typeof pick;
+    omit: typeof omit;
+}>;
+export { UNSAFE_KEYS };

package/dist/schema/builders.js

@@ -0,0 +1,285 @@
+/**
+ * The combinators. Each returns a frozen plain object describing a shape;
+ * `validate` and `toJsonSchema` interpret it, and `Infer` reads its type.
+ * Builders throw `TypeError` on a malformed schema (a developer error, at
+ * module load); validation itself never throws.
+ */
+import { compilePattern, discriminatorIndex, isUnsafeKey, UNSAFE_KEYS, unwrapObject, } from "./internal.js";
+import { validate } from "./validate.js";
+function freeze(node) {
+    const out = {};
+    for (const [key, value] of Object.entries(node))
+        if (value !== undefined)
+            out[key] = value;
+    return Object.freeze(out);
+}
+function count(name, value) {
+    if (value !== undefined && !(Number.isInteger(value) && value >= 0)) {
+        throw new TypeError(`${name} must be a whole number, got ${value}.`);
+    }
+}
+function bounds(min, max) {
+    count('min', min);
+    count('max', max);
+    if (min !== undefined && max !== undefined && min > max) {
+        throw new TypeError(`min (${min}) is greater than max (${max}).`);
+    }
+}
+function string(options = {}) {
+    bounds(options.min, options.max);
+    let pattern;
+    if (options.pattern !== undefined) {
+        if (typeof options.pattern === 'string')
+            pattern = options.pattern;
+        else {
+            if (/[^uv]/.test(options.pattern.flags)) {
+                throw new TypeError('Patterns take no flags (they compile with "u" and must port to JSON Schema).');
+            }
+            pattern = options.pattern.source;
+        }
+        compilePattern(pattern);
+    }
+    return freeze({
+        kind: 'string',
+        min: options.min,
+        max: options.max,
+        pattern,
+        not: options.not ? Object.freeze([...options.not]) : undefined,
+        trim: options.trim || undefined,
+        text: options.text,
+        description: options.description,
+    });
+}
+function numeric(int, options) {
+    if (options.min !== undefined && options.max !== undefined && options.min > options.max) {
+        throw new TypeError(`min (${options.min}) is greater than max (${options.max}).`);
+    }
+    return freeze({
+        kind: 'number',
+        int,
+        min: options.min,
+        max: options.max,
+        finite: options.finite ?? true,
+        description: options.description,
+    });
+}
+function number(options = {}) {
+    return numeric(false, options);
+}
+function int(options = {}) {
+    return numeric(true, options);
+}
+function boolean(options = {}) {
+    return freeze({ kind: 'boolean', description: options.description });
+}
+function nullValue(options = {}) {
+    return freeze({ kind: 'null', description: options.description });
+}
+function literal(value, options = {}) {
+    if (typeof value === 'number' && !Number.isFinite(value)) {
+        throw new TypeError('A literal number must be finite.');
+    }
+    return freeze({
+        kind: 'literal',
+        value,
+        code: options.code,
+        description: options.description,
+    });
+}
+function enumOf(values, options = {}) {
+    if (values.length === 0)
+        throw new TypeError('An enum needs at least one value.');
+    if (new Set(values).size !== values.length)
+        throw new TypeError('Enum values must be unique.');
+    return freeze({
+        kind: 'enum',
+        values: Object.freeze([...values]),
+        code: options.code,
+        description: options.description,
+    });
+}
+function array(item, options = {}) {
+    bounds(options.min, options.max);
+    return freeze({
+        kind: 'array',
+        item,
+        min: options.min,
+        max: options.max,
+        description: options.description,
+    });
+}
+function object(shape, options = {}) {
+    const copy = {};
+    for (const key of Object.keys(shape)) {
+        if (isUnsafeKey(key))
+            throw new TypeError(`The key "${key}" cannot be declared.`);
+        copy[key] = shape[key];
+    }
+    return freeze({
+        kind: 'object',
+        shape: Object.freeze(copy),
+        strict: options.strict ?? true,
+        description: options.description,
+    });
+}
+function record(value, options = {}) {
+    bounds(options.min, options.max);
+    return freeze({
+        kind: 'record',
+        key: options.key,
+        value,
+        min: options.min,
+        max: options.max,
+        description: options.description,
+    });
+}
+function union(options, settings = {}) {
+    if (options.length === 0)
+        throw new TypeError('A union needs at least one option.');
+    const node = freeze({
+        kind: 'union',
+        options: Object.freeze([...options]),
+        discriminator: settings.discriminator,
+        code: settings.code,
+        description: settings.description,
+    });
+    if (node.discriminator !== undefined)
+        discriminatorIndex(node); // throws when malformed
+    return node;
+}
+function nullable(inner, options = {}) {
+    return freeze({ kind: 'nullable', inner, description: options.description });
+}
+function optional(inner, options = {}) {
+    const hasDefault = Object.hasOwn(options, 'default');
+    if (hasDefault) {
+        const check = validate(inner, options.default);
+        if (!check.ok) {
+            throw new TypeError(`The default is not valid: ${check.issues[0]?.message ?? 'invalid'}`);
+        }
+    }
+    return freeze({
+        kind: 'optional',
+        inner,
+        hasDefault,
+        default: hasDefault ? deepFreeze(options.default) : undefined,
+        description: options.description,
+    });
+}
+function deepFreeze(value) {
+    if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            deepFreeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+/**
+ * A recursive schema. TypeScript cannot infer a recursive type from a value,
+ * so annotate it: `const Node: Schema<TreeNode> = t.object({ kids: t.array(t.lazy(() => Node)) })`.
+ */
+function lazy(get, options = {}) {
+    count('maxDepth', options.maxDepth);
+    if (options.name !== undefined && !/^[A-Za-z][A-Za-z0-9_-]*$/.test(options.name)) {
+        throw new TypeError(`Invalid lazy schema name "${options.name}".`);
+    }
+    return freeze({
+        kind: 'lazy',
+        get,
+        name: options.name,
+        maxDepth: options.maxDepth,
+        description: options.description,
+    });
+}
+/**
+ * A named custom check. The `description` documents the rule and is copied
+ * into the JSON Schema `description`, since JSON Schema cannot express it.
+ */
+function refine(inner, options) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(options.code)) {
+        throw new TypeError(`Refinement codes are kebab-case, got "${options.code}".`);
+    }
+    return freeze({
+        kind: 'refine',
+        inner,
+        code: options.code,
+        check: options.check,
+        description: options.description,
+    });
+}
+/** Protoyard's props limits (`DECK_LIMITS`): depth 4, 100 keys, 200 items, 2,000-character strings. */
+export const JSON_DEFAULTS = Object.freeze({
+    depth: 4,
+    maxKeys: 100,
+    maxItems: 200,
+    maxString: 2_000,
+    maxKeyLength: 64,
+});
+/** Bounded JSON data: plain objects, arrays, finite numbers, strings, booleans, null. */
+function json(options = {}) {
+    const node = {
+        kind: 'json',
+        depth: options.depth ?? JSON_DEFAULTS.depth,
+        maxKeys: options.maxKeys ?? JSON_DEFAULTS.maxKeys,
+        maxItems: options.maxItems ?? JSON_DEFAULTS.maxItems,
+        maxString: options.maxString ?? JSON_DEFAULTS.maxString,
+        maxKeyLength: options.maxKeyLength ?? JSON_DEFAULTS.maxKeyLength,
+        text: options.text,
+        description: options.description,
+    };
+    for (const key of ['depth', 'maxKeys', 'maxItems', 'maxString', 'maxKeyLength']) {
+        count(key, node[key]);
+    }
+    return freeze(node);
+}
+/** A copy of `schema` with a description (shown in the JSON Schema). */
+function describe(schema, description) {
+    return freeze({ ...schema, description });
+}
+/** An object schema with more (or replaced) fields; keeps strictness unless overridden. */
+function extend(base, shape, options = {}) {
+    return object({ ...base.shape, ...shape }, {
+        strict: options.strict ?? base.strict,
+        description: options.description ?? base.description,
+    });
+}
+function pick(base, keys) {
+    const shape = {};
+    for (const key of keys)
+        shape[key] = base.shape[key];
+    return object(shape, { strict: base.strict });
+}
+function omit(base, keys) {
+    const shape = { ...base.shape };
+    for (const key of keys)
+        delete shape[key];
+    return object(shape, { strict: base.strict });
+}
+/** The field schema of a discriminated union option, after unwrapping refinements. */
+export function objectOf(schema) {
+    return unwrapObject(schema);
+}
+/** The combinators, as one frozen object: `t.object({ title: t.string({ max: 200 }) })`. */
+export const t = Object.freeze({
+    string,
+    number,
+    int,
+    boolean,
+    null: nullValue,
+    literal,
+    enum: enumOf,
+    array,
+    object,
+    record,
+    union,
+    nullable,
+    optional,
+    lazy,
+    refine,
+    json,
+    describe,
+    extend,
+    pick,
+    omit,
+});
+export { UNSAFE_KEYS };