@getaster/elements 0.0.0-stage → 0.1.0-preview.1

package/dist/composition/definition.js

@@ -0,0 +1,291 @@
+export class CompositeError extends Error {
+    path;
+    constructor(path, message) {
+        super(`${path}: ${message}`);
+        this.path = path;
+        this.name = "CompositeError";
+    }
+}
+export function located(error, sources = {}) {
+    if (!(error instanceof CompositeError))
+        return error instanceof Error ? error : new Error(String(error));
+    let path = error.path;
+    while (path && !sources[path])
+        path = path.includes(".") ? path.slice(0, path.lastIndexOf(".")) : "";
+    const at = sources[path];
+    return at ? new Error(`${at.file}:${at.line}:${at.column}: ${error.message}`, { cause: error }) : error;
+}
+export function record(value, path) {
+    if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+        throw new CompositeError(path, "expected a mapping");
+    return value;
+}
+export function keys(value, allowed, path) {
+    for (const key of Object.keys(value))
+        if (!allowed.includes(key))
+            throw new CompositeError(`${path}.${key}`, "unknown property");
+}
+export function name(value, path) {
+    if (typeof value !== "string" || !/^[a-zA-Z][\w-]*$/.test(value) || ["constructor", "prototype", "__proto__"].includes(value))
+        throw new CompositeError(path, "expected a safe name");
+}
+function text(value, path) {
+    if (typeof value !== "string" || !value.length)
+        throw new CompositeError(path, "expected text");
+}
+function condition(value, path) {
+    if (typeof value === "string") {
+        text(value, path);
+        return;
+    }
+    const entry = record(value, path);
+    switch (entry.op) {
+        case "and":
+        case "or":
+            keys(entry, ["op", "args"], path);
+            if (!Array.isArray(entry.args))
+                throw new CompositeError(`${path}.args`, "expected an array");
+            entry.args.forEach((arg, i) => condition(arg, `${path}.args.${i}`));
+            return;
+        case "not":
+            keys(entry, ["op", "arg"], path);
+            condition(entry.arg, `${path}.arg`);
+            return;
+        case "eq":
+        case "ne":
+        case "gt":
+        case "ge":
+        case "lt":
+        case "le":
+            keys(entry, ["op", "field", "value", "other"], path);
+            text(entry.field, `${path}.field`);
+            if (Object.hasOwn(entry, "value") === Object.hasOwn(entry, "other"))
+                throw new CompositeError(path, "comparison needs exactly one value or other path");
+            if (entry.other !== undefined)
+                text(entry.other, `${path}.other`);
+            return;
+        case "contains":
+        case "startswith":
+        case "endswith":
+            keys(entry, ["op", "field", "value", "caseInsensitive"], path);
+            text(entry.field, `${path}.field`);
+            if (typeof entry.value !== "string")
+                throw new CompositeError(`${path}.value`, "expected text");
+            if (entry.caseInsensitive !== undefined && typeof entry.caseInsensitive !== "boolean")
+                throw new CompositeError(path, "caseInsensitive must be boolean");
+            return;
+        case "in":
+            keys(entry, ["op", "field", "values"], path);
+            text(entry.field, `${path}.field`);
+            if (!Array.isArray(entry.values))
+                throw new CompositeError(`${path}.values`, "expected an array");
+            return;
+        case "any":
+        case "all":
+        case "via":
+            keys(entry, ["op", "field", "where"], path);
+            text(entry.field, `${path}.field`);
+            if (typeof entry.where === "string")
+                throw new CompositeError(`${path}.where`, "related criteria require an explicit comparison");
+            condition(entry.where, `${path}.where`);
+            return;
+        default: throw new CompositeError(`${path}.op`, "unknown rule operator");
+    }
+}
+export function defineComposite(value) {
+    let nodes = 0;
+    const seen = new Set();
+    function json(v, path, depth) {
+        if (++nodes > 10000 || depth > 40)
+            throw new CompositeError(path, "definition exceeds size/depth limit");
+        if (v === null || typeof v === "string" || typeof v === "boolean")
+            return;
+        if (typeof v === "number" && Number.isFinite(v) && Math.abs(v) <= Number.MAX_SAFE_INTEGER)
+            return;
+        if (!v || typeof v !== "object")
+            throw new CompositeError(path, "expected JSON-compatible data");
+        if (seen.has(v))
+            throw new CompositeError(path, "cyclic objects are not supported");
+        seen.add(v);
+        if (Array.isArray(v))
+            v.forEach((item, i) => json(item, `${path}.${i}`, depth + 1));
+        else
+            for (const [key, item] of Object.entries(record(v, path))) {
+                if (["__proto__", "prototype", "constructor", "<<"].includes(key))
+                    throw new CompositeError(`${path}.${key}`, "unsafe key");
+                json(item, `${path}.${key}`, depth + 1);
+            }
+        seen.delete(v);
+    }
+    json(value, "definition", 0);
+    const d = record(value, "definition");
+    keys(d, ["version", "name", "model", "publish", "commands", "children", "layout", "customize"], "definition");
+    if (d.version !== 1)
+        throw new CompositeError("definition.version", "unsupported version");
+    name(d.name, "definition.name");
+    const model = record(d.model, "definition.model");
+    keys(model, ["type", "inputs"], "definition.model");
+    name(model.type, "definition.model.type");
+    if (model.inputs !== undefined)
+        record(model.inputs, "definition.model.inputs");
+    for (const [key, item] of Object.entries(record(d.publish ?? {}, "definition.publish"))) {
+        name(key, `definition.publish.${key}`);
+        const entry = record(item, `definition.publish.${key}`);
+        keys(entry, ["ref"], `definition.publish.${key}`);
+        text(entry.ref, `definition.publish.${key}.ref`);
+    }
+    for (const [key, item] of Object.entries(record(d.commands ?? {}, "definition.commands"))) {
+        name(key, `definition.commands.${key}`);
+        const path = `definition.commands.${key}`;
+        const entry = record(item, path);
+        keys(entry, ["use", "enabledWhen", "reason"], path);
+        text(entry.use, `${path}.use`);
+        if (entry.enabledWhen !== undefined)
+            condition(entry.enabledWhen, `${path}.enabledWhen`);
+        if (entry.reason !== undefined)
+            text(entry.reason, `${path}.reason`);
+    }
+    const children = record(d.children, "definition.children");
+    for (const [key, item] of Object.entries(children)) {
+        name(key, `definition.children.${key}`);
+        const path = `definition.children.${key}`;
+        const entry = record(item, path);
+        keys(entry, ["type", "props", "create", "retain", "enabled"], path);
+        name(entry.type, `${path}.type`);
+        if (entry.props !== undefined)
+            record(entry.props, `${path}.props`);
+        if (entry.create !== undefined && entry.create !== "eager" && entry.create !== "on-demand")
+            throw new CompositeError(`${path}.create`, "expected eager or on-demand");
+        if (entry.retain !== undefined && typeof entry.retain !== "boolean")
+            throw new CompositeError(`${path}.retain`, "expected boolean");
+        if (entry.enabled !== undefined && typeof entry.enabled !== "boolean")
+            throw new CompositeError(`${path}.enabled`, "expected boolean");
+    }
+    function names(v, path) {
+        if (!Array.isArray(v))
+            throw new CompositeError(path, "expected an array of names");
+        v.forEach((item, i) => name(item, `${path}.${i}`));
+    }
+    if (d.customize !== undefined) {
+        const c = record(d.customize, "definition.customize");
+        keys(c, ["children", "modelInputs", "layout"], "definition.customize");
+        if (c.layout !== undefined && typeof c.layout !== "boolean")
+            throw new CompositeError("definition.customize.layout", "expected boolean");
+        if (c.modelInputs !== undefined) {
+            names(c.modelInputs, "definition.customize.modelInputs");
+            for (const key of c.modelInputs)
+                if (!Object.hasOwn(model.inputs ?? {}, key))
+                    throw new CompositeError("definition.customize.modelInputs", `unknown model input '${key}'`);
+        }
+        for (const [key, value] of Object.entries(record(c.children ?? {}, "definition.customize.children"))) {
+            const path = `definition.customize.children.${key}`;
+            if (!Object.hasOwn(children, key))
+                throw new CompositeError(path, "unknown child");
+            const spec = record(value, path);
+            keys(spec, ["props", "replace", "optional", "lifecycle"], path);
+            if (spec.props !== undefined)
+                names(spec.props, `${path}.props`);
+            if (spec.replace !== undefined)
+                names(spec.replace, `${path}.replace`);
+            for (const flag of ["optional", "lifecycle"])
+                if (spec[flag] !== undefined && typeof spec[flag] !== "boolean")
+                    throw new CompositeError(`${path}.${flag}`, "expected boolean");
+        }
+    }
+    const placed = new Set();
+    function layout(v, path) {
+        const entry = record(v, path);
+        if (entry.child !== undefined) {
+            keys(entry, ["child"], path);
+            name(entry.child, `${path}.child`);
+            if (!Object.hasOwn(children, entry.child))
+                throw new CompositeError(path, `unknown child '${entry.child}'`);
+            if (placed.has(entry.child))
+                throw new CompositeError(path, `duplicate placement '${entry.child}'`);
+            placed.add(entry.child);
+            return;
+        }
+        switch (entry.type) {
+            case "stack":
+                keys(entry, ["type", "items"], path);
+                if (!Array.isArray(entry.items))
+                    throw new CompositeError(`${path}.items`, "expected an array");
+                entry.items.forEach((item, i) => layout(item, `${path}.items.${i}`));
+                break;
+            case "deck":
+                keys(entry, ["type", "active", "items"], path);
+                if (entry.active === undefined)
+                    throw new CompositeError(`${path}.active`, "required");
+                for (const [key, item] of Object.entries(record(entry.items, `${path}.items`))) {
+                    name(key, path);
+                    layout(item, `${path}.items.${key}`);
+                }
+                break;
+            case "outlet":
+                keys(entry, ["type", "active", "content"], path);
+                if (entry.active === undefined)
+                    throw new CompositeError(`${path}.active`, "required");
+                layout(entry.content, `${path}.content`);
+                break;
+            default: throw new CompositeError(path, "unknown layout type");
+        }
+    }
+    layout(d.layout, "definition.layout");
+    for (const key of Object.keys(children))
+        if (!placed.has(key))
+            throw new CompositeError(`definition.children.${key}`, "child has no placement");
+    // Detach caller-owned objects and freeze every level of the public definition.
+    const copy = JSON.parse(JSON.stringify(value));
+    const normalized = copy.customize?.children ? { ...copy, customize: { ...copy.customize,
+            children: Object.fromEntries(Object.entries(copy.customize.children).map(([key, spec]) => [key, spec.replace ? { ...spec, replace: [...new Set([copy.children[key].type, ...spec.replace])] } : spec])),
+        } } : copy;
+    function freeze(v) {
+        if (!v || typeof v !== "object")
+            return;
+        Object.values(v).forEach(freeze);
+        Object.freeze(v);
+    }
+    freeze(normalized);
+    return normalized;
+}
+/** Immutable public customization: base → derived definition → instance overrides. */
+export function deriveComposite(base, overrides) {
+    const definition = defineComposite(base);
+    const patch = record(overrides, "overrides");
+    keys(patch, ["name", "modelInputs", "children", "layout"], "overrides");
+    const customize = definition.customize;
+    const children = { ...definition.children };
+    for (const [key, value] of Object.entries(record(patch.children ?? {}, "overrides.children"))) {
+        const path = `overrides.children.${key}`;
+        const child = children[key];
+        const permission = customize?.children?.[key];
+        if (!child || !permission)
+            throw new CompositeError(path, "child is not a public customization point");
+        const next = record(value, path);
+        keys(next, ["type", "props", "enabled", "create", "retain"], path);
+        if (next.type !== undefined && next.type !== child.type && !permission.replace?.includes(String(next.type)))
+            throw new CompositeError(`${path}.type`, "replacement type is not permitted");
+        if (next.enabled !== undefined && !permission.optional)
+            throw new CompositeError(`${path}.enabled`, "child suppression is not public");
+        if ((next.create !== undefined || next.retain !== undefined) && !permission.lifecycle)
+            throw new CompositeError(path, "lifecycle policy is not public");
+        const props = record(next.props ?? {}, `${path}.props`);
+        for (const property of Object.keys(props))
+            if (!permission.props?.includes(property))
+                throw new CompositeError(`${path}.props.${property}`, "property is not public");
+        children[key] = { ...child, ...next, props: { ...child.props, ...props } };
+    }
+    const modelInputs = record(patch.modelInputs ?? {}, "overrides.modelInputs");
+    for (const key of Object.keys(modelInputs))
+        if (!customize?.modelInputs?.includes(key))
+            throw new CompositeError(`overrides.modelInputs.${key}`, "model input is not public");
+    if (patch.layout !== undefined && !customize?.layout)
+        throw new CompositeError("overrides.layout", "placement is not public");
+    return defineComposite({
+        ...definition,
+        ...(patch.name !== undefined ? { name: patch.name } : {}),
+        model: { ...definition.model, inputs: { ...definition.model.inputs, ...modelInputs } },
+        children,
+        ...(patch.layout !== undefined ? { layout: patch.layout } : {}),
+    });
+}

