@aventara/core 1.0.0-rc.0 → 1.0.0-rc.1

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

@@ -10,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 };
@@ -93,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 })),
@@ -107,7 +231,11 @@ const SCALAR_FIELD = object({
         create: list(literal(SCALAR_MUTATION_DIRECTIVES)),
         update: list(literal(SCALAR_MUTATION_DIRECTIVES)),
     }),
-}, { format: STRING, json: { is: "jsonSchema" } });
+}, {
+    format: STRING,
+    json: { is: "jsonSchema" },
+    validators: list(FIELD_CHECK),
+});
 const RELATION_FIELD = object({
     kind: literal(["relation"]),
     target: STRING,
@@ -162,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]) })),
@@ -173,6 +307,7 @@ export const CLIENT_CONTRACT_STRUCTURE = object({
         maxListLimit: NUMBER,
         maxTransactionOperations: NUMBER,
         maxBooleanNodes: NUMBER,
+        maxJsonDepth: NUMBER,
     }),
     transactions: literal(TRANSACTION_CAPABILITIES),
     protocol: object({
@@ -272,13 +407,20 @@ function jsonSchemaDefect(value, path, depth) {
     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, nonEmpty: true, unique: true }, schema.enum, `${path}.enum`, 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) ??
@@ -296,7 +438,7 @@ function jsonSchemaDefect(value, path, depth) {
             }
             if (!Object.hasOwn(schema, "required"))
                 return undefined;
-            const requiredDefect = defectOf({ is: "list", item: STRING, nonEmpty: false, unique: true }, schema.required, `${path}.required`, depth + 1);
+            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));
@@ -348,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) {
@@ -103,7 +103,7 @@ function normalizeJsonSchema(schema) {
                 normalizeJsonSchema(child),
             ]));
         }
-        else if (key === "const" || key === "enum") {
+        else if (key === "const" || key === "enum" || key === "checks") {
             normalized[key] = value;
         }
         else {
@@ -173,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)
@@ -201,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";
     }
@@ -220,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;
 };

package/dist/contracts/contract-limits.js

@@ -4,4 +4,5 @@ export const DEFAULT_CONTRACT_LIMITS = {
     maxListLimit: 250,
     maxTransactionOperations: 20,
     maxBooleanNodes: 50,
+    maxJsonDepth: 64,
 };

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

@@ -1,6 +1,6 @@
-import type { Contract } from "./contract.js";
-import type { Field } from "./field.js";
-import type { Resource } from "./resource.js";
+import type { AvContract } from "./contract.js";
+import type { AvField } from "./field.js";
+import type { AvResource } from "./resource.js";
 /**
  * Own-property lookups over Contract registries.
  *
@@ -12,5 +12,5 @@ import type { Resource } from "./resource.js";
  * must go through here so an unknown key is unknown, whatever its name.
  */
 export declare function lookupOwn<T>(registry: Readonly<Record<string, T>> | undefined, key: string): T | undefined;
-export declare function lookupResource<C extends Contract>(contract: C, resourceName: string): Resource<C> | undefined;
-export declare function lookupField<C extends Contract>(resource: Resource<C> | undefined, fieldName: string): Field<C> | undefined;
+export declare function lookupResource<C extends AvContract>(contract: C, resourceName: string): AvResource<C> | undefined;
+export declare function lookupField<C extends AvContract>(resource: AvResource<C> | undefined, fieldName: string): AvField<C> | undefined;

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

@@ -5,13 +5,13 @@
  */
 export declare const AVENTARA_PROTOCOL_VERSION: 1;
 /** A Contract hash: `sha256:` followed by the hex digest. */
-export type ContractHash = `sha256:${string}`;
+export type AvContractHash = `sha256:${string}`;
 /** The protocol a Contract is written for. */
-export type ContractProtocol = {
+export type AvContractProtocol = {
     /** The protocol version; see {@link AVENTARA_PROTOCOL_VERSION}. */
     readonly version: typeof AVENTARA_PROTOCOL_VERSION;
 };
 /** A ClientContract's `protocol`: the protocol version and the Contract hash. */
-export type ClientContractProtocol = ContractProtocol & {
-    readonly hash: ContractHash;
+export type AvContractClientProtocol = AvContractProtocol & {
+    readonly hash: AvContractHash;
 };

package/dist/contracts/contract.d.ts

@@ -1,22 +1,22 @@
-import type { ContractLimits } from "./contract-limits.js";
-import type { ClientContractProtocol } from "./contract-protocol.js";
-import type { EnumDefinition } from "./enum-definition.js";
+import type { AvContractLimits } from "./contract-limits.js";
+import type { AvContractClientProtocol } from "./contract-protocol.js";
+import type { AvEnumDefinition } from "./enum-definition.js";
 import type { ReferenceWriteLimit } from "./reference-write-limit.js";
-import type { Resource } from "./resource.js";
-import type { ScalarRegistry } from "./scalar.js";
-import type { TransactionCapability } from "./transaction-capability.js";
+import type { AvResource } from "./resource.js";
+import type { AvScalarRegistry } from "./scalar.js";
+import type { AvTransactionCapability } from "./transaction-capability.js";
 /** What every Contract describes: scalars, enums, Resources, limits and transactions. */
-export interface Contract {
+export interface AvContract {
     /** The scalar types available. */
-    readonly scalars: ScalarRegistry;
+    readonly scalars: AvScalarRegistry;
     /** The enums, by name. */
-    readonly enums: Readonly<Record<string, EnumDefinition>>;
+    readonly enums: Readonly<Record<string, AvEnumDefinition>>;
     /** The Resources, by name. */
-    readonly resources: Readonly<Record<string, Resource<this>>>;
+    readonly resources: Readonly<Record<string, AvResource<this>>>;
     /** The request limits in force. */
-    readonly limits: ContractLimits;
+    readonly limits: AvContractLimits;
     /** Whether interactive transactions are available. */
-    readonly transactions: TransactionCapability;
+    readonly transactions: AvTransactionCapability;
     /**
      * `"uniform"` when one record must write the relations that hold a reference
      * either all as relations or all through their reference fields; a record
@@ -25,16 +25,24 @@ export interface Contract {
     readonly referenceWrites?: ReferenceWriteLimit;
 }
 /** The Contract compiled from the root configuration. */
-export interface CoreContract extends Contract {
+export interface AvContractCore extends AvContract {
 }
 /** The Contract in-process calls run under (`framework.application`). */
-export interface ApplicationContract extends Contract {
+export interface AvContractApplication extends AvContract {
 }
 /**
  * The Contract remote clients run under, published at `GET /_contract` and
  * identified by its hash.
  */
-export interface ClientContract extends Contract {
+export interface AvContractClient extends AvContract {
     /** The protocol version and this Contract's hash. */
-    readonly protocol: ClientContractProtocol;
+    readonly protocol: AvContractClientProtocol;
+}
+/**
+ * The Contract an AI agent's calls run under (the `agent` layer), identified by
+ * its hash. MCP tools are built from it.
+ */
+export interface AvContractAgent extends AvContract {
+    /** The protocol version and this Contract's hash. */
+    readonly protocol: AvContractClientProtocol;
 }