@aventara/core 0.1.0-pilot.4 → 1.0.0-rc.1

package/dist/contracts/client-contract-structure.validator.js

@@ -1,6 +1,7 @@
 import { PROJECTION_SCOPES, WRITE_SCOPES } from "./capability.js";
 import { AVENTARA_PROTOCOL_VERSION } from "./contract-protocol.js";
 import { LIFECYCLE_TRAITS } from "./lifecycle-trait.js";
+import { REFERENCE_WRITE_LIMITS } from "./reference-write-limit.js";
 import { TRANSACTION_CAPABILITIES } from "./transaction-capability.js";
 const STRING = { is: "string" };
 const NUMBER = { is: "number" };
@@ -9,13 +10,16 @@ function literal(values) {
     return { is: "literal", values };
 }
 function list(item) {
-    return { is: "list", item, nonEmpty: false, unique: false };
+    return { is: "list", item, minimum: 0, unique: false };
 }
 function nonEmptyList(item) {
-    return { is: "list", item, nonEmpty: true, unique: false };
+    return { is: "list", item, minimum: 1, unique: false };
+}
+function pairOrMoreList(item) {
+    return { is: "list", item, minimum: 2, unique: false };
 }
 function uniqueList(item) {
-    return { is: "list", item, nonEmpty: false, unique: true };
+    return { is: "list", item, minimum: 0, unique: true };
 }
 function registry(entry) {
     return { is: "registry", entry };
@@ -92,6 +96,127 @@ const RELATION_MUTATION = union(list(literal(RELATION_MUTATION_DIRECTIVES)), obj
     directives: list(literal(RELATION_MUTATION_DIRECTIVES)),
     scopes: WRITE_SCOPE_LIST,
 }));