package/dist/composition/element.d.ts

@@ -0,0 +1,35 @@
+import { AsterElement, type View } from "../base/element.ts";
+import type { CompositeType } from "./contracts.ts";
+export interface ElementProperty<T, C extends CompositeType<T> = CompositeType<T>> {
+    readonly type: C;
+    /** Called separately for each element; mutable defaults must be newly created. */
+    readonly initial: () => T;
+    readonly description: string;
+}
+export type ElementProperties = Readonly<Record<string, ElementProperty<unknown>>>;
+export type ElementValues<P extends ElementProperties> = {
+    -readonly [K in keyof P]: P[K] extends ElementProperty<infer T> ? T : never;
+};
+export type ElementContract<P extends ElementProperties> = {
+    readonly [K in keyof P]: P[K]["type"] & {
+        readonly optional: true;
+    };
+};
+export interface DeclaredElement<P extends ElementProperties> {
+    new (): AsterElement & ElementValues<P>;
+    readonly tag: string;
+    readonly properties: P;
+    readonly contract: ElementContract<P>;
+}
+/** Declare a validated property, its per-instance default and its documentation once. */
+export declare function elementProperty<const C extends CompositeType<unknown>>(type: C, initial: () => C extends CompositeType<infer T> ? T : never, description: string): {
+    readonly type: C;
+    readonly initial: typeof initial;
+    readonly description: string;
+};
+/** Define a light-DOM element with reactive accessors and an inferred YAML contract. */
+export declare function defineElement<const P extends ElementProperties>(spec: {
+    readonly tag: string;
+    readonly properties: P;
+    readonly render: (props: Readonly<ElementValues<P>>, element: AsterElement & ElementValues<P>) => View;
+}): DeclaredElement<P>;

