@vxnsin/inkan 0.0.0-stage → 0.1.0

package/dist/router.js

@@ -0,0 +1,84 @@
+// A segment tree. Static segments win over `:params`, params win over `*rest`,
+// so `/users/me` and `/users/:id` can live side by side in any order.
+const node = () => ({ statics: new Map(), routes: new Map() });
+export function splitPath(path) {
+    return path.split("/").filter(Boolean);
+}
+export class Router {
+    root = node();
+    add(method, path, route) {
+        let n = this.root;
+        const segments = splitPath(path);
+        for (const [i, seg] of segments.entries()) {
+            if (seg.startsWith("*")) {
+                if (i !== segments.length - 1)
+                    throw new Error(`A wildcard has to be the last segment: ${path}`);
+                n.wildcard ??= { name: seg.slice(1) || "rest", routes: new Map() };
+                this.put(n.wildcard.routes, method, path, route);
+                return;
+            }
+            if (seg.startsWith(":")) {
+                const name = seg.slice(1);
+                if (n.param && n.param.name !== name) {
+                    throw new Error(`${path} names a parameter :${name} where another route already has :${n.param.name}`);
+                }
+                n.param ??= { name, node: node() };
+                n = n.param.node;
+            }
+            else {
+                let next = n.statics.get(seg);
+                if (!next)
+                    n.statics.set(seg, (next = node()));
+                n = next;
+            }
+        }
+        this.put(n.routes, method, path, route);
+    }
+    put(routes, method, path, route) {
+        if (routes.has(method))
+            throw new Error(`${method} ${path} is defined twice`);
+        routes.set(method, route);
+    }
+    match(method, path) {
+        let segments;
+        try {
+            segments = splitPath(path).map(decodeURIComponent);
+        }
+        catch {
+            return { kind: "none" };
+        }
+        const hit = this.walk(this.root, segments, 0, {});
+        if (!hit)
+            return { kind: "none" };
+        const route = hit.routes.get(method) ?? (method === "HEAD" ? hit.routes.get("GET") : undefined);
+        if (route)
+            return { kind: "found", route, params: hit.params };
+        const allow = [...hit.routes.keys()];
+        if (allow.includes("GET"))
+            allow.push("HEAD");
+        return { kind: "method", allow };
+    }
+    walk(n, segs, i, params) {
+        if (i === segs.length) {
+            if (n.routes.size)
+                return { routes: n.routes, params };
+            if (n.wildcard)
+                return { routes: n.wildcard.routes, params: { ...params, [n.wildcard.name]: "" } };
+            return undefined;
+        }
+        const s = n.statics.get(segs[i]);
+        if (s) {
+            const hit = this.walk(s, segs, i + 1, params);
+            if (hit)
+                return hit;
+        }
+        if (n.param) {
+            const hit = this.walk(n.param.node, segs, i + 1, { ...params, [n.param.name]: segs[i] });
+            if (hit)
+                return hit;
+        }
+        if (n.wildcard)
+            return { routes: n.wildcard.routes, params: { ...params, [n.wildcard.name]: segs.slice(i).join("/") } };
+        return undefined;
+    }
+}

package/dist/schema.d.ts

