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

package/dist/runtime/pipe-output.validator.js

@@ -19,7 +19,7 @@ function serverContract(core, active) {
     return { ...core, resources };
 }
 const SERVER_VIEWS = new WeakMap();
-function serverContractFor(core, active) {
+export function serverContractFor(core, active) {
     let view = SERVER_VIEWS.get(active);
     if (view === undefined) {
         view = serverContract(core, active);
@@ -64,7 +64,9 @@ export function refusePipeOutput(contracts, request, args, pipe, index, options)
     return refuseStageOutput(contracts, request, args, `Pipe ${pipeLabel(pipe, index)}`, options);
 }
 export function refuseStageOutput(contracts, request, args, subject, options) {
-    const issues = serverIssues(serverContractFor(contracts.core, contracts.active), request, args, options);
+    return refusedStageOutput(request, serverIssues(serverContractFor(contracts.core, contracts.active), request, args, options), subject);
+}
+export function refusedStageOutput(request, issues, subject) {
     const [first] = issues;
     if (first === undefined) {
         return undefined;

package/dist/runtime/pipeline.d.ts

@@ -1,16 +1,17 @@
 import type { AvAdapterModel } from "../adapters/adapter-model.js";
 import type { AvAdapterSqlValue } from "../adapters/adapter-sql-statement.js";
+import type { AvPreComputeLift } from "../config/computed-fields.js";
 import type { AvRequestOrigin } from "../config/config-layer.js";
 import type { AvConfigResourceKey } from "../config/framework-field-definition.js";
 import type { AvContract } from "../contracts/contract.js";
 import type { AvApplicationScalarForms } from "../contracts/scalar-value-type.js";
-import type { AvContractApplicationView } from "../framework/contract-view.js";
+import type { AvContractApplicationView, RequirementsLessComputed } from "../framework/contract-view.js";
 import type { AvContextOperations } from "../framework/operation-facade.js";
 import type { AvOperationArgumentsFor, AvResourceKey } from "../operations/operation-arguments.js";
 import type { AvOperationFamily, AvOperationIdentity } from "../operations/operation-identity.js";
 import type { AvTransactionReference } from "../transactions/transaction-reference.js";
 import type { AvError } from "./framework-error.js";
-import type { AvDeepReadonly, AvDeepReadonlyLeaf } from "./readonly-value.js";
+import type { ArrayForm, AvDeepReadonly, AvDeepReadonlyLeaf } from "./readonly-value.js";
 import type { AvState } from "./request-state.js";
 /**
  * What a pipeline is told about the HTTP request a client-origin operation arrived on.
@@ -36,24 +37,38 @@ type AvContextFacts = {
      */
     readonly $state: AvState;
 };
-/**
- * `ctx.$sql`: a developer SQL statement, written only as a tagged template —
- * ``await ctx.$sql<Row>`insert into audit (actor) values (${actorId})` `` — run at
- * once. Every interpolated value is bound as a parameter, never spliced into the
- * text. It runs in the current transaction; outside one, as a plain statement,
- * with no transaction opened around it. Resolves the rows the statement returned.
- */
-export type AvContextSql = <Row = unknown>(strings: TemplateStringsArray, ...values: readonly AvAdapterSqlValue[]) => Promise<Row[]>;
 /**
  * The arguments a variant-level stage is told: the operation's arguments under
  * the model's Application Contract view, in the application forms, a reference
  * position admitting an unresolved `$ref`. `unknown` for a model whose Resource
  * names are not literal.
  */
-export type AvStageArguments<M extends AvAdapterModel, R extends string, F extends AvOperationFamily, V extends string> = string extends R ? unknown : R extends AvResourceKey<AvContractApplicationView<M>> ? AvOperationArgumentsFor<AvContractApplicationView<M>, R, Extract<AvOperationIdentity, {
+export type AvStageArguments<M extends AvAdapterModel, R extends string, F extends AvOperationFamily, V extends string> = StageArgumentsOf<AvContractApplicationView<M>, R, F, V>;
+/** The arguments of operation `F`.`V` on `R` under the Contract view `C`. */
+type StageArgumentsOf<C extends AvContract, R extends string, F extends AvOperationFamily, V extends string> = string extends R ? unknown : R extends AvResourceKey<C> ? AvOperationArgumentsFor<C, R, Extract<AvOperationIdentity, {
     readonly family: F;
     readonly variant: V;
 }>, AvApplicationScalarForms, AvApplicationScalarForms> : unknown;
+/**
+ * The arguments a variant's guards, pipes and filters are told: the operation's
+ * arguments before write compute has run, so a create need not hold a field
+ * `compute.create` fills (`Lift`, as `"<Resource>.<field>"`; `string`: any).
+ */
+export type AvPreComputeStageArguments<M extends AvAdapterModel, R extends string, F extends AvOperationFamily, V extends string, Lift extends string = AvPreComputeLift<M, "root">> = F extends "find" | "delete" ? AvStageArguments<M, R, F, V> : [Lift] extends [never] ? AvStageArguments<M, R, F, V> : StageArgumentsOf<PreComputeView<AvContractApplicationView<M>, Lift>, R, F, V>;
+/** A Contract view with the create requirements `Lift` names lifted. */
+type PreComputeView<C, Lift extends string> = Extract<{
+    readonly [P in keyof C]: P extends "resources" ? string extends Lift ? {
+        readonly [R in keyof C[P]]: Omit<C[P][R], "createRequirements">;
+    } : {
+        readonly [R in keyof C[P]]: LiftedResource<C[P][R], LiftedFieldOf<Lift, R>>;
+    } : C[P];
+}, AvContract>;
+/** The fields of Resource `R` that `Lift` names. */
+type LiftedFieldOf<Lift extends string, R> = Lift extends `${R & string}.${infer Field}` ? Field : never;
+/** One Resource with the create requirements on `Fields` lifted; itself when none. */
+type LiftedResource<Resource, Fields> = [Fields] extends [never] ? Resource : {
+    readonly [P in keyof Resource]: P extends "createRequirements" ? RequirementsLessComputed<Exclude<Resource[P], undefined>, Fields> : Resource[P];
+};
 /**
  * What a pipeline callback is told about the operation it is wrapping, and the
  * framework's executor: `ctx.<Resource>.<family>.<variant>(args)`, `ctx.$sql` and
@@ -83,11 +98,20 @@ export type AvContext<M extends AvAdapterModel = AvAdapterModel, R extends strin
      * returned them in a pipe, and the validated arguments the operation executes in
      * an interceptor, a hook or a filter. Only a pipe changes them, by returning new
      * ones; writing to them throws a `TypeError`. At a variant, typed as that
-     * operation's arguments ({@link AvStageArguments}), deep read-only; above it,
-     * `unknown`.
+     * operation's arguments ({@link AvStageArguments}), deep read-only; in a guard or
+     * a filter a create may lack the fields `compute.create` fills ({@link
+     * AvPreComputeStageArguments}: write compute has not run); above it, `unknown`.
      */
     readonly $args: AvDeepReadonly<A>;
-    readonly $sql: AvContextSql;
+    /**
+     * A developer SQL statement, written only as a tagged template —
+     * ``await ctx.$sql<Row>`insert into audit (actor) values (${actorId})` ``
+     * — run at once. Every interpolated value is bound as a parameter, never
+     * spliced into the text. It runs in the current transaction; outside one,
+     * as a plain statement, with no transaction opened around it. Resolves
+     * the rows the statement returned.
+     */
+    readonly $sql: <Row = unknown>(strings: TemplateStringsArray, ...values: readonly AvAdapterSqlValue[]) => Promise<Row[]>;
     /**
      * Runs `work` in a transaction, `tx` being this ctx bound to it, and resolves
      * what `work` resolved; a throw rolls it back. Inside an open transaction it
@@ -103,22 +127,22 @@ export type AvGuard<M extends AvAdapterModel = AvAdapterModel, R extends string
  * Transforms the arguments before the validators judge them: the only stage
  * that changes them. `args` is deep-frozen, so a pipe returns new arguments;
  * returning `undefined` keeps them as they are. At a variant, `args` and the
- * return are typed as that operation's arguments ({@link AvStageArguments}),
- * `args` deep read-only.
+ * return are typed as that operation's arguments before write compute runs
+ * ({@link AvPreComputeStageArguments}: a create may lack the fields
+ * `compute.create` fills), `args` deep read-only.
  */
 export type AvPipe<M extends AvAdapterModel = AvAdapterModel, R extends string = AvConfigResourceKey<M>, F extends AvOperationFamily = AvOperationFamily, V extends string = string, A = unknown> = {
-    pipe(args: PipeArguments<A>, context: AvContext<M, R, F, V, A>): PipeResult<PipeArguments<A>>;
+    pipe(args: PipeArguments<A>, context: AvContext<M, R, F, V, A>): unknown extends PipeArguments<A> ? any : PipeArguments<A> | undefined | void | Promise<PipeArguments<A> | undefined | void>;
 }["pipe"];
 /**
  * A variant pipe's arguments and return: the operation's arguments, deep
  * read-only, each member closed to inference.
  */
-type PipeArguments<T> = T extends AvDeepReadonlyLeaf | AvTransactionReference ? T : T extends object ? {
+type PipeArguments<T> = T extends AvDeepReadonlyLeaf | AvTransactionReference ? T : T extends readonly unknown[] ? ArrayForm<T> extends "array" ? readonly NoInfer<PipeArguments<Exclude<T[number], undefined>>>[] : {
+    readonly [K in keyof T]: NoInfer<PipeArguments<Exclude<T[K], undefined>>>;
+} : T extends object ? {
     readonly [K in keyof T]: NoInfer<PipeArguments<Exclude<T[K], undefined>>>;
 } : T;
-/** What a pipe returns: arguments of type `A`, or `undefined` to keep them. */
-type PipeResult<A> = unknown extends A ? any : // biome-ignore lint/suspicious/noConfusingVoidType: a pipe written as `() => void sideEffect()` keeps the arguments, as `undefined` does
-A | undefined | void | Promise<A | undefined | void>;
 /** Runs just before the operation executes, inside every interceptor; `ctx.$args` is deep-frozen. */
 export type AvBeforeHook<M extends AvAdapterModel = AvAdapterModel, R extends string = AvConfigResourceKey<M>, F extends AvOperationFamily = AvOperationFamily, V extends string = string, A = unknown> = {
     before(context: AvContext<M, R, F, V, A>): void | Promise<void>;
@@ -180,7 +204,8 @@ export type AvTransactionStep<M extends AvAdapterModel = AvAdapterModel> = {
 export type AvTransactionContext<M extends AvAdapterModel = AvAdapterModel> = AvContextOperations<M> & AvContextFacts & {
     /** The plan, in step order, `$ref`s unresolved, deep-frozen. */
     readonly $args: readonly AvTransactionStep<M>[];
-    readonly $sql: AvContextSql;
+    /** As a stage's `ctx.$sql`: a developer SQL statement, run in this transaction. */
+    readonly $sql: <Row = unknown>(strings: TemplateStringsArray, ...values: readonly AvAdapterSqlValue[]) => Promise<Row[]>;
     /** Runs `work` inside this transaction (it opens nothing): `tx` is this ctx. */
     $transaction<T>(work: (tx: AvTransactionContext<M>) => Promise<T>): Promise<T>;
 };

package/dist/runtime/readonly-value.d.ts

@@ -1,12 +1,23 @@
-import { AvDecimal } from "./decimal.js";
+import { type AvDecimal } from "./decimal.js";
 /** A value `AvDeepReadonly` leaves as it is: a primitive, a function, or a scalar instance. */
 export type AvDeepReadonlyLeaf = string | number | boolean | bigint | symbol | null | undefined | Date | Uint8Array | AvDecimal | ((...args: never[]) => unknown);
+/**
+ * Whether array type `T` is an open array (every length: `"array"`) or a tuple
+ * (`"tuple"`). A tuple whose only fixed positions are optional ones before a rest
+ * element (`[a?, ...b[]]`) has every length too and reads as an array.
+ */
+export type ArrayForm<T extends readonly unknown[]> = T extends readonly [] | readonly [unknown, ...unknown[]] | readonly [...unknown[], unknown] ? "tuple" : T extends {
+    readonly length: infer Length;
+} ? number extends Length ? "array" : "tuple" : "tuple";
 /**
  * `T` with every property, element and nested property read-only: what a stage
- * that only reads is told. Arrays become read-only arrays; a `Date`, a
- * `Uint8Array`, an `AvDecimal` and functions are left as they are.
+ * that only reads is told. Arrays become read-only arrays, tuples read-only
+ * tuples; a `Date`, a `Uint8Array`, an `AvDecimal` and functions are left as
+ * they are.
  */
-export type AvDeepReadonly<T> = T extends AvDeepReadonlyLeaf ? T : T extends object ? {
+export type AvDeepReadonly<T> = T extends AvDeepReadonlyLeaf ? T : T extends readonly unknown[] ? ArrayForm<T> extends "array" ? readonly AvDeepReadonly<T[number]>[] : {
+    readonly [K in keyof T]: AvDeepReadonly<T[K]>;
+} : T extends object ? {
     readonly [K in keyof T]: AvDeepReadonly<T[K]>;
 } : T;
 /**
@@ -21,8 +32,12 @@ export declare function deepFreeze<T>(value: T): T;
  * only reads is told — the validated arguments after validation, a result in an
  * after hook — so neither what is written nor the result the caller receives can
  * be changed through it.
+ *
+ * With `snapshot`, a copied container found to hold no `Date` or `Uint8Array`
+ * is remembered as such at once, so a later `frozenCopy` of the copy shares it
+ * without walking it: for a copy that is itself copied again for each stage.
  */
-export declare function frozenCopy<T>(value: T): AvDeepReadonly<T>;
+export declare function frozenCopy<T>(value: T, snapshot?: boolean): AvDeepReadonly<T>;
 /**
  * A read-only view of `value`: reads see the live value, nested plain objects
  * and arrays as views too, and any write, definition or deletion throws a

package/dist/runtime/readonly-value.js

@@ -1,4 +1,4 @@
-import { AvDecimal } from "./decimal.js";
+import { isAvDecimal } from "./decimal.js";
 function isContainer(value) {
     if (value === null || typeof value !== "object") {
         return false;
@@ -6,7 +6,7 @@ function isContainer(value) {
     if (Array.isArray(value)) {
         return true;
     }
-    if (value instanceof AvDecimal) {
+    if (isAvDecimal(value)) {
         return false;
     }
     const prototype = Object.getPrototypeOf(value);
@@ -36,51 +36,99 @@ function scalarCopy(value) {
     }
     return undefined;
 }
-export function frozenCopy(value) {
+const SCALAR_FREE = new WeakSet();
+function scalarFree(value) {
+    return Object.isFrozen(value) && SCALAR_FREE.has(value);
+}
+const WALKING = Symbol("walking");
+function place(target, key, value, enumerable) {
+    if (enumerable && typeof key === "string" && !(key in target)) {
+        target[key] = value;
+        return;
+    }
+    Object.defineProperty(target, key, {
+        value,
+        enumerable,
+        writable: true,
+        configurable: true,
+    });
+}
+export function frozenCopy(value, snapshot = false) {
+    const scalar = scalarCopy(value);
+    if (scalar !== undefined) {
+        return scalar;
+    }
+    if (!isContainer(value) || scalarFree(value)) {
+        return value;
+    }
     const copies = new Map();
+    let cycled = false;
+    let holdsScalar = false;
     const copy = (current) => {
+        if (current === null || typeof current !== "object") {
+            return current;
+        }
         const scalar = scalarCopy(current);
         if (scalar !== undefined) {
+            holdsScalar = true;
             return scalar;
         }
-        if (!isContainer(current)) {
+        if (!isContainer(current) || scalarFree(current)) {
             return current;
         }
-        if (copies.has(current)) {
-            return copies.get(current);
+        const known = copies.get(current);
+        if (known === WALKING) {
+            cycled = true;
+            return current;
+        }
+        if (known !== undefined) {
+            holdsScalar ||= !scalarFree(known);
+            return known;
         }
-        copies.set(current, current);
-        const entries = [];
-        let changed = !DEEP_FROZEN.has(current);
+        copies.set(current, WALKING);
+        const outer = holdsScalar;
+        holdsScalar = false;
+        let changed = !(Object.isFrozen(current) && DEEP_FROZEN.has(current));
+        const array = Array.isArray(current);
+        const prototype = Object.getPrototypeOf(current);
+        const target = array
+            ? new Array(current.length)
+            : prototype === Object.prototype
+                ? {}
+                : Object.create(prototype);
         for (const key of Reflect.ownKeys(current)) {
+            if (array && key === "length") {
+                continue;
+            }
             const descriptor = Object.getOwnPropertyDescriptor(current, key);
-            if (descriptor === undefined ||
-                !("value" in descriptor) ||
-                (Array.isArray(current) && key === "length")) {
+            if (descriptor === undefined || !("value" in descriptor)) {
                 continue;
             }
             const next = copy(descriptor.value);
             changed ||= next !== descriptor.value;
-            entries.push([key, descriptor, next]);
+            place(target, key, next, descriptor.enumerable === true);
         }
+        const held = holdsScalar;
+        holdsScalar = outer || held;
         if (!changed) {
             copies.set(current, current);
+            if (!cycled) {
+                SCALAR_FREE.add(current);
+            }
             return current;
         }
-        const target = Array.isArray(current)
-            ? new Array(current.length)
-            : Object.create(Object.getPrototypeOf(current));
-        for (const [key, descriptor, next] of entries) {
-            Object.defineProperty(target, key, {
-                value: next,
-                enumerable: descriptor.enumerable ?? false,
-                writable: true,
-                configurable: true,
-            });
+        Object.freeze(target);
+        DEEP_FROZEN.add(target);
+        if (cycled) {
+            for (const key of Reflect.ownKeys(target)) {
+                deepFreeze(target[key]);
+            }
+        }
+        if (snapshot && !held && !cycled) {
+            SCALAR_FREE.add(target);
         }
-        const frozen = deepFreeze(target);
-        copies.set(current, frozen);
-        return frozen;
+        copies.set(current, target);
+        return target;
     };
     return copy(value);
 }

package/dist/runtime/referential-action.d.ts

@@ -29,7 +29,7 @@ export type ReferentialEdge = {
      * relation `field` and any of these names the reference twice and is refused;
      * a required relation may be written through all of them instead.
      */
-    readonly references: readonly string[];
+    readonly referenceFields: readonly string[];
     /** What deleting a `target` row does to rows of the ENCLOSING Resource. */
     readonly onDelete: ReferentialDeleteEffect;
 };

package/dist/runtime/scalar-runtime.d.ts

@@ -1,19 +1,18 @@
 import type { AvRequestOrigin } from "../config/config-layer.js";
-import type { AvScalarFilterOperator } from "../contracts/capability.js";
 import type { AvContract } from "../contracts/contract.js";
 import type { AvScalarField } from "../contracts/field.js";
 import type { AvOperationIdentity } from "../operations/operation-identity.js";
 import type { OperationValidationOptions, SemanticOperationArguments } from "../operations/operation-validator.js";
 import type { AvValidationIssue } from "../operations/validation-code.js";
 import { type TransactionSlotShape } from "../transactions/transaction-reference.js";
-export type ScalarNormalizationResult = {
+type ScalarNormalizationResult = {
     readonly ok: true;
     readonly arguments: SemanticOperationArguments;
 } | {
     readonly ok: false;
     readonly issues: readonly AvValidationIssue[];
 };
-export type ScalarValueNormalizationResult = {
+type ScalarValueNormalizationResult = {
     readonly ok: true;
     readonly value: unknown;
 } | {
@@ -31,6 +30,8 @@ type Path = readonly (string | number)[];
  * one reader and a value to another.
  */
 export declare function isPlainRecord(value: unknown): value is Readonly<Record<string, unknown>>;
+/** The `V1001` of an `undefined` the request reads with. */
+export declare function unsentReadValueIssue(path: Path): AvValidationIssue;
 /**
  * An operation argument's JSON value is bounded by `maxJsonDepth`, which the
  * structural walk enforces before this runs; a `$sql` step's parameter is not
@@ -71,14 +72,6 @@ export declare function jsonShapeIssues(field: AvScalarField<AvContract>, value:
  * its copy.
  */
 export declare function copyScalarFieldValue(field: AvScalarField<AvContract>, value: unknown): unknown;
-/**
- * The operators of a step's own filter whose operand is a reference position, and
- * the shape each holds — the one table the normalization below and the reference
- * collector (`transaction-reference-collector.ts`) both read. `not` also takes a
- * nested operator object. Not here, so never a reference: `mode`, `isEmpty`, `path`
- * and a `json` field's `string*`/`array*` operators, which take no field value.
- */
-export declare const REFERENCE_OPERANDS: Readonly<Partial<Record<AvScalarFilterOperator, TransactionSlotShape>>>;
 /** The shape of `operator`'s operand when it is a reference position. */
 export declare function referenceOperandShape(operator: string): TransactionSlotShape | undefined;
 /**

package/dist/runtime/scalar-runtime.js

@@ -1,13 +1,20 @@
 import { shapeOfField } from "../avz/json-shape.registry.js";
+import { AVZ_FORMATS } from "../config/framework-field-definition.js";
+import { FILTER_MODES, } from "../contracts/capability.js";
 import { lookupField, lookupOwn, lookupResource, } from "../contracts/contract-lookup.js";
 import { decodeBase64, WIRE_SCALAR_PATTERNS, } from "../contracts/wire-scalar-format.js";
 import { routeTransactionReferenceCandidate, } from "../transactions/transaction-reference.js";
-import { AvDecimal } from "./decimal.js";
+import { AvDecimal, isAvDecimal } from "./decimal.js";
+import { fieldCheckIssues } from "./field-check.evaluator.js";
 const INT_MIN = -(2 ** 31);
 const INT_MAX = 2 ** 31 - 1;
 const BIGINT_MIN = -(2n ** 63n);
 const BIGINT_MAX = 2n ** 63n - 1n;
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const NAMED_FORMATS = new Set(AVZ_FORMATS);
+function isNamedFormat(format) {
+    return NAMED_FORMATS.has(format);
+}
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -24,6 +31,10 @@ function issue(code, path, message) {
 function typeIssue(path, expected) {
     return issue("V1001", path, `Value must be ${expected}.`);
 }
+const UNSENT_READ_VALUE_MESSAGE = "Value must not be undefined: it would be left out, and the request would reach more rows.";
+export function unsentReadValueIssue(path) {
+    return issue("V1001", path, UNSENT_READ_VALUE_MESSAGE);
+}
 function formatIssue(path, expected) {
     return issue("V1003", path, `Value must use ${expected}.`);
 }
@@ -83,18 +94,14 @@ export function normalizeJsonValue(value, path, seen) {
             const normalized = [];
             task.emit(normalized);
             stack.push({ kind: "leave", container: current });
-            const entries = [];
-            current.forEach((entry, index) => {
-                entries.push([index, entry]);
-            });
-            for (let cursor = entries.length - 1; cursor >= 0; cursor -= 1) {
-                const entry = entries[cursor];
+            for (let index = current.length - 1; index >= 0; index -= 1) {
+                const entry = current[index];
                 stack.push({
                     kind: "visit",
-                    value: entry[1],
-                    link: { parent: task.link, segment: entry[0] },
+                    value: entry === undefined ? null : entry,
+                    link: { parent: task.link, segment: index },
                     emit: (child) => {
-                        normalized.push(child);
+                        normalized[index] = child;
                     },
                 });
             }
@@ -112,7 +119,7 @@ export function normalizeJsonValue(value, path, seen) {
         const normalized = {};
         task.emit(normalized);
         stack.push({ kind: "leave", container: current });
-        const entries = Object.entries(current);
+        const entries = Object.entries(current).filter((entry) => entry[1] !== undefined);
         for (let cursor = entries.length - 1; cursor >= 0; cursor -= 1) {
             const entry = entries[cursor];
             stack.push({
@@ -231,10 +238,9 @@ function normalizeScalarAtom(contract, field, value, origin, path, allowNull) {
             break;
         case "decimal":
             if (origin === "application") {
-                normalized =
-                    value instanceof AvDecimal
-                        ? { ok: true, value }
-                        : { ok: false, issues: [typeIssue(path, "an Aventara Decimal")] };
+                normalized = isAvDecimal(value)
+                    ? { ok: true, value }
+                    : { ok: false, issues: [typeIssue(path, "an Aventara Decimal")] };
             }
             else if (typeof value !== "string") {
                 normalized = {
@@ -359,9 +365,21 @@ export function normalizeScalarFieldValue(contract, field, value, origin, path)
         });
         return issues.length > 0
             ? { ok: false, issues }
-            : { ok: true, value: normalized };
+            : heldToFormat(field, { ok: true, value: normalized }, origin, path);
     }
-    return normalizeScalarAtom(contract, field, value, origin === "runtime" ? "application" : origin, path, field.nullable);
+    return heldToFormat(field, normalizeScalarAtom(contract, field, value, origin === "runtime" ? "application" : origin, path, field.nullable), origin, path);
+}
+function heldToFormat(field, normalized, origin, path) {
+    const format = field.format;
+    if (origin !== "runtime" ||
+        !normalized.ok ||
+        format === undefined ||
+        format === "uuid" ||
+        !isNamedFormat(format)) {
+        return normalized;
+    }
+    const issues = fieldCheckIssues([{ check: "string_format", format }], normalized.value, "string", path, field.list);
+    return issues.length === 0 ? normalized : { ok: false, issues };
 }
 export function jsonShapeIssues(field, value, path, position = "value") {
     if (field.json === undefined || value === null || value === undefined) {
@@ -427,6 +445,11 @@ export function copyScalarFieldValue(field, value) {
 function normalizeListElement(contract, field, value, origin, path) {
     return normalizeScalarAtom(contract, field, value, origin, path, false);
 }
+function normalizeFilterEntry(contract, field, value, origin, path) {
+    return value === undefined
+        ? { ok: false, issues: [unsentReadValueIssue(path)] }
+        : normalizeListElement(contract, field, value, origin, path);
+}
 function mergeResult(result, issues) {
     if (result.ok) {
         return result.value;
@@ -434,7 +457,7 @@ function mergeResult(result, issues) {
     issues.push(...result.issues);
     return undefined;
 }
-export const REFERENCE_OPERANDS = Object.freeze({
+const REFERENCE_OPERANDS = Object.freeze({
     equals: "value",
     not: "value",
     lt: "nonNullValue",
@@ -463,10 +486,40 @@ const NULL_OPERAND_OPERATORS = new Set([
     "arrayStartsWith",
     "arrayEndsWith",
 ]);
+const KEYWORD_OPERANDS = Object.freeze({
+    mode: (operand, path, issues) => {
+        if (!FILTER_MODES.includes(operand)) {
+            issues.push(typeIssue(path, '"default", "sensitive" or "insensitive"'));
+        }
+    },
+    isEmpty: (operand, path, issues) => {
+        if (typeof operand !== "boolean") {
+            issues.push(typeIssue(path, "a boolean"));
+        }
+    },
+    path: (operand, path, issues) => {
+        if (!Array.isArray(operand)) {
+            issues.push(typeIssue(path, "an array of strings"));
+            return;
+        }
+        for (let index = 0; index < operand.length; index += 1) {
+            if (operand[index] === undefined) {
+                issues.push(unsentReadValueIssue([...path, index]));
+            }
+            else if (typeof operand[index] !== "string") {
+                issues.push(typeIssue([...path, index], "a string"));
+            }
+        }
+    },
+});
 function normalizeScalarFilter(contract, field, value, origin, path, issues, references = false) {
     if (isKeptReference(references, value)) {
         return value;
     }
+    if (value === undefined) {
+        issues.push(unsentReadValueIssue(path));
+        return value;
+    }
     if (!isPlainRecord(value)) {
         return mergeResult(normalizeScalarFieldValue(contract, field, value, origin, path), issues);
     }
@@ -477,11 +530,17 @@ function normalizeScalarFilter(contract, field, value, origin, path, issues, ref
     const normalized = cloneRecord(value);
     for (const [operator, operand] of Object.entries(value)) {
         const operandPath = [...path, operator];
+        if (operand === undefined) {
+            issues.push(unsentReadValueIssue(operandPath));
+            continue;
+        }
         if (operand === null && !acceptsNullOperand(operator)) {
             issues.push(typeIssue(operandPath, "non-null"));
             continue;
         }
-        if (operator === "mode" || operator === "isEmpty" || operator === "path") {
+        const keyword = lookupOwn(KEYWORD_OPERANDS, operator);
+        if (keyword !== undefined) {
+            keyword(operand, operandPath, issues);
             continue;
         }
         if (referenceOperandShape(operator) !== undefined &&
@@ -497,14 +556,14 @@ function normalizeScalarFilter(contract, field, value, origin, path, issues, ref
                 issues.push(typeIssue(operandPath, "an array"));
                 continue;
             }
-            normalized[operator] = operand.map((entry, index) => mergeResult(normalizeListElement(contract, field, entry, origin, [
+            normalized[operator] = operand.map((entry, index) => mergeResult(normalizeFilterEntry(contract, field, entry, origin, [
                 ...operandPath,
                 index,
             ]), issues));
             continue;
         }
         if (operator === "has") {
-            normalized[operator] = mergeResult(normalizeListElement(contract, field, operand, origin, operandPath), issues);
+            normalized[operator] = mergeResult(normalizeFilterEntry(contract, field, operand, origin, operandPath), issues);
             continue;
         }
         if (operator === "hasEvery" || operator === "hasSome") {
@@ -512,7 +571,7 @@ function normalizeScalarFilter(contract, field, value, origin, path, issues, ref
                 issues.push(typeIssue(operandPath, "an array"));
                 continue;
             }
-            normalized[operator] = operand.map((entry, index) => mergeResult(normalizeListElement(contract, field, entry, origin, [
+            normalized[operator] = operand.map((entry, index) => mergeResult(normalizeFilterEntry(contract, field, entry, origin, [
                 ...operandPath,
                 index,
             ]), issues));
@@ -521,6 +580,12 @@ function normalizeScalarFilter(contract, field, value, origin, path, issues, ref
         if ("scalar" in field.type &&
             field.type.scalar === "json" &&
             (operator.startsWith("string") || operator.startsWith("array"))) {
+            if (operator.startsWith("string")) {
+                if (typeof operand !== "string") {
+                    issues.push(typeIssue(operandPath, "a string"));
+                }
+                continue;
+            }
             const jsonResult = normalizeJsonValue(operand, operandPath, new Set());
             normalized[operator] = mergeResult(jsonResult, issues);
             continue;
@@ -585,6 +650,10 @@ function normalizeUniqueSelector(contract, resourceName, selector, origin, path,
     const normalized = cloneRecord(selector);
     for (const [fieldName, value] of Object.entries(selector)) {
         const field = lookupField(resource, fieldName);
+        if (field?.kind === "scalar" && value === undefined) {
+            issues.push(unsentReadValueIssue([...path, fieldName]));
+            continue;
+        }
         if (field?.kind === "scalar" && !isKeptReference(references, value)) {
             normalized[fieldName] = mergeResult(normalizeScalarFieldValue(contract, field, value, origin, [
                 ...path,

package/dist/runtime/unsent-value.normalizer.d.ts

@@ -0,0 +1,15 @@
+import type { AvContract } from "../contracts/contract.js";
+import type { AvOperationFamily } from "../operations/operation-identity.js";
+/**
+ * One operation's arguments with every write record's unsent fields removed — a
+ * field whose value is `undefined`, at any depth of nested write data the
+ * Contract's `maxNestingDepth` admits — and
+ * nothing else changed (see the module note): `where`, selectors and every other
+ * member are left as they are. The same object when nothing was unsent; otherwise
+ * a copy of each container on the way, never a write into `args`. Total over
+ * malformed input.
+ */
+export declare function withoutUnsentWriteValues(contract: AvContract, request: {
+    readonly resource: string;
+    readonly family: AvOperationFamily;
+}, args: unknown): unknown;