package/dist/composition/element.js

@@ -0,0 +1,51 @@
+import { signal } from "@preact/signals-core";
+import { AsterElement, define } from "../base/element.js";
+/** Declare a validated property, its per-instance default and its documentation once. */
+export function elementProperty(type, initial, description) {
+    return Object.freeze({ type: Object.freeze({ ...type }), initial, description });
+}
+/** Define a light-DOM element with reactive accessors and an inferred YAML contract. */
+export function defineElement(spec) {
+    const { tag, render } = spec;
+    if (customElements.get(tag))
+        throw new Error(`Element '${tag}' is already defined`);
+    const properties = Object.freeze(Object.fromEntries(Object.entries(spec.properties).map(([key, property]) => {
+        // Native DOM capabilities and lifecycle hooks cannot become YAML inputs.
+        if (key in AsterElement.prototype || ["__proto__", "prototype", "constructor"].includes(key))
+            throw new Error(`Reserved element property '${key}'`);
+        return [key, Object.freeze({ ...property, type: Object.freeze({ ...property.type }) })];
+    })));
+    const contract = Object.freeze(Object.fromEntries(Object.entries(properties).map(([key, property]) => [key,
+        Object.freeze({ ...property.type, optional: true, description: property.description }),
+    ])));
+    class Element extends AsterElement {
+        static tag = tag;
+        static properties = properties;
+        static contract = contract;
+        constructor() {
+            super();
+            for (const [key, property] of Object.entries(properties)) {
+                // Upgrade pre-definition assignments before installing our own accessors.
+                const initial = Object.hasOwn(this, key) ? Reflect.get(this, key) : property.initial();
+                const validate = (value) => {
+                    if (!property.type.validate(value))
+                        throw new TypeError(`${tag}.${key}: expected ${property.type.description ?? property.description}`);
+                };
+                validate(initial);
+                const state = signal(initial);
+                Object.defineProperty(this, key, {
+                    enumerable: true, configurable: false,
+                    get: () => state.value,
+                    set: (value) => { validate(value); state.value = value; },
+                });
+            }
+        }
+        render() {
+            const element = this;
+            return render(element, element);
+        }
+    }
+    // Accessors belong to each newly constructed instance; existing prototypes are untouched.
+    define(tag, Element);
+    return Element;
+}