+const NAMED_FORMATS = [
+    "lowercase",
+    "uppercase",
+    "email",
+    "url",
+    "emoji",
+    "uuid",
+    "guid",
+    "nanoid",
+    "cuid",
+    "cuid2",
+    "ulid",
+    "xid",
+    "ksuid",
+    "datetime",
+    "date",
+    "time",
+    "duration",
+    "ipv4",
+    "ipv6",
+    "cidrv4",
+    "cidrv6",
+    "base64",
+    "base64url",
+    "json_string",
+    "e164",
+    "credit_card",
+    "iban",
+    "jwt",
+];
+const STRING_FORMAT_CHECK = union(object({
+    check: literal(["string_format"]),
+    format: literal(["regex"]),
+    pattern: object({ source: STRING, flags: STRING }),
+}), object({
+    check: literal(["string_format"]),
+    format: literal(["includes"]),
+    includes: STRING,
+}), object({
+    check: literal(["string_format"]),
+    format: literal(["starts_with"]),
+    prefix: STRING,
+}), object({
+    check: literal(["string_format"]),
+    format: literal(["ends_with"]),
+    suffix: STRING,
+}), object({
+    check: literal(["string_format"]),
+    format: literal(NAMED_FORMATS),
+}));
+const STRING_LENGTH_CHECKS = {
+    max_length: object({ check: literal(["max_length"]), maximum: NUMBER }),
+    min_length: object({ check: literal(["min_length"]), minimum: NUMBER }),
+    length_equals: object({ check: literal(["length_equals"]), length: NUMBER }),
+    string_format: STRING_FORMAT_CHECK,
+};
+const FIELD_CHECK = {
+    is: "variants",
+    key: "check",
+    arms: {
+        less_than: object({
+            check: literal(["less_than"]),
+            value: union(NUMBER, STRING),
+            inclusive: BOOLEAN,
+        }),
+        greater_than: object({
+            check: literal(["greater_than"]),
+            value: union(NUMBER, STRING),
+            inclusive: BOOLEAN,
+        }),
+        multiple_of: object({
+            check: literal(["multiple_of"]),
+            value: union(NUMBER, STRING),
+        }),
+        max_length: object({ check: literal(["max_length"]), maximum: NUMBER }, { list: literal([true]) }),
+        min_length: object({ check: literal(["min_length"]), minimum: NUMBER }, { list: literal([true]) }),
+        length_equals: STRING_LENGTH_CHECKS.length_equals,
+        string_format: STRING_FORMAT_CHECK,
+        max_size: object({ check: literal(["max_size"]), maximum: NUMBER }),
+        min_size: object({ check: literal(["min_size"]), minimum: NUMBER }),
+        size_equals: object({ check: literal(["size_equals"]), size: NUMBER }),
+    },
+};
+const JSON_STRING_CHECK = {
+    is: "variants",
+    key: "check",
+    arms: STRING_LENGTH_CHECKS,
+};
+const JSON_NUMBER_CHECK = {
+    is: "variants",
+    key: "check",
+    arms: {
+        less_than: object({
+            check: literal(["less_than"]),
+            value: NUMBER,
+            inclusive: BOOLEAN,
+        }),
+        greater_than: object({
+            check: literal(["greater_than"]),
+            value: NUMBER,
+            inclusive: BOOLEAN,
+        }),
+        multiple_of: object({ check: literal(["multiple_of"]), value: NUMBER }),
+    },
+};
+const JSON_LIST_CHECK = {
+    is: "variants",
+    key: "check",
+    arms: {
+        max_length: object({
+            check: literal(["max_length"]),
+            maximum: NUMBER,
+            list: literal([true]),
+        }),
+        min_length: object({
+            check: literal(["min_length"]),
+            minimum: NUMBER,
+            list: literal([true]),
+        }),
+    },
+};
 const SCALAR_FIELD = object({
     kind: literal(["scalar"]),
     type: union(object({ scalar: STRING }), object({ enum: STRING })),
@@ -106,7 +231,11 @@ const SCALAR_FIELD = object({
         create: list(literal(SCALAR_MUTATION_DIRECTIVES)),
         update: list(literal(SCALAR_MUTATION_DIRECTIVES)),
     }),
-}, { format: STRING });
+}, {
+    format: STRING,
+    json: { is: "jsonSchema" },
+    validators: list(FIELD_CHECK),
+});
 const RELATION_FIELD = object({
     kind: literal(["relation"]),
     target: STRING,
@@ -124,6 +253,7 @@ const RELATION_FIELD = object({
         })),
         create: RELATION_MUTATION,
         update: RELATION_MUTATION,
+        nestedWriteFilter: literal(["scalar"]),
     }),
 });
 const OPERATION_AVAILABILITY = union(literal([true]), object({ projection: literal(PROJECTION_SCOPES) }, { write: literal(WRITE_SCOPES) }), object({ write: literal(WRITE_SCOPES) }, { projection: literal(PROJECTION_SCOPES) }));
@@ -160,6 +290,12 @@ const RESOURCE = object({
         }),
         upsert: object({}, { unique: OPERATION_AVAILABILITY }),
     }),