@@ -0,0 +1,185 @@
+export type Issue = {
+    path: string;
+    message: string;
+};
+export type JsonSchema = Record<string, unknown>;
+export type SafeResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    issues: Issue[];
+};
+export declare class ValidationError extends Error {
+    issues: Issue[];
+    constructor(issues: Issue[]);
+}
+/** Collects component schemas while a document is written. */
+export type RefContext = {
+    components: Map<string, JsonSchema>;
+};
+declare const FAIL: unique symbol;
+type Fail = typeof FAIL;
+type Meta = {
+    description?: string;
+    examples?: unknown[];
+    optional?: boolean;
+    nullable?: boolean;
+    hasDefault?: boolean;
+    default?: unknown;
+    name?: string;
+    deprecated?: boolean;
+};
+export declare abstract class Schema<T = unknown> {
+    readonly _type: T;
+    meta: Meta;
+    protected abstract check(value: unknown, path: string, coerce: boolean, issues: Issue[]): T | Fail;
+    protected abstract json(ctx?: RefContext): JsonSchema;
+    /** @internal */
+    _run(value: unknown, path: string, coerce: boolean, issues: Issue[]): T | Fail;
+    /** @internal */
+    _schema(ctx?: RefContext): JsonSchema;
+    private decorate;
+    protected clone(patch?: Partial<Meta>): this;
+    optional(): Schema<T | undefined>;
+    nullable(): Schema<T | null>;
+    /** The value used when the field is missing. The field becomes optional for callers. */
+    default(value: Exclude<T, undefined>): Schema<Exclude<T, undefined>>;
+    describe(description: string): this;
+    example(...examples: T[]): this;
+    deprecated(): this;
+    /** Names the schema, so OpenAPI lists it once under components and refers to it. */
+    named(name: string): this;
+    parse(value: unknown, opts?: {
+        coerce?: boolean;
+    }): T;
+    safeParse(value: unknown, opts?: {
+        coerce?: boolean;
+    }): SafeResult<T>;
+    toJSONSchema(): JsonSchema;
+}
+export type Infer<S> = S extends Schema<infer T> ? T : never;
+export type StringFormat = "email" | "uuid" | "date-time" | "date" | "uri";
+export declare class StringSchema extends Schema<string> {
+    private rules;
+    min(n: number): this;
+    max(n: number): this;
+    pattern(re: RegExp): this;
+    format(f: StringFormat): this;
+    email(): this;
+    uuid(): this;
+    /** Trims whitespace before the other rules run. */
+    trim(): this;
+    protected check(v: unknown, path: string, _coerce: boolean, issues: Issue[]): string | typeof FAIL;
+    protected json(): JsonSchema;
+}
+export declare class NumberSchema extends Schema<number> {
+    private rules;
+    constructor(int?: boolean);
+    min(n: number): this;
+    max(n: number): this;
+    positive(): this;
+    protected check(v: unknown, path: string, coerce: boolean, issues: Issue[]): number | typeof FAIL;
+    protected json(): JsonSchema;
+}
+export declare class BooleanSchema extends Schema<boolean> {
+    protected check(v: unknown, path: string, coerce: boolean, issues: Issue[]): boolean | typeof FAIL;
+    protected json(): {
+        type: string;
+    };
+}
+export declare class EnumSchema<const V extends string | number | boolean> extends Schema<V> {
+    values: readonly V[];
+    constructor(values: readonly V[]);
+    protected check(v: unknown, path: string, coerce: boolean, issues: Issue[]): typeof FAIL | V;
+    protected json(): {
+        const: V;
+        enum?: undefined;
+    } | {
+        const?: undefined;
+        enum: V[];
+    };
+}
+export declare class AnySchema<T = unknown> extends Schema<T> {
+    protected check(v: unknown): T;
+    protected json(): {};
+}
+export declare class ArraySchema<S extends Schema<any>> extends Schema<Infer<S>[]> {
+    item: S;
+    private rules;
+    constructor(item: S);
+    min(n: number): this;
+    max(n: number): this;
+    protected check(v: unknown, path: string, coerce: boolean, issues: Issue[]): typeof FAIL | Infer<S>[];
+    protected json(ctx?: RefContext): JsonSchema;
+}
+export type Shape = Record<string, Schema<any>>;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type OptionalKeys<S extends Shape> = {
+    [K in keyof S]: undefined extends Infer<S[K]> ? K : never;
+}[keyof S];
+export type InferShape<S extends Shape> = Simplify<{
+    [K in Exclude<keyof S, OptionalKeys<S>>]: Infer<S[K]>;
+} & {
+    [K in OptionalKeys<S>]?: Infer<S[K]>;
+}>;
+export declare class ObjectSchema<S extends Shape> extends Schema<InferShape<S>> {
+    shape: S;
+    private unknownKeys;
+    constructor(shape: S);
+    /** Unknown keys become an error instead of being dropped. */
+    strict(): this;
+    /** Unknown keys are kept as they are. */
+    passthrough(): this;
+    extend<E extends Shape>(more: E): ObjectSchema<Simplify<Omit<S, keyof E> & E>>;
+    pick<K extends keyof S>(...keys: K[]): ObjectSchema<Pick<S, K>>;
+    omit<K extends keyof S>(...keys: K[]): ObjectSchema<Omit<S, K>>;
+    partial(): ObjectSchema<{
+        [K in keyof S]: Schema<Infer<S[K]> | undefined>;
+    }>;
+    protected check(v: unknown, path: string, coerce: boolean, issues: Issue[]): typeof FAIL | ({ [K in Exclude<keyof S, OptionalKeys<S>>]: Infer<S[K]>; } & { [K in OptionalKeys<S>]?: Infer<S[K]> | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never);
+    protected json(ctx?: RefContext): JsonSchema;
+}
+export declare class RecordSchema<S extends Schema<any>> extends Schema<Record<string, Infer<S>>> {
+    value: S;
+    constructor(value: S);
+    protected check(v: unknown, path: string, coerce: boolean, issues: Issue[]): typeof FAIL | Record<string, Infer<S>>;
+    protected json(ctx?: RefContext): {
+        type: string;
+        additionalProperties: JsonSchema;
+    };
+}
+export declare class UnionSchema<S extends Schema<any>[]> extends Schema<Infer<S[number]>> {
+    options: S;
+    constructor(options: S);
+    protected check(v: unknown, path: string, coerce: boolean, issues: Issue[]): any;
+    protected json(ctx?: RefContext): {
+        anyOf: JsonSchema[];
+    };
+}
+export declare const t: {
+    string: () => StringSchema;
+    number: () => NumberSchema;
+    int: () => NumberSchema;
+    boolean: () => BooleanSchema;
+    literal: <const V extends string | number | boolean>(value: V) => EnumSchema<V>;
+    enum: <const V extends string | number | boolean>(values: readonly V[]) => EnumSchema<V>;
+    array: <S extends Schema<any>>(item: S) => ArraySchema<S>;
+    object: <S extends Shape>(shape: S) => ObjectSchema<S>;
+    record: <S extends Schema<any>>(value: S) => RecordSchema<S>;
+    union: <S extends Schema<any>[]>(...options: S) => UnionSchema<S>;
+    any: <T = unknown>() => AnySchema<T>;
+    /** No body at all, for a 204. */
+    empty: () => Schema<undefined>;
+    /** An RFC 9457 problem document, the shape every inkan error has. */
+    problem: () => ObjectSchema<{
+        type: StringSchema;
+        title: StringSchema;
+        status: NumberSchema;
+        detail: Schema<string | undefined>;
+        instance: Schema<string | undefined>;
+    }>;
+};
+export {};

package/dist/schema.js

@@ -0,0 +1,398 @@
+// A small schema builder. One definition gives you a runtime check,
+// a TypeScript type and a JSON Schema, so they cannot drift apart.
+export class ValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super(issues.map((i) => (i.path ? `${i.path}: ${i.message}` : i.message)).join("; "));
+        this.name = "ValidationError";
+        this.issues = issues;
+    }
+}
+const FAIL = Symbol("fail");
+export class Schema {
+    meta = {};
+    /** @internal */
+    _run(value, path, coerce, issues) {
+        if (value === undefined) {
+            if (this.meta.hasDefault)
+                return structuredClone(this.meta.default);
+            if (this.meta.optional)
+                return undefined;
+            issues.push({ path, message: "is required" });
+            return FAIL;
+        }
+        if (value === null && this.meta.nullable)
+            return null;
+        return this.check(value, path, coerce, issues);
+    }
+    /** @internal */
+    _schema(ctx) {
+        if (ctx && this.meta.name) {
+            if (!ctx.components.has(this.meta.name)) {
+                ctx.components.set(this.meta.name, {}); // reserve first, so recursive shapes terminate
+                ctx.components.set(this.meta.name, this.decorate(this.json(ctx)));
+            }
+            const ref = { $ref: `#/components/schemas/${this.meta.name}` };
+            return this.meta.nullable ? { anyOf: [ref, { type: "null" }] } : ref;
+        }
+        const out = this.decorate(this.json(ctx));
+        return this.meta.nullable ? { anyOf: [out, { type: "null" }] } : out;
+    }
+    decorate(s) {
+        const out = { ...s };
+        if (this.meta.description)
+            out.description = this.meta.description;
+        if (this.meta.examples)
+            out.examples = this.meta.examples;
+        if (this.meta.hasDefault)
+            out.default = this.meta.default;
+        if (this.meta.deprecated)
+            out.deprecated = true;
+        return out;
+    }
+    clone(patch = {}) {
+        const copy = Object.create(Object.getPrototypeOf(this));
+        Object.assign(copy, this);
+        copy.meta = { ...this.meta, ...patch };
+        return copy;
+    }
+    optional() {
+        return this.clone({ optional: true });
+    }
+    nullable() {
+        return this.clone({ nullable: true });
+    }
+    /** The value used when the field is missing. The field becomes optional for callers. */
+    default(value) {
+        return this.clone({ hasDefault: true, default: value });
+    }
+    describe(description) {
+        return this.clone({ description });
+    }
+    example(...examples) {
+        return this.clone({ examples });
+    }
+    deprecated() {
+        return this.clone({ deprecated: true });
+    }
+    /** Names the schema, so OpenAPI lists it once under components and refers to it. */
+    named(name) {
+        return this.clone({ name });
+    }
+    parse(value, opts = {}) {
+        const r = this.safeParse(value, opts);
+        if (!r.ok)
+            throw new ValidationError(r.issues);
+        return r.value;
+    }
+    safeParse(value, opts = {}) {
+        const issues = [];
+        const out = this._run(value, "", opts.coerce ?? false, issues);
+        if (out === FAIL || issues.length)
+            return { ok: false, issues };
+        return { ok: true, value: out };
+    }
+    toJSONSchema() {
+        return this._schema();
+    }
+}
+const typeOf = (v) => (v === null ? "null" : Array.isArray(v) ? "array" : typeof v);
+// ---------- primitives ----------
+const FORMATS = {
+    email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+    uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+    "date-time": /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/,
+    date: /^\d{4}-\d{2}-\d{2}$/,
+    uri: /^[a-z][a-z0-9+.-]*:\/\/\S+$/i,
+};
+export class StringSchema extends Schema {
+    rules = {};
+    min(n) { const c = this.clone(); c.rules = { ...this.rules, min: n }; return c; }
+    max(n) { const c = this.clone(); c.rules = { ...this.rules, max: n }; return c; }
+    pattern(re) { const c = this.clone(); c.rules = { ...this.rules, pattern: re }; return c; }
+    format(f) { const c = this.clone(); c.rules = { ...this.rules, format: f }; return c; }
+    email() { return this.format("email"); }
+    uuid() { return this.format("uuid"); }
+    /** Trims whitespace before the other rules run. */
+    trim() { const c = this.clone(); c.rules = { ...this.rules, trim: true }; return c; }
+    check(v, path, _coerce, issues) {
+        if (typeof v !== "string") {
+            issues.push({ path, message: `expected a string, got ${typeOf(v)}` });
+            return FAIL;
+        }
+        const s = this.rules.trim ? v.trim() : v;
+        const { min, max, pattern, format } = this.rules;
+        if (min !== undefined && s.length < min)
+            issues.push({ path, message: `must be at least ${min} characters` });
+        if (max !== undefined && s.length > max)
+            issues.push({ path, message: `must be at most ${max} characters` });
+        if (pattern && !pattern.test(s))
+            issues.push({ path, message: `must match ${pattern}` });
+        if (format && !FORMATS[format].test(s))
+            issues.push({ path, message: `must be a valid ${format}` });
+        return s;
+    }
+    json() {
+        const { min, max, pattern, format } = this.rules;
+        const s = { type: "string" };
+        if (min !== undefined)
+            s.minLength = min;
+        if (max !== undefined)
+            s.maxLength = max;
+        if (pattern)
+            s.pattern = pattern.source;
+        if (format)
+            s.format = format;
+        return s;
+    }
+}
+export class NumberSchema extends Schema {
+    rules = {};
+    constructor(int = false) {
+        super();
+        this.rules.int = int;
+    }
+    min(n) { const c = this.clone(); c.rules = { ...this.rules, min: n }; return c; }
+    max(n) { const c = this.clone(); c.rules = { ...this.rules, max: n }; return c; }
+    positive() { return this.min(this.rules.int ? 1 : Number.MIN_VALUE); }
+    check(v, path, coerce, issues) {
+        let n = v;
+        if (coerce && typeof v === "string" && v.trim() !== "")
+            n = Number(v);
+        const kind = this.rules.int ? "an integer" : "a number";
+        if (typeof n !== "number" || Number.isNaN(n) || !Number.isFinite(n)) {
+            issues.push({ path, message: `expected ${kind}, got ${typeof v === "string" ? JSON.stringify(v) : typeOf(v)}` });
+            return FAIL;
+        }
+        if (this.rules.int && !Number.isInteger(n)) {
+            issues.push({ path, message: `expected an integer, got ${n}` });
+            return FAIL;
+        }
+        const { min, max } = this.rules;
+        if (min !== undefined && n < min)
+            issues.push({ path, message: `must be ${min} or more` });
+        if (max !== undefined && n > max)
+            issues.push({ path, message: `must be ${max} or less` });
+        return n;
+    }
+    json() {
+        const s = { type: this.rules.int ? "integer" : "number" };
+        if (this.rules.min !== undefined)
+            s.minimum = this.rules.min;
+        if (this.rules.max !== undefined)
+            s.maximum = this.rules.max;
+        return s;
+    }
+}
+export class BooleanSchema extends Schema {
+    check(v, path, coerce, issues) {
+        if (typeof v === "boolean")
+            return v;
+        if (coerce && typeof v === "string") {
+            if (v === "true" || v === "1" || v === "")
+                return true;
+            if (v === "false" || v === "0")
+                return false;
+        }
+        issues.push({ path, message: `expected a boolean, got ${typeOf(v)}` });
+        return FAIL;
+    }
+    json() {
+        return { type: "boolean" };
+    }
+}
+export class EnumSchema extends Schema {
+    values;
+    constructor(values) {
+        super();
+        this.values = values;
+    }
+    check(v, path, coerce, issues) {
+        const hit = this.values.find((x) => x === v || (coerce && typeof v === "string" && String(x) === v));
+        if (hit === undefined) {
+            issues.push({ path, message: `must be one of ${this.values.map((x) => JSON.stringify(x)).join(", ")}` });
+            return FAIL;
+        }
+        return hit;
+    }
+    json() {
+        return this.values.length === 1 ? { const: this.values[0] } : { enum: [...this.values] };
+    }
+}
+export class AnySchema extends Schema {
+    check(v) {
+        return v;
+    }
+    json() {
+        return {};
+    }
+}
+// ---------- composites ----------
+export class ArraySchema extends Schema {
+    item;
+    rules = {};
+    constructor(item) {
+        super();
+        this.item = item;
+    }
+    min(n) { const c = this.clone(); c.rules = { ...this.rules, min: n }; return c; }
+    max(n) { const c = this.clone(); c.rules = { ...this.rules, max: n }; return c; }
+    check(v, path, coerce, issues) {
+        // ?tag=a reads as "a", ?tag=a&tag=b as ["a","b"]: both are a list here.
+        const list = coerce && !Array.isArray(v) ? [v] : v;
+        if (!Array.isArray(list)) {
+            issues.push({ path, message: `expected an array, got ${typeOf(v)}` });
+            return FAIL;
+        }
+        const { min, max } = this.rules;
+        if (min !== undefined && list.length < min)
+            issues.push({ path, message: `must have at least ${min} items` });
+        if (max !== undefined && list.length > max)
+            issues.push({ path, message: `must have at most ${max} items` });
+        const out = [];
+        list.forEach((x, i) => {
+            const r = this.item._run(x, `${path}[${i}]`, coerce, issues);
+            if (r !== FAIL)
+                out.push(r);
+        });
+        return out;
+    }
+    json(ctx) {
+        const s = { type: "array", items: this.item._schema(ctx) };
+        if (this.rules.min !== undefined)
+            s.minItems = this.rules.min;
+        if (this.rules.max !== undefined)
+            s.maxItems = this.rules.max;
+        return s;
+    }
+}
+export class ObjectSchema extends Schema {
+    shape;
+    unknownKeys = "strip";
+    constructor(shape) {
+        super();
+        this.shape = shape;
+    }
+    /** Unknown keys become an error instead of being dropped. */
+    strict() { const c = this.clone(); c.unknownKeys = "strict"; return c; }
+    /** Unknown keys are kept as they are. */
+    passthrough() { const c = this.clone(); c.unknownKeys = "keep"; return c; }
+    extend(more) {
+        return new ObjectSchema({ ...this.shape, ...more });
+    }
+    pick(...keys) {
+        return new ObjectSchema(Object.fromEntries(keys.map((k) => [k, this.shape[k]])));
+    }
+    omit(...keys) {
+        const s = { ...this.shape };
+        for (const k of keys)
+            delete s[k];
+        return new ObjectSchema(s);
+    }
+    partial() {
+        return new ObjectSchema(Object.fromEntries(Object.entries(this.shape).map(([k, s]) => [k, s.optional()])));
+    }
+    check(v, path, coerce, issues) {
+        if (typeof v !== "object" || v === null || Array.isArray(v)) {
+            issues.push({ path, message: `expected an object, got ${typeOf(v)}` });
+            return FAIL;
+        }
+        const input = v;
+        const out = this.unknownKeys === "keep" ? { ...input } : {};
+        for (const [key, schema] of Object.entries(this.shape)) {
+            const r = schema._run(input[key], path ? `${path}.${key}` : key, coerce, issues);
+            if (r !== FAIL && r !== undefined)
+                out[key] = r;
+        }
+        if (this.unknownKeys === "strict") {
+            for (const key of Object.keys(input)) {
+                if (!(key in this.shape))
+                    issues.push({ path: path ? `${path}.${key}` : key, message: "is not allowed" });
+            }
+        }
+        return out;
+    }
+    json(ctx) {
+        const properties = {};
+        const required = [];
+        for (const [key, schema] of Object.entries(this.shape)) {
+            properties[key] = schema._schema(ctx);
+            if (!schema.meta.optional && !schema.meta.hasDefault)
+                required.push(key);
+        }
+        const s = { type: "object", properties };
+        if (required.length)
+            s.required = required;
+        if (this.unknownKeys === "strict")
+            s.additionalProperties = false;
+        return s;
+    }
+}
+export class RecordSchema extends Schema {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    check(v, path, coerce, issues) {
+        if (typeof v !== "object" || v === null || Array.isArray(v)) {
+            issues.push({ path, message: `expected an object, got ${typeOf(v)}` });
+            return FAIL;
+        }
+        const out = {};
+        for (const [k, x] of Object.entries(v)) {
+            const r = this.value._run(x, path ? `${path}.${k}` : k, coerce, issues);
+            if (r !== FAIL)
+                out[k] = r;
+        }
+        return out;
+    }
+    json(ctx) {
+        return { type: "object", additionalProperties: this.value._schema(ctx) };
+    }
+}
+export class UnionSchema extends Schema {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    check(v, path, coerce, issues) {
+        for (const option of this.options) {
+            const local = [];
+            const r = option._run(v, path, coerce, local);
+            if (r !== FAIL && local.length === 0)
+                return r;
+        }
+        issues.push({ path, message: "matches none of the allowed shapes" });
+        return FAIL;
+    }
+    json(ctx) {
+        return { anyOf: this.options.map((o) => o._schema(ctx)) };
+    }
+}
+// ---------- the builder ----------
+const problemShape = {
+    type: new StringSchema().describe("A stable code for this kind of problem"),
+    title: new StringSchema(),
+    status: new NumberSchema(true),
+    detail: new StringSchema().optional(),
+    instance: new StringSchema().optional(),
+};
+export const t = {
+    string: () => new StringSchema(),
+    number: () => new NumberSchema(false),
+    int: () => new NumberSchema(true),
+    boolean: () => new BooleanSchema(),
+    literal: (value) => new EnumSchema([value]),
+    enum: (values) => new EnumSchema(values),
+    array: (item) => new ArraySchema(item),
+    object: (shape) => new ObjectSchema(shape),
+    record: (value) => new RecordSchema(value),
+    union: (...options) => new UnionSchema(options),
+    any: () => new AnySchema(),
+    /** No body at all, for a 204. */
+    empty: () => new AnySchema().optional().describe("No content"),
+    /** An RFC 9457 problem document, the shape every inkan error has. */
+    problem: () => new ObjectSchema(problemShape).passthrough().named("Problem").describe("An RFC 9457 problem document"),
+};