package/dist/composition/registry.d.ts

@@ -0,0 +1,83 @@
+import type { Command, Lifetime, PageScope, Publication, SessionActivity } from "@getaster/data";
+export type CompositeValues = Readonly<Record<string, unknown>>;
+export interface CompositeProperty {
+    readonly validate: (value: unknown) => boolean;
+    readonly optional?: boolean;
+    readonly description?: string;
+    readonly schema?: Readonly<Record<string, unknown>>;
+}
+export type CompositeContract = Readonly<Record<string, CompositeProperty>>;
+export declare function snapshotContract<C extends CompositeContract>(contract: C): C;
+export declare function checkContract(values: CompositeValues, contract: CompositeContract, path: string): void;
+export interface CompositeModel {
+    readonly values: CompositeValues;
+    readonly publications?: Readonly<Record<string, Publication>>;
+    readonly commands?: Readonly<Record<string, Command>>;
+}
+export interface CompositeModelType {
+    readonly inputs: CompositeContract;
+    readonly exports: CompositeContract;
+    readonly commands?: CompositeContract;
+    readonly publications?: CompositeContract;
+    /** Register owned work with lifetime; inputs are borrowed. */
+    readonly create: (inputs: CompositeValues, lifetime: Lifetime, activity?: SessionActivity) => CompositeModel;
+}
+export interface CompositeMount {
+    readonly activity?: SessionActivity;
+    readonly props: CompositeValues;
+    readonly lifetime: Lifetime;
+    readonly scope: PageScope;
+}
+export interface CompositeSession {
+    readonly setActive?: (active: boolean) => void;
+    readonly canClose?: (signal: AbortSignal) => boolean | Promise<boolean>;
+    readonly element: HTMLElement;
+    readonly dispose?: () => void;
+    /** A nested composite's local namespace, preserved when it is placed. */
+    readonly scope?: PageScope;
+}
+export type CompositeFactory = (mount: CompositeMount) => CompositeSession | Promise<CompositeSession>;
+export interface CompositeComponentType {
+    /** Only these inputs may change while a keyed session retains its identity. */
+    readonly mutableInputs?: readonly string[];
+    readonly props: CompositeContract;
+    readonly create?: CompositeFactory;
+    readonly load?: () => Promise<CompositeFactory>;
+    /** Custom composites can consume props themselves; ordinary elements receive property bindings. */
+    readonly apply?: (element: HTMLElement, props: CompositeValues) => void;
+}
+export interface CompositeRenderer {
+    readonly render: (...args: never[]) => unknown;
+    readonly accepts: (property: string) => boolean;
+    readonly properties?: readonly string[];
+}
+/** Runtime lookup capabilities; registration is complete before a catalog is exposed. */
+export interface CompositeResolver<C extends CompositeContract = CompositeContract> {
+    readonly inputs: C | undefined;
+    model(name: string): CompositeModelType;
+    component(name: string): CompositeComponentType;
+    renderer(name: string): CompositeRenderer;
+    load(name: string): Promise<CompositeFactory>;
+}
+/** A host-owned allowlist; definitions can use only these capabilities. */
+export declare class CompositeRegistry {
+    #private;
+    get inputs(): CompositeContract | undefined;
+    /** Seal registrations and optionally carry a host input contract into mounting. */
+    seal(): CompositeResolver;
+    seal<const C extends CompositeContract>(inputs: C): CompositeResolver<C>;
+    model(name: string, entry?: CompositeModelType): CompositeModelType;
+    component(name: string, entry?: CompositeComponentType): CompositeComponentType;
+    renderer(name: string, entry?: CompositeRenderer): CompositeRenderer;
+    load(name: string): Promise<CompositeFactory>;
+}
+/** Adapter for existing public custom-element property APIs. */
+export declare function compositeElement<const C extends CompositeContract>(element: {
+    readonly tag: string;
+    readonly contract: C;
+}): Omit<CompositeComponentType, "props"> & {
+    readonly props: C;
+};
+export declare function compositeElement<const C extends CompositeContract>(tag: string, props: C): Omit<CompositeComponentType, "props"> & {
+    readonly props: C;
+};