+}, {
+    createRequirements: object({}, {
+        required: nonEmptyList(STRING),
+        oneOf: nonEmptyList(pairOrMoreList(STRING)),
+        parentSupplies: registry(registry(nonEmptyList(STRING))),
+    }),
 });
 export const CLIENT_CONTRACT_STRUCTURE = object({
     scalars: registry(object({ builtin: literal([true]) })),
@@ -171,13 +307,14 @@ export const CLIENT_CONTRACT_STRUCTURE = object({
         maxListLimit: NUMBER,
         maxTransactionOperations: NUMBER,
         maxBooleanNodes: NUMBER,
+        maxJsonDepth: NUMBER,
     }),
     transactions: literal(TRANSACTION_CAPABILITIES),
     protocol: object({
         version: literal([AVENTARA_PROTOCOL_VERSION]),
         hash: { is: "prefixed", prefix: "sha256:" },
     }),
-});
+}, { referenceWrites: literal(REFERENCE_WRITE_LIMITS) });
 export function validateClientContractStructure(value) {
     const defect = defectOf(CLIENT_CONTRACT_STRUCTURE, value, "$", 0);
     if (defect !== undefined) {
@@ -233,6 +370,108 @@ function defectOf(node, value, path, depth) {
         }
         case "union":
             return unionDefect(node.arms, value, path, depth);
+        case "jsonSchema":
+            return jsonSchemaDefect(value, path, depth);
+    }
+}
+const JSON_SCHEMA_SCALAR_TYPES = [
+    "string",
+    "number",
+    "integer",
+    "boolean",
+    "null",
+];
+const JSON_PRIMITIVE = union(STRING, NUMBER, BOOLEAN);
+function jsonSchemaDefect(value, path, depth) {
+    const kind = kindDefect(value, "object", path, depth);
+    if (kind !== undefined)
+        return kind;
+    const schema = value;
+    const keys = Object.keys(schema).sort().join(",");
+    const child = (member, entry, at = `${path}.${member}`) => jsonSchemaDefect(entry, at, depth + 1);
+    const children = (member, minimum) => {
+        const listKind = kindDefect(schema[member], "array", `${path}.${member}`, depth + 1);
+        if (listKind !== undefined)
+            return listKind;
+        const entries = schema[member];
+        if (entries.length < minimum) {
+            return at(`${path}.${member}`, depth + 1, `needs at least ${minimum} entries`);
+        }
+        for (let index = 0; index < entries.length; index += 1) {
+            const defect = child(member, entries[index], `${path}.${member}[${index}]`);
+            if (defect !== undefined)
+                return defect;
+        }
+        return undefined;
+    };
+    switch (keys) {
+        case "type":
+            return literalDefect(JSON_SCHEMA_SCALAR_TYPES, schema.type, `${path}.type`, depth + 1);
+        case "checks,type":
+            return (literalDefect(["string", "number", "integer"], schema.type, `${path}.type`, depth + 1) ??
+                defectOf(list(schema.type === "string" ? JSON_STRING_CHECK : JSON_NUMBER_CHECK), schema.checks, `${path}.checks`, depth + 1));
+        case "checks,items,type":
+            return (literalDefect(["array"], schema.type, `${path}.type`, depth + 1) ??
+                child("items", schema.items) ??
+                defectOf(list(JSON_LIST_CHECK), schema.checks, `${path}.checks`, depth + 1));
+        case "const":
+            return Object.is(schema.const, null)
+                ? undefined
+                : defectOf(JSON_PRIMITIVE, schema.const, `${path}.const`, depth + 1);
+        case "enum,type":
+            return (literalDefect(["string"], schema.type, `${path}.type`, depth + 1) ??
+                defectOf({ is: "list", item: STRING, minimum: 1, unique: true }, schema.enum, `${path}.enum`, depth + 1));
+        case "additionalProperties,properties,type":
+        case "additionalProperties,properties,required,type": {
+            const typeDefect = literalDefect(["object"], schema.type, `${path}.type`, depth + 1) ??
+                literalDefect([false], schema.additionalProperties, `${path}.additionalProperties`, depth + 1);
+            if (typeDefect !== undefined)
+                return typeDefect;
+            const propertiesKind = kindDefect(schema.properties, "object", `${path}.properties`, depth + 1);
+            if (propertiesKind !== undefined)
+                return propertiesKind;
+            const properties = schema.properties;
+            for (const name of Object.keys(properties)) {
+                const defect = child("properties", properties[name], `${path}.properties.${name}`);
+                if (defect !== undefined)
+                    return defect;
+            }
+            if (!Object.hasOwn(schema, "required"))
+                return undefined;
+            const requiredDefect = defectOf({ is: "list", item: STRING, minimum: 0, unique: true }, schema.required, `${path}.required`, depth + 1);
+            if (requiredDefect !== undefined)
+                return requiredDefect;
+            const undeclared = schema.required.findIndex((name) => !Object.hasOwn(properties, name));
+            return undeclared === -1
+                ? undefined
+                : at(`${path}.required[${undeclared}]`, depth + 1, "names a key that is not one of the object's properties");
+        }
+        case "additionalProperties,type":
+            return (literalDefect(["object"], schema.type, `${path}.type`, depth + 1) ??
+                child("additionalProperties", schema.additionalProperties));
+        case "items,type":
+            return (literalDefect(["array"], schema.type, `${path}.type`, depth + 1) ??
+                child("items", schema.items));
+        case "items,maxItems,minItems,prefixItems,type": {
+            const defect = literalDefect(["array"], schema.type, `${path}.type`, depth + 1) ??
+                literalDefect([false], schema.items, `${path}.items`, depth + 1) ??
+                children("prefixItems", 1);
+            if (defect !== undefined)
+                return defect;
+            const length = schema.prefixItems.length;
+            for (const bound of ["minItems", "maxItems"]) {
+                if (schema[bound] !== length) {
+                    return at(`${path}.${bound}`, depth + 1, `is ${JSON.stringify(schema[bound])}, not the tuple's length ${length}`);
+                }
+            }
+            return undefined;
+        }
+        case "anyOf":
+            return children("anyOf", 2);
+        case "oneOf":
+            return children("oneOf", 1);
+        default:
+            return at(path, depth, `is not a Json Shape schema: its keywords {${keys}} are not one of the forms Aventara emits`);
     }
 }
 function literalDefect(values, value, path, depth) {
@@ -251,8 +490,10 @@ function listDefect(node, value, path, depth) {
     if (kind !== undefined)
         return kind;
     const entries = value;
-    if (node.nonEmpty && entries.length === 0) {
-        return at(path, depth, "is an empty JSON array, and needs at least one entry");
+    if (entries.length < node.minimum) {
+        return at(path, depth, entries.length === 0
+            ? `is an empty JSON array, and needs at least ${node.minimum === 1 ? "one entry" : "two entries"}`
+            : "is a JSON array of one entry, and needs at least two");
     }
     const firstIndexOf = new Map();
     for (let index = 0; index < entries.length; index += 1) {

package/dist/contracts/contract-canonicalizer.d.ts

@@ -1,11 +1,27 @@
-import type { Contract } from "./contract.js";
+import type { AvContract } from "./contract.js";
 /**
  * Thrown when a value cannot be written as canonical JSON (RFC 8785). It is a
  * `TypeError`.
  */
-export declare class CanonicalJsonError extends TypeError {
+export declare class AvCanonicalJsonError extends TypeError {
 }
 /** Canonical JSON (RFC 8785) for a JSON-safe value. */
 export declare function canonicalizeJson(value: unknown): string;
+/** One top-level member of a canonical Contract: its key and its value's canonical text. */
+export type CanonicalContractMember = {
+    readonly key: string;
+    readonly text: string;
+};
+/** The Contract as canonical JSON (RFC 8785), one top-level member at a time, in order. */
+export declare function canonicalizeContractMembers<C extends AvContract>(contract: C): readonly CanonicalContractMember[];
+/** The canonical object text the members write: `{"key":text,…}`, in their order. */
+export declare function joinCanonicalContractMembers(members: readonly CanonicalContractMember[]): string;
 /** The Contract as canonical JSON (RFC 8785): the same bytes for the same Contract. */
-export declare function canonicalizeContract<C extends Contract>(contract: C): string;
+export declare function canonicalizeContract<C extends AvContract>(contract: C): string;
+/** Records `text` as the canonical text `contract` was parsed from. */
+export declare function recordCanonicalContractText(contract: AvContract, text: string): void;
+/**
+ * The Contract's canonical text: the text it was identified from, when the compiler
+ * recorded one, else written now. Both are the same bytes for the same Contract.
+ */
+export declare function canonicalContractTextOf<C extends AvContract>(contract: C): string;

package/dist/contracts/contract-canonicalizer.js

@@ -3,7 +3,7 @@ import { LIFECYCLE_TRAITS } from "./lifecycle-trait.js";
 import { projectionScopeOf, writeScopeOf } from "./resource-operations.js";
 const PAGINATION_ORDER = ["limit", "offset", "cursor"];
 const REDUCER_ORDER = ["$count"];
-export class CanonicalJsonError extends TypeError {
+export class AvCanonicalJsonError extends TypeError {
 }
 function compareCodeUnits(left, right) {
     if (left === right) {
@@ -83,10 +83,42 @@ function normalizeCapabilities(capabilities) {
     }
     return normalized;
 }
+function normalizeJsonSchema(schema) {
+    if (Array.isArray(schema)) {
+        return schema.map(normalizeJsonSchema);
+    }
+    if (typeof schema !== "object" || schema === null) {
+        return schema;
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === "required" && Array.isArray(value)) {
+            normalized[key] = [...value].sort((left, right) => compareCodeUnits(String(left), String(right)));
+        }
+        else if (key === "properties" &&
+            typeof value === "object" &&
+            value !== null) {
+            normalized[key] = Object.fromEntries(Object.entries(value).map(([name, child]) => [
+                name,
+                normalizeJsonSchema(child),
+            ]));
+        }
+        else if (key === "const" || key === "enum" || key === "checks") {
+            normalized[key] = value;
+        }
+        else {
+            normalized[key] = normalizeJsonSchema(value);
+        }
+    }
+    return normalized;
+}
 function normalizeField(field) {
     if (field.kind === "scalar") {
         return {
             ...field,
+            ...(field.json !== undefined
+                ? { json: normalizeJsonSchema(field.json) }
+                : {}),
             lifecycle: normalizeStringSet(field.lifecycle, LIFECYCLE_TRAITS),
             capabilities: normalizeCapabilities(field.capabilities),
         };
@@ -141,8 +173,46 @@ function normalizeResource(resource) {
         fields,
         identifiers,
         operations: normalizeOperations(resource.operations),
+        ...(resource.createRequirements === undefined
+            ? {}
+            : {
+                createRequirements: normalizeCreateRequirements(resource.createRequirements),
+            }),
     };
 }
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeCreateRequirements(requirements) {
+    if (!isJsonObject(requirements)) {
+        return requirements;
+    }
+    const normalized = { ...requirements };
+    if (Array.isArray(requirements.required)) {
+        normalized.required = normalizeStringSet(requirements.required);
+    }
+    if (Array.isArray(requirements.oneOf)) {
+        normalized.oneOf = requirements.oneOf
+            .map((group) => Array.isArray(group) && group.length > 0
+            ? [group[0], ...normalizeStringSet(group.slice(1))]
+            : group)
+            .sort((left, right) => compareCodeUnits(canonicalizeJson(left), canonicalizeJson(right)));
+    }
+    if (isJsonObject(requirements.parentSupplies)) {
+        normalized.parentSupplies = Object.fromEntries(Object.entries(requirements.parentSupplies).map(([parent, byRelation]) => [
+            parent,
+            isJsonObject(byRelation)
+                ? Object.fromEntries(Object.entries(byRelation).map(([relation, members]) => [
+                    relation,
+                    Array.isArray(members)
+                        ? normalizeStringSet(members)
+                        : members,
+                ]))
+                : byRelation,
+        ]));
+    }
+    return normalized;
+}
 function normalizeContract(contract) {
     const scalars = Object.fromEntries(Object.keys(contract.scalars)
         .sort(compareCodeUnits)
@@ -169,17 +239,24 @@ function assertValidUnicode(value, path) {
         if (code >= 0xd800 && code <= 0xdbff) {
             const next = value.charCodeAt(index + 1);
             if (!(next >= 0xdc00 && next <= 0xdfff)) {
-                throw new CanonicalJsonError(`invalid Unicode surrogate at ${path}`);
+                throw new AvCanonicalJsonError(`invalid Unicode surrogate at ${path()}`);
             }
             index += 1;
             continue;
         }
         if (code >= 0xdc00 && code <= 0xdfff) {
-            throw new CanonicalJsonError(`invalid Unicode surrogate at ${path}`);
+            throw new AvCanonicalJsonError(`invalid Unicode surrogate at ${path()}`);
         }
     }
 }
-function canonicalizeValue(value, path) {
+function pathOf(link) {
+    const segments = [];
+    for (let current = link; current !== undefined; current = current.parent) {
+        segments.push(current.segment);
+    }
+    return `$${segments.reverse().join("")}`;
+}
+function canonicalizePrimitive(value, link) {
     if (value === null) {
         return "null";
     }
@@ -188,47 +265,115 @@ function canonicalizeValue(value, path) {
             return value ? "true" : "false";
         case "number": {
             if (!Number.isFinite(value)) {
-                throw new CanonicalJsonError(`non-finite number at ${path}`);
+                throw new AvCanonicalJsonError(`non-finite number at ${pathOf(link)}`);
             }
             const serialized = JSON.stringify(value);
             if (serialized === undefined) {
-                throw new CanonicalJsonError(`number at ${path} is not JSON serializable`);
+                throw new AvCanonicalJsonError(`number at ${pathOf(link)} is not JSON serializable`);
             }
             return serialized;
         }
         case "string":
-            assertValidUnicode(value, path);
+            assertValidUnicode(value, () => pathOf(link));
             return JSON.stringify(value);
         case "undefined":
-            throw new CanonicalJsonError(`undefined value at ${path}`);
+            throw new AvCanonicalJsonError(`undefined value at ${pathOf(link)}`);
         case "bigint":
         case "function":
         case "symbol":
-            throw new CanonicalJsonError(`${typeof value} value at ${path} is not JSON serializable`);
-        case "object":
-            break;
+            throw new AvCanonicalJsonError(`${typeof value} value at ${pathOf(link)} is not JSON serializable`);
+        default:
+            return undefined;
     }
-    if (Array.isArray(value)) {
-        return `[${Array.prototype.map
-            .call(value, (entry, index) => canonicalizeValue(entry, `${path}[${index}]`))
-            .join(",")}]`;
-    }
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-        throw new CanonicalJsonError(`non-plain object at ${path} is not canonical JSON`);
+}
+function canonicalizeValue(value, link = undefined) {
+    const output = [];
+    const stack = [{ kind: "value", value, link }];
+    while (stack.length > 0) {
+        const task = stack.pop();
+        if (task.kind === "text") {
+            output.push(task.text);
+            continue;
+        }
+        if (task.kind === "key") {
+            assertValidUnicode(task.key, () => `${pathOf(task.link)} key`);
+            output.push(`${JSON.stringify(task.key)}:`);
+            continue;
+        }
+        const { value: current, link } = task;
+        const primitive = canonicalizePrimitive(current, link);
+        if (primitive !== undefined) {
+            output.push(primitive);
+            continue;
+        }
+        if (Array.isArray(current)) {
+            output.push("[");
+            stack.push({ kind: "text", text: "]" });
+            for (let index = current.length - 1; index >= 0; index -= 1) {
+                if (index in current) {
+                    stack.push({
+                        kind: "value",
+                        value: current[index],
+                        link: { parent: link, segment: `[${index}]` },
+                    });
+                }
+                if (index > 0) {
+                    stack.push({ kind: "text", text: "," });
+                }
+            }
+            continue;
+        }
+        const prototype = Object.getPrototypeOf(current);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw new AvCanonicalJsonError(`non-plain object at ${pathOf(link)} is not canonical JSON`);
+        }
+        const record = current;
+        const keys = Object.keys(record).sort(compareCodeUnits);
+        output.push("{");
+        stack.push({ kind: "text", text: "}" });
+        for (let index = keys.length - 1; index >= 0; index -= 1) {
+            const key = keys[index];
+            stack.push({
+                kind: "value",
+                value: record[key],
+                link: { parent: link, segment: `.${key}` },
+            });
+            stack.push({ kind: "key", key, link });
+            if (index > 0) {
+                stack.push({ kind: "text", text: "," });
+            }
+        }
     }
-    const record = value;
-    const entries = Object.keys(record)
+    return output.join("");
+}
+export function canonicalizeJson(value) {
+    return canonicalizeValue(value);
+}
+export function canonicalizeContractMembers(contract) {
+    const record = normalizeContract(contract);
+    return Object.keys(record)
         .sort(compareCodeUnits)
         .map((key) => {
-        assertValidUnicode(key, `${path} key`);
-        return `${JSON.stringify(key)}:${canonicalizeValue(record[key], `${path}.${key}`)}`;
+        assertValidUnicode(key, () => "$ key");
+        return {
+            key,
+            text: canonicalizeValue(record[key], {
+                parent: undefined,
+                segment: `.${key}`,
+            }),
+        };
     });
-    return `{${entries.join(",")}}`;
 }
-export function canonicalizeJson(value) {
-    return canonicalizeValue(value, "$");
+export function joinCanonicalContractMembers(members) {
+    return `{${members.map(({ key, text }) => `${JSON.stringify(key)}:${text}`).join(",")}}`;
 }
 export function canonicalizeContract(contract) {
-    return canonicalizeJson(normalizeContract(contract));
+    return joinCanonicalContractMembers(canonicalizeContractMembers(contract));
+}
+const canonicalTexts = new WeakMap();
+export function recordCanonicalContractText(contract, text) {
+    canonicalTexts.set(contract, text);
+}
+export function canonicalContractTextOf(contract) {
+    return canonicalTexts.get(contract) ?? canonicalizeContract(contract);
 }

package/dist/contracts/contract-hash.d.ts

@@ -1,11 +1,16 @@
-import type { ClientContract } from "./contract.js";
-import type { ContractHash, ContractProtocol } from "./contract-protocol.js";
+import type { AvContractClient } from "./contract.js";
+import type { AvContractHash, AvContractProtocol } from "./contract-protocol.js";
 /** A ClientContract whose `protocol` does not carry the hash yet. */
-export type ClientContractHashInput = Omit<ClientContract, "protocol"> & {
-    readonly protocol: ContractProtocol;
+export type AvContractClientHashInput = Omit<AvContractClient, "protocol"> & {
+    readonly protocol: AvContractProtocol;
 };
-export declare function createClientContractHashInput(contract: ClientContract | ClientContractHashInput): ClientContractHashInput;
+export declare function createClientContractHashInput(contract: AvContractClient | AvContractClientHashInput): AvContractClientHashInput;
 /** Computes a ClientContract's `sha256:` hash, ignoring `protocol.hash` itself. */
-export declare function computeClientContractHash(contract: ClientContract | ClientContractHashInput): Promise<ContractHash>;
+export declare function computeClientContractHash(contract: AvContractClient | AvContractClientHashInput): Promise<AvContractHash>;
+/**
+ * The `sha256:` hash of a hash input's canonical text, already written: what
+ * {@link computeClientContractHash} answers for the input that text is of.
+ */
+export declare function hashCanonicalContractText(canonical: string): Promise<AvContractHash>;
 /** Whether a ClientContract's `protocol.hash` matches its content. */
-export declare function verifyClientContractHash(contract: ClientContract): Promise<boolean>;
+export declare function verifyClientContractHash(contract: AvContractClient): Promise<boolean>;

package/dist/contracts/contract-hash.js

@@ -10,8 +10,9 @@ function digestHex(digest) {
     return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 export async function computeClientContractHash(contract) {
-    const input = createClientContractHashInput(contract);
-    const canonical = canonicalizeContract(input);
+    return hashCanonicalContractText(canonicalizeContract(createClientContractHashInput(contract)));
+}
+export async function hashCanonicalContractText(canonical) {
     const bytes = new TextEncoder().encode(canonical);
     const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
     return `sha256:${digestHex(digest)}`;

package/dist/contracts/contract-limits.d.ts

@@ -1,5 +1,5 @@
 /** The request limits a Contract enforces. */
-export type ContractLimits = {
+export type AvContractLimits = {
     /** The largest request body accepted, in bytes. */
     readonly maxRequestBytes: number;
     /** How deeply arguments may nest. */
@@ -10,6 +10,8 @@ export type ContractLimits = {
     readonly maxTransactionOperations: number;
     /** The most boolean and filter nodes one request may hold. */
     readonly maxBooleanNodes: number;
+    /** How deeply a `json` field's value may nest: its arrays and objects, counted from the value. */
+    readonly maxJsonDepth: number;
 };
 /** The limits in force when the configuration sets none. */
 export declare const DEFAULT_CONTRACT_LIMITS: {
@@ -18,4 +20,5 @@ export declare const DEFAULT_CONTRACT_LIMITS: {
     readonly maxListLimit: 250;
     readonly maxTransactionOperations: 20;
     readonly maxBooleanNodes: 50;
+    readonly maxJsonDepth: 64;
 };