package/dist/composition/registry.js

@@ -0,0 +1,99 @@
+import { CompositeError } from "./definition.js";
+export function snapshotContract(contract) {
+    const freeze = (value) => {
+        if (!value || typeof value !== "object")
+            return;
+        Object.values(value).forEach(freeze);
+        Object.freeze(value);
+    };
+    return Object.freeze(Object.fromEntries(Object.entries(contract).map(([key, field]) => {
+        const schema = structuredClone(field.schema ?? {});
+        freeze(schema);
+        return [key, Object.freeze({ ...field, schema })];
+    })));
+}
+export function checkContract(values, contract, path) {
+    for (const key of Object.keys(values))
+        if (!Object.hasOwn(contract, key))
+            throw new CompositeError(`${path}.${key}`, "unknown input/property");
+    for (const [key, spec] of Object.entries(contract)) {
+        if (!Object.hasOwn(values, key) && spec.optional)
+            continue;
+        if (!spec.validate(values[key]))
+            throw new CompositeError(`${path}.${key}`, spec.description ? `expected ${spec.description}` : "value does not match the registered contract");
+    }
+}
+/** A host-owned allowlist; definitions can use only these capabilities. */
+export class CompositeRegistry {
+    #models = new Map();
+    #components = new Map();
+    #renderers = new Map();
+    #loads = new Map();
+    #sealed = false;
+    #inputs;
+    get inputs() { return this.#inputs; }
+    seal(inputs) {
+        if (this.#sealed)
+            throw new Error("Registry is already sealed");
+        this.#inputs = inputs ? snapshotContract(inputs) : undefined;
+        this.#sealed = true;
+        return this;
+    }
+    model(name, entry) {
+        if (entry)
+            this.#add(this.#models, name, entry);
+        const value = this.#models.get(name);
+        if (!value)
+            throw new Error(`Unknown model '${name}'`);
+        return value;
+    }
+    component(name, entry) {
+        if (entry) {
+            if (!!entry.create === !!entry.load)
+                throw new Error(`Component '${name}' needs exactly one create or load factory`);
+            this.#add(this.#components, name, entry);
+        }
+        const value = this.#components.get(name);
+        if (!value)
+            throw new Error(`Unknown component '${name}'`);
+        return value;
+    }
+    renderer(name, entry) {
+        if (entry)
+            this.#add(this.#renderers, name, entry);
+        const value = this.#renderers.get(name);
+        if (!value)
+            throw new Error(`Unknown renderer '${name}'`);
+        return value;
+    }
+    load(name) {
+        const entry = this.component(name);
+        if (entry.create)
+            return Promise.resolve(entry.create);
+        let pending = this.#loads.get(name);
+        if (!pending) {
+            pending = Promise.resolve().then(() => entry.load()).catch(error => { this.#loads.delete(name); throw error; });
+            this.#loads.set(name, pending);
+        }
+        return pending;
+    }
+    #add(map, name, entry) {
+        if (this.#sealed)
+            throw new Error("Registry is sealed; declare capabilities in the catalog before creating it");
+        if (map.has(name))
+            throw new Error(`Duplicate registration '${name}'`);
+        map.set(name, entry);
+    }
+}
+export function compositeElement(element, contract) {
+    const tag = typeof element === "string" ? element : element.tag;
+    const props = typeof element === "string" ? contract : element.contract;
+    return {
+        props,
+        create: () => ({ element: document.createElement(tag) }),
+        apply: (element, values) => {
+            for (const [key, value] of Object.entries(values))
+                Reflect.set(element, key, value);
+        },
+    };
+}

package/dist/composition/schema.d.ts

@@ -0,0 +1,9 @@
+import type { CompositeProperty } from "./registry.ts";
+export type Schema = Readonly<Record<string, unknown>>;
+export declare function asSchema(value: unknown): Schema;
+export declare function schemaProperty(schema: Schema): CompositeProperty;
+export declare function matchesSchema(value: unknown, schema: Schema): boolean;
+/** Unknown/custom refinements are runtime checks; metadata cannot prove their assignability. */
+export declare function compatibility(source: Schema, target: Schema): boolean | undefined;
+/** JSON cannot express instance identity, signals or undefined as literal values. */
+export declare function literalSchema(schema: Schema): Schema;