@aventara/core 1.0.0-rc.14 → 1.0.0-rc.15

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @aventara/core
 
+## 1.0.0-rc.15
+
+### Patch Changes
+
+- aab6d72: The client `avclient generate` writes now passes a default `biome check` as written, on Biome 2.4.0 and later (Biome's default rules; an opt-in rule or assist such as `useSortedKeys` is not covered): every generated file opens with `biome-ignore-all` lines for formatting, lint and import order (`organizeImports`), core's copied declarations have a blank line after their imports, the copied field-check evaluator carries no line suppression that the file-wide one makes unused, and each file ends without a final line break, which Biome 2.4.0 to 2.4.10 reported on every file under `biome-ignore-all format`. `aventara-build`'s own files pass too, in NestJS and Next.js projects: `resources.generated.ts`, `computed-fields.generated.ts` and `contracts.generated.ts` now open with the same suppressions and end without a final line break, and `--client`'s `src/aventara/client.ts` and `src/aventara/universal.ts` are written the same way. The discovery artifact `aventara-prisma7-generate` writes passes too. A file an earlier version wrote is reported stale by `aventara-build --check` and replaced by the next run. A client `avclient generate` wrote before is replaced on its next run. The client skill now says the generated files need no exclusion under Biome's default rules, and how to skip them in another linter or formatter.
+- bf98da7: A pipeline stage's types now know the root's field definitions. `aventara-build` writes `src/generated/aventara/config-facts.generated.ts` after it compiles the Contracts, and the discovery artifact puts it on the model's type:
+
+  - A Json field the root shapes reads as its shape in a stage's `ctx` calls, in `tx` and in compute's read-only `ctx`: `ctx.Product.find.many({ select: ["name"] })` types `name` as `{ ar: string; en: string }`. A read gives the shape's own type, the same as `framework.application`'s.
+  - A `VIRTUAL` field the root adds is in a variant's typed `ctx.$args` (`ctx.$args.data.tenderedMinor`), and a `ctx` create must write a non-null added input it can create.
+  - A variant's hooks and interceptors are told resolved arguments: their `ctx.$args` holds no `$ref` (an `AvTransactionReference`), since references are resolved before they run. Guards, pipes and filters still may see one.
+  - A write takes a shaped Json value read-only, deep, on every surface (`framework.application`, `ctx`, the generated client too), so a frozen value, such as a stage's `ctx.$args`, fits as well as a mutable one.
+  - A compute stage on a shaped Json field returns the shape's type. A compute stage on an added field returns the type its generated fact states, read from the model instead of the configuration. Without the generated file, its return is not typed.
+
+  The server warns at startup (`AVENTARA_STALE_GENERATED_TYPES`) when the configuration's definitions differ from the ones the generated types were written with, naming each field. It is the same one warning as for stale computed fields: one stale build gives one warning, with a paragraph for each part that is stale, including a facts file it cannot read. `aventara-build --check` also fails on a stale file. Run `aventara:prepare` after you change a `definition`.
+
+  The discovery artifact's format is now 5: regenerate it with `aventara:prepare` (an artifact of format 4 is refused, as before). The Json Shape type emitter the client generator uses now lives in `@aventara/core`; the generated clients are unchanged. The CLI's agent skill says this in `SKILL.md` and `reference/stages.md`.
+
+- f8cd860: The transaction docs and skills now say where a `$ref` works with a Json field: as the field's whole value, from another Json field. Inside a Json value nothing is read as a reference, so a nested `$ref` is stored as the reference object (`{ "$ref": { "operation", "fingerprint", "path" } }`), unresolved. A Json value cannot have `$ref` as its own root key: it is read as a `$ref` directive and refused with `A2004` (`V1006`, or `V1001` for other shapes). To build Json from an earlier step's result, write the `$ref` into a `VIRTUAL` input field and build the Json in a compute stage. No behaviour changed.
+- 8a64af2: A transaction plan's references are installed and resolved in time linear in their number. Before this release the cost grew with the square of the references in one nested list, so a plan with a few thousand of them, such as a long `$connect` or `$create` list where each entry holds a `$ref`, took seconds to validate. The plan's answer is unchanged.
+- 548881c: Pipeline stages type-check faster. A stage typed for compute's read-only context (`(ctx: AvComputeContext<Model>) => …`) placed as a variant's hook or guard, and an annotated stage such as `AvGuard<Model>`, no longer make TypeScript compare two copies of the model's ctx types. On one server application this cut the check by about 40 % (from about 2.03 to 1.21 million type instantiations). The configuration's `pipelines` keys still never decide the model: it comes from the adapter, as before. A stage's `ctx.<Resource>.<family>` (and compute's `ctx.<Resource>.find`) is now named `AvContextFamilyFacade<C, R, F>`, a new export of `@aventara/core`, as `framework.application.<Resource>.<family>` is `AvApplicationFamilyFacade`.
+- 62fa91f: A compute stage's return is now typed by its field, so a wrong return is a type error instead of an `A3000` at run time. A discovered field takes its model type and an added `VIRTUAL` field takes the type in its `definition`, in the root, in overlays, in `defineResource` blocks and inline. A Decimal is an `AvDecimal` (a number or a string is refused, as at run time), a datetime is a `Date`, a list is an array, an enum is one of its members, and `null` fits only a nullable field. Returning `undefined`, or not returning at all, still keeps the current value. A Json field takes any JSON value, and its shape is still checked at run time; type a Json value with a `type` alias, not an `interface`, which has no index signature. `AvComputeCreate`, `AvComputeUpdate`, `AvComputeRead`, `AvFieldCompute` and `AvScalarFieldPipeline` take an optional last type argument for the value, `unknown` by default. The model comes from the adapter: a stage annotated for any model no longer turns off the checks of the other stages beside it.
+
+  Some code no longer compiles:
+
+  - A stage that returns one of its inputs (`value`, `data`, `record`, all still `unknown`), such as `return data.title`. Convert it (`String(data.title)`) or check its type first.
+  - A stage annotated without the field's value type. `const slug: AvComputeCreate<Model> = …` returns `unknown`, which no field takes: write `AvComputeCreate<Model, string>`, the field's value type (the same for `AvComputeUpdate` and `AvComputeRead`).
+  - A bare enum literal, which can widen to `string` (`() => "LIVE"`), in a `defineResource` block and inline. Write `() => "LIVE" as const`.
+
+  The CLI's agent skill says this in `SKILL.md` and `reference/stages.md`, and its post recipe no longer returns an `unknown` input.
+
 ## 1.0.0-rc.14
 
 ### Patch Changes

package/ERRORS.md

@@ -1,6 +1,6 @@
 # Aventara error codes
 
-Every code `@aventara/core` 1.0.0-rc.14 answers, reports in a validation issue, or refuses to start with. Generated from `AvErrorCatalog` (exported by `@aventara/core`); do not edit.
+Every code `@aventara/core` 1.0.0-rc.15 answers, reports in a validation issue, or refuses to start with. Generated from `AvErrorCatalog` (exported by `@aventara/core`); do not edit.
 
 Branch on the code, never on the message. In code, `AvErrorCatalog[code]` gives the same entry: `{ code, kind, message, cause, fix, docs }`.
 

package/dist/adapters/adapter-model.d.ts

@@ -32,4 +32,15 @@ export interface AvAdapterModel {
      * those stages require none.
      */
     readonly "~computedFields"?: AvConfigComputedFields;
+    /**
+     * Type-only, never present at runtime: per Resource, the TypeScript type of
+     * each Json field the root's definitions shape (`json`), and each field they
+     * add, as the Contract field it compiles to (`added`). A pipeline stage's
+     * `ctx` and its typed `$args` read them. Absent: those stages see the
+     * model's own fields, Json unshaped.
+     */
+    readonly "~configFacts"?: {
+        readonly added: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+        readonly json: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    } | undefined;
 }

package/dist/adapters/adapter.interface.d.ts

@@ -1,4 +1,5 @@
 import type { AvConfigComputedFields } from "../config/computed-fields.js";
+import type { AvJsonValue } from "../runtime/json-value.js";
 import type { ReferentialActionTable } from "../runtime/referential-action.js";
 import type { AvAdapterModel } from "./adapter-model.js";
 import type { AvAdapterOperationExecutor } from "./adapter-operation-executor.interface.js";
@@ -40,6 +41,19 @@ export interface AvAdapter<M extends AvAdapterModel = AvAdapterModel> extends Av
      * them); it changes no behaviour. Never part of a Contract or its hash.
      */
     readonly computedFields?: AvConfigComputedFields;
+    /**
+     * Optional: the Json shapes and added fields the generated types were written
+     * with (`config-facts.generated.ts`, the same statement as the model type's
+     * `"~configFacts"`): per Resource, each shaped field's JSON Schema and each
+     * added field's Contract field. When the Framework is constructed it is
+     * compared with the Core Contract, and a difference is a warning that the
+     * generated types are stale (`aventara:prepare` regenerates them); it changes
+     * no behaviour. Never part of a Contract or its hash.
+     */
+    readonly configFacts?: {
+        readonly added: Readonly<Record<string, Readonly<Record<string, AvJsonValue>>>>;
+        readonly json: Readonly<Record<string, Readonly<Record<string, AvJsonValue>>>>;
+    };
     /**
      * Optional: `true` when the Adapter runs developer SQL statements: standalone
      * through its own {@link executeSql}, and, when it has `transaction`, inside a

package/dist/config/computed-fields.d.ts

@@ -61,10 +61,16 @@ export declare function computedFieldsDrift(generated: AvConfigComputedFields, c
 /** The warning's code, as `process.emitWarning` reports it. */
 export declare const STALE_GENERATED_TYPES_WARNING = "AVENTARA_STALE_GENERATED_TYPES";
 /**
- * Warns, through `process.emitWarning` (code
- * {@link STALE_GENERATED_TYPES_WARNING}), when the generated types' computed
- * fields differ from the configuration's. Nothing to compare (an Adapter that
- * carries none) warns nothing.
+ * The stale warning's paragraph on the computed fields, naming each difference
+ * between the generated types' computed fields and the configuration's; none
+ * when they agree or there is nothing to compare (an Adapter that carries none).
  */
-export declare function warnOnStaleComputedFields(generated: AvConfigComputedFields | undefined, configured: AvConfigComputedFields): void;
+export declare function staleComputedFields(generated: AvConfigComputedFields | undefined, configured: AvConfigComputedFields): string | undefined;
+/**
+ * Warns once, through `process.emitWarning` (code
+ * {@link STALE_GENERATED_TYPES_WARNING}), with each paragraph a stale part of
+ * the generated types states (`staleComputedFields`, `staleConfigFacts`);
+ * nothing when none is stale.
+ */
+export declare function warnOnStaleGeneratedTypes(paragraphs: readonly (string | undefined)[]): void;
 export {};

package/dist/config/computed-fields.js

@@ -58,16 +58,20 @@ export function computedFieldsDrift(generated, configured) {
     return drift;
 }
 export const STALE_GENERATED_TYPES_WARNING = "AVENTARA_STALE_GENERATED_TYPES";
-export function warnOnStaleComputedFields(generated, configured) {
+export function staleComputedFields(generated, configured) {
     if (generated === undefined) {
-        return;
+        return undefined;
     }
     const drift = computedFieldsDrift(generated, configured);
-    if (drift.length === 0) {
-        return;
+    return drift.length === 0
+        ? undefined
+        : `The computed fields the pre-compute stages and ctx creates are typed with differ from the configuration's:\n${drift
+            .map((line) => `  - ${line}`)
+            .join("\n")}`;
+}
+export function warnOnStaleGeneratedTypes(paragraphs) {
+    const stale = paragraphs.filter((paragraph) => paragraph !== undefined);
+    if (stale.length > 0) {
+        emitFrameworkWarning(`generated types are stale: run aventara:prepare. ${stale.join("\n")}`, STALE_GENERATED_TYPES_WARNING);
     }
-    const message = `generated types are stale: run aventara:prepare. The computed fields the pre-compute stages and ctx creates are typed with differ from the configuration's:\n${drift
-        .map((line) => `  - ${line}`)
-        .join("\n")}`;
-    emitFrameworkWarning(message, STALE_GENERATED_TYPES_WARNING);
 }

package/dist/config/config-facts.d.ts

@@ -0,0 +1,22 @@
+import type { AvAdapter } from "../adapters/adapter.interface.js";
+import type { AvContractCore } from "../contracts/contract.js";
+/**
+ * The configuration's facts a stage's types read, in the form the generated
+ * file states them as a value: per Resource, each shaped Json field's JSON
+ * Schema (`json`) and each added field's Contract field (`added`).
+ */
+export type ConfigFacts = NonNullable<AvAdapter["configFacts"]>;
+/** The facts the Core Contract states, every name sorted. */
+export declare function configFactsOf(core: AvContractCore): ConfigFacts;
+/**
+ * How the configuration's facts differ from the ones the generated types were
+ * written with, one sentence per difference; empty when they agree.
+ */
+export declare function configFactsDrift(generated: ConfigFacts, configured: ConfigFacts): string[];
+/**
+ * The stale warning's paragraph on the configuration facts
+ * (`warnOnStaleGeneratedTypes`), naming each difference between the generated
+ * types' facts and the ones the Core Contract states; none when they agree or
+ * there is nothing to compare (an Adapter that carries none).
+ */
+export declare function staleConfigFacts(generated: ConfigFacts | undefined, core: AvContractCore): string | undefined;

package/dist/config/config-facts.js

@@ -0,0 +1,97 @@
+import { canonicalJson } from "../contracts/canonical-json.writer.js";
+const ADDED_FIELD_MEMBERS = [
+    "kind",
+    "type",
+    "nullable",
+    "list",
+    "lifecycle",
+    "capabilities",
+];
+export function configFactsOf(core) {
+    const added = {};
+    const json = {};
+    for (const resource of Object.keys(core.resources).sort()) {
+        const fields = core.resources[resource]?.fields ?? {};
+        for (const name of Object.keys(fields).sort()) {
+            const field = fields[name];
+            if (field?.kind !== "scalar") {
+                continue;
+            }
+            if (field.json !== undefined) {
+                json[resource] = {
+                    ...json[resource],
+                    [name]: field.json,
+                };
+            }
+            if (field.lifecycle.includes("VIRTUAL")) {
+                added[resource] = {
+                    ...added[resource],
+                    [name]: Object.fromEntries(ADDED_FIELD_MEMBERS.map((member) => [
+                        member,
+                        field[member],
+                    ])),
+                };
+            }
+        }
+    }
+    return { added, json };
+}
+function differing(left, right) {
+    const found = [];
+    for (const statement of ["added", "json"]) {
+        for (const [resource, fields] of Object.entries(left[statement])) {
+            for (const [field, fact] of Object.entries(fields)) {
+                const other = right[statement][resource]?.[field];
+                if (other === undefined ||
+                    canonicalJson(other) !== canonicalJson(fact)) {
+                    found.push(`${statement === "added" ? "added field" : "Json shape"} ${resource}.${field}`);
+                }
+            }
+        }
+    }
+    return found;
+}
+export function configFactsDrift(generated, configured) {
+    const missing = new Set(differing(generated, configured));
+    return [
+        ...differing(configured, generated).map((entry) => missing.delete(entry)
+            ? `changed since the types were generated: ${entry}`
+            : `in the configuration, not in the types: ${entry}`),
+        ...[...missing].map((entry) => `in the types, not in the configuration: ${entry}`),
+    ];
+}
+export function staleConfigFacts(generated, core) {
+    if (generated === undefined) {
+        return undefined;
+    }
+    const unreadable = malformedFacts(generated);
+    if (unreadable !== undefined) {
+        return `The generated config facts (the Json shapes and added fields that stages' ctx and arguments are typed with) cannot be read (${unreadable}): run aventara:prepare to rewrite config-facts.generated.ts.`;
+    }
+    const drift = configFactsDrift(generated, configFactsOf(core));
+    return drift.length === 0
+        ? undefined
+        : `The Json shapes and added fields that stages' ctx and arguments are typed with differ from the configuration's:\n${drift
+            .map((line) => `  - ${line}`)
+            .join("\n")}`;
+}
+function malformedFacts(facts) {
+    if (!isPlainObject(facts)) {
+        return "the statement is not an object";
+    }
+    for (const statement of ["added", "json"]) {
+        const resources = facts[statement];
+        if (!isPlainObject(resources)) {
+            return `\`${statement}\` is not an object`;
+        }
+        for (const [resource, fields] of Object.entries(resources)) {
+            if (!isPlainObject(fields)) {
+                return `\`${statement}.${resource}\` is not an object`;
+            }
+        }
+    }
+    return undefined;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/config/field-pipeline-config.d.ts

@@ -9,20 +9,20 @@ export type { AvZCheck } from "../avz/avz-check.registry.js";
  * A scalar field's computed values, one stage per phase: `create` and `update`
  * run before the write, `read` on each returned record.
  */
-export type AvFieldCompute<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>> = {
+export type AvFieldCompute<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>, Value = unknown> = {
     /** Computes the value on every create; an upsert's create branch included. */
-    readonly create?: AvComputeCreate<M>;
+    readonly create?: AvComputeCreate<M, Value>;
     /** Computes the value on every read of a returned record. */
-    readonly read?: AvComputeRead<M, Cfg, R>;
+    readonly read?: AvComputeRead<M, Cfg, R, Value>;
     /** Computes the value on every update; an upsert's update branch included. */
-    readonly update?: AvComputeUpdate<M>;
+    readonly update?: AvComputeUpdate<M, Value>;
 };
 /**
  * A scalar field's stages: validators, field pipes, compute and write guards.
  * `Check` is the checks the field takes (any, when the field's type is not
  * known here), or the sentence a type that takes none refuses them with.
  */
-export type AvScalarFieldPipeline<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>, Check extends AvZCheck | `Error: ${string}` = AvZCheck> = {
+export type AvScalarFieldPipeline<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>, Check extends AvZCheck | `Error: ${string}` = AvZCheck, Value = unknown> = {
     /**
      * Declarative checks on the value, built with `AvZ` and carried in the Contract;
      * root's, then the overlay's. On a list field `AvZ.minItems` and `AvZ.maxItems`
@@ -36,12 +36,12 @@ export type AvScalarFieldPipeline<M extends AvAdapterModel = AvAdapterModel, Cfg
      */
     readonly pipes?: readonly AvFieldPipe[];
     /** The field's computed values. */
-    readonly compute?: AvFieldCompute<M, Cfg, R>;
+    readonly compute?: NoInfer<AvFieldCompute<M, Cfg, R, Value>>;
     /** Write-only admission: run when the caller sends the field. */
-    readonly guards?: readonly AvFieldGuard<NoInfer<M>, R>[];
+    readonly guards?: readonly NoInfer<AvFieldGuard<M, R>>[];
 };
 /** A relation field's stages: write guards only. */
 export type AvRelationFieldPipeline<M extends AvAdapterModel = AvAdapterModel, R extends string = AvConfigResourceKey<M>> = {
     /** Write-only admission: run for every write through the relation. */
-    readonly guards?: readonly AvFieldGuard<NoInfer<M>, R>[];
+    readonly guards?: readonly NoInfer<AvFieldGuard<M, R>>[];
 };

package/dist/config/framework-config.d.ts

@@ -48,7 +48,7 @@ export type AvConfigLayer<M extends AvAdapterModel = AvAdapterModel, Cfg = AvCon
     /** Request limits; see {@link AvConfigLimits}. */
     readonly limits?: AvConfigLimits;
     /** Guards, pipes, hooks, interceptors and filters run around every operation of the layer. */
-    readonly pipelines?: AvPipeline<NoInfer<M>>;
+    readonly pipelines?: NoInfer<AvPipeline<M>>;
     /** The per-Resource tree: stages, operations, transactions and fields. */
     readonly resources?: AvConfigResources<M, Cfg, Kind, Layer>;
     /**

package/dist/config/framework-resources-config.d.ts

@@ -1,6 +1,10 @@
 import type { AvAdapterModel } from "../adapters/adapter-model.js";
 import type { AvAdapterFieldKey } from "../adapters/adapter-resource.js";
 import type { AvZCheck } from "../avz/avz-check.registry.js";
+import type { AvContractLimits } from "../contracts/contract-limits.js";
+import type { AvScalarField } from "../contracts/field.js";
+import type { ShapedJsonSchema } from "../contracts/json-shape.js";
+import type { AvScalarValueType } from "../contracts/scalar-value-type.js";
 import type { AvOperationFamily } from "../operations/operation-identity.js";
 import type { AvPreComputeStageArguments, AvStageArguments } from "../runtime/pipeline.js";
 import type { AvConfigAny } from "./any-framework-config.js";
@@ -23,7 +27,7 @@ export type AvConfigVariant<M extends AvAdapterModel = AvAdapterModel, R extends
      * pipe or a filter a create may lack the fields `compute.create` fills
      * (write compute runs after them).
      */
-    readonly pipelines?: AvPipeline<NoInfer<M>, R, F, V, A, PreCompute>;
+    readonly pipelines?: NoInfer<AvPipeline<M, R, F, V, A, PreCompute>>;
     /** Runs a plain call of this operation as a one-step transaction. */
     readonly forceTransaction?: boolean;
 };
@@ -43,7 +47,7 @@ export type AvConfigOperations<M extends AvAdapterModel = AvAdapterModel, R exte
 /** A Resource's transaction level. */
 export type AvConfigResourceTransactions<M extends AvAdapterModel = AvAdapterModel> = {
     /** Stages that run once per transaction with a top-level step on the Resource. */
-    readonly pipelines?: AvTransactionPipeline<NoInfer<M>>;
+    readonly pipelines?: NoInfer<AvTransactionPipeline<M>>;
 };
 /** A field's entry at the root: its definition and its stages. */
 export type AvConfigRootField<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>> = {
@@ -74,15 +78,39 @@ type FieldCheckOf<Field> = Field extends {
     readonly type: infer Type;
     readonly list: infer List;
 } ? ([TypeChecks<Type>] extends [never] ? NoCheckRefusal<Type, List> : TypeChecks<Type>) | (false extends List ? never : AvZCheck<"list">) : AvZCheck;
-/** A discovered scalar field's stages, its `validators` typed by the field. */
-type KnownScalarFieldPipeline<M extends AvAdapterModel, Cfg, R extends AvConfigResourceKey<M>, Field> = Field extends {
+/** Model `M`'s scalars and enums, as the value rule reads a Contract's. */
+type ModelValueSource<M extends AvAdapterModel> = {
+    readonly scalars: M["scalars"];
+    readonly enums: M["enums"];
+    readonly resources: Record<never, never>;
+    readonly limits: AvContractLimits;
+    readonly transactions: "none";
+};
+/** The value a compute stage of discovered field `F` returns, in process form. */
+type ComputedValueOf<M extends AvAdapterModel, R extends AvConfigResourceKey<M>, F extends string> = (ShapeFactOf<M, R, F> extends infer Shape ? [Shape] extends [never] ? M["resources"][R]["fields"][F] : M["resources"][R]["fields"][F] & {
+    readonly json: ShapedJsonSchema<Shape>;
+} : never) extends infer Field extends AvScalarField<ModelValueSource<M>> ? AvScalarValueType<ModelValueSource<M>, Field> : unknown;
+/** A statement of the model's configuration facts (`json` or `added`), or `never`. */
+type FactsStatementOf<M, Key extends "added" | "json"> = M extends {
+    readonly "~configFacts"?: infer Facts;
+} ? Exclude<Facts, undefined> extends {
+    readonly [K in Key]: infer Statement;
+} ? Statement : never : never;
+/** The shape type the model's facts give Json field `F` of `R`, or `never`. */
+type ShapeFactOf<M, R extends string, F extends string> = FactsStatementOf<M, "json"> extends infer Json ? R extends keyof Json ? F extends keyof Json[R] ? Json[R][F] : never : never : never;
+/** The Contract field the model's facts state for added field `F` of `R`, or `never`. */
+type AddedFactOf<M, R extends string, F extends string> = FactsStatementOf<M, "added"> extends infer Added ? R extends keyof Added ? F extends keyof Added[R] ? Added[R][F] : never : never : never;
+/** The value a compute stage of added (VIRTUAL) field `F` returns, read off its fact. */
+type AddedComputedValueOf<M extends AvAdapterModel, R extends string, F extends string> = AddedFactOf<M, R, F> extends infer Field extends AvScalarField<ModelValueSource<M>> ? [Field] extends [never] ? unknown : AvScalarValueType<ModelValueSource<M>, Field> : unknown;
+/** A discovered scalar field's stages, its `validators` and `compute` typed by the field. */
+type KnownScalarFieldPipeline<M extends AvAdapterModel, Cfg, R extends AvConfigResourceKey<M>, Field, Value> = Field extends {
     readonly type: {
         readonly scalar: "json";
     };
-} ? Omit<AvScalarFieldPipeline<M, Cfg, R>, "validators"> & {
+} ? Omit<AvScalarFieldPipeline<M, Cfg, R, AvZCheck, Value>, "validators"> & {
     /** A Json field's checks are in its shape (`definition.json`). */
     readonly validators?: never;
-} : AvScalarFieldPipeline<M, Cfg, R, FieldCheckOf<Field>>;
+} : AvScalarFieldPipeline<M, Cfg, R, FieldCheckOf<Field>, Value>;
 /** The root entry one effective field name admits. */
 type RootFieldConfigFor<M extends AvAdapterModel, Cfg, R extends AvConfigResourceKey<M>, F extends string> = string extends F ? AvConfigRootField<M, Cfg, R> : F extends AvAdapterFieldKey<M, R> ? M["resources"][R]["fields"][F] extends {
     readonly kind: "relation";
@@ -91,10 +119,10 @@ type RootFieldConfigFor<M extends AvAdapterModel, Cfg, R extends AvConfigResourc
     readonly pipelines?: AvRelationFieldPipeline<M, R>;
 } : {
     readonly definition?: AvConfigKnownFieldDefinition<M["resources"][R]["fields"][F]>;
-    readonly pipelines?: KnownScalarFieldPipeline<M, Cfg, R, M["resources"][R]["fields"][F]>;
+    readonly pipelines?: KnownScalarFieldPipeline<M, Cfg, R, M["resources"][R]["fields"][F], ComputedValueOf<M, R, F>>;
 } : {
     readonly definition: AvConfigAddedFieldDefinition<M>;
-    readonly pipelines?: AvScalarFieldPipeline<M, Cfg, R>;
+    readonly pipelines?: AvScalarFieldPipeline<M, Cfg, R, AvZCheck, AddedComputedValueOf<M, R, F>>;
 };
 /** The overlay entry one effective field name admits. */
 type OverlayFieldConfigFor<M extends AvAdapterModel, Cfg, R extends AvConfigResourceKey<M>, F extends string> = string extends F ? AvConfigOverlayField<M, Cfg, R> : F extends AvAdapterFieldKey<M, R> ? M["resources"][R]["fields"][F] extends {
@@ -102,8 +130,11 @@ type OverlayFieldConfigFor<M extends AvAdapterModel, Cfg, R extends AvConfigReso
 } ? {
     readonly pipelines?: AvRelationFieldPipeline<M, R>;
 } : {
-    readonly pipelines?: KnownScalarFieldPipeline<M, Cfg, R, M["resources"][R]["fields"][F]>;
-} : AvConfigOverlayField<M, Cfg, R>;
+    readonly pipelines?: KnownScalarFieldPipeline<M, Cfg, R, M["resources"][R]["fields"][F], ComputedValueOf<M, R, F>>;
+} : {
+    /** The field's stages, added to the root's. */
+    readonly pipelines?: AvScalarFieldPipeline<M, Cfg, R, AvZCheck, AddedComputedValueOf<M, R, F>>;
+};
 /** A Resource's fields at one layer, keyed by its effective field names. */
 export type AvConfigResourceFields<in out M extends AvAdapterModel = AvAdapterModel, in out Cfg = AvConfigAny, in out R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>, Kind extends AvConfigLayerKind = "root"> = {
     readonly [F in AvEffectiveFieldKey<M, Cfg, R>]?: Kind extends "root" ? RootFieldConfigFor<M, Cfg, R, F> : OverlayFieldConfigFor<M, Cfg, R, F>;
@@ -111,7 +142,7 @@ export type AvConfigResourceFields<in out M extends AvAdapterModel = AvAdapterMo
 /** One Resource's tree: its stages, operations, transactions and fields. */
 export type AvConfigResource<in out M extends AvAdapterModel = AvAdapterModel, in out Cfg = AvConfigAny, in out R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>, Kind extends AvConfigLayerKind = "root", Layer extends AvConfigLayerName = LayerOfKind<Kind>> = {
     /** Stages that run for every operation of this Resource. */
-    readonly pipelines?: AvPipeline<NoInfer<M>, R>;
+    readonly pipelines?: NoInfer<AvPipeline<M, R>>;
     /** Per family, and per variant under its family. */
     readonly operations?: AvConfigOperations<M, R, Layer>;
     /** Stages that run once per transaction with a top-level step on this Resource. */

package/dist/config/stage-type.eraser.d.ts

@@ -1,3 +1,4 @@
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
 import type { AvComputeCreate, AvComputeRead, AvComputeUpdate } from "../runtime/field-compute.js";
 import type { AvScalarFieldPipeline } from "./field-pipeline-config.js";
 import type { AvPipeline, AvTransactionPipeline } from "./pipeline-config.js";
@@ -11,14 +12,16 @@ type ErasedStageGroup<G, Wide> = G extends object ? {
 } : G;
 /** A field's `compute`, by phase; a read stage's `dependsOn` kept. */
 type ErasedCompute<C> = C extends object ? {
-    [K in keyof C]: K extends "create" ? AvComputeCreate : K extends "update" ? AvComputeUpdate : K extends "read" ? C[K] extends {
+    [K in keyof C]: K extends "create" ? AvComputeCreate<AvAdapterModel, ReturnedValue<C[K]>> : K extends "update" ? AvComputeUpdate<AvAdapterModel, ReturnedValue<C[K]>> : K extends "read" ? C[K] extends {
         readonly compute: unknown;
     } ? {
-        [D in keyof C[K]]: D extends "compute" ? ComputeReadStage : C[K][D];
-    } : ComputeReadStage : C[K];
+        [D in keyof C[K]]: D extends "compute" ? ComputeReadStage<ReturnedValue<C[K][D]>> : C[K][D];
+    } : ComputeReadStage<ReturnedValue<C[K]>> : C[K];
 } : C;
+/** The value an authored compute stage returns, `undefined` and a promise taken off. */
+type ReturnedValue<Stage> = Stage extends (context: never) => infer Returned ? Exclude<Awaited<Returned>, undefined> : unknown;
 /** A read compute stage's function form, for any model. */
-type ComputeReadStage = Parameters<Extract<AvComputeRead, (context: never) => unknown>>[0] extends infer Context ? (context: Context) => unknown : never;
+type ComputeReadStage<Value = unknown> = Parameters<Extract<AvComputeRead, (context: never) => unknown>>[0] extends infer Context ? (context: Context) => Value | void | Promise<Value | void> : never;
 /** A variant's level: its `pipelines` erased, `forceTransaction` kept. */
 type ErasedVariant<V> = V extends object ? {
     [K in keyof V]: K extends "pipelines" ? ErasedPipelines<V[K], AvPipeline> : V[K];

package/dist/contracts/json-schema-type.emitter.d.ts

@@ -0,0 +1,9 @@
+type Schema = Readonly<Record<string, unknown>>;
+/**
+ * The TypeScript type a Json Shape schema describes, as source text.
+ *
+ * @throws Error on a schema outside the accepted forms — unreachable for a
+ *   ClientContract that passed the structure check.
+ */
+export declare function jsonSchemaType(schema: Schema): string;
+export {};

package/dist/contracts/json-schema-type.emitter.js

@@ -0,0 +1,58 @@
+const SCALAR_TYPES = {
+    string: "string",
+    number: "number",
+    integer: "number",
+    boolean: "boolean",
+    null: "null",
+};
+const plain = (text) => ({ text, union: false });
+function unionOf(members) {
+    return members.length === 1
+        ? members[0]
+        : { text: members.map((member) => member.text).join(" | "), union: true };
+}
+function operand(type) {
+    return type.union ? `(${type.text})` : type.text;
+}
+function emitted(schema) {
+    if (Object.hasOwn(schema, "const")) {
+        return plain(JSON.stringify(schema.const));
+    }
+    if (Array.isArray(schema.enum)) {
+        return unionOf(schema.enum.map((value) => plain(JSON.stringify(value))));
+    }
+    for (const keyword of ["anyOf", "oneOf"]) {
+        const options = schema[keyword];
+        if (Array.isArray(options)) {
+            return unionOf(options.map((option) => emitted(option)));
+        }
+    }
+    const type = schema.type;
+    if (typeof type === "string" && Object.hasOwn(SCALAR_TYPES, type)) {
+        return plain(SCALAR_TYPES[type]);
+    }
+    if (type === "array") {
+        if (Array.isArray(schema.prefixItems)) {
+            return plain(`[${schema.prefixItems.map((item) => emitted(item).text).join(", ")}]`);
+        }
+        return plain(`${operand(emitted(schema.items))}[]`);
+    }
+    if (type === "object") {
+        const properties = schema.properties;
+        if (properties === undefined) {
+            return plain(`{ [key: string]: ${emitted(schema.additionalProperties).text} }`);
+        }
+        const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+        const members = Object.keys(properties).map((key) => {
+            const member = emitted(properties[key]).text;
+            return required.has(key)
+                ? `${JSON.stringify(key)}: ${member}`
+                : `${JSON.stringify(key)}?: ${member} | undefined`;
+        });
+        return plain(members.length === 0 ? "{}" : `{ ${members.join("; ")} }`);
+    }
+    throw new Error(`a Json Shape schema outside the accepted forms reached the emitter: ${JSON.stringify(schema)}`);
+}
+export function jsonSchemaType(schema) {
+    return emitted(schema).text;
+}

package/dist/framework/contract-view.d.ts

@@ -57,7 +57,13 @@ type LayeredModelField<Field, FieldConfig> = Field extends {
     readonly kind: "scalar";
 } ? [FieldConfig] extends [never] ? Field extends {
     readonly capabilities: infer Capabilities;
-} ? "select" extends keyof Capabilities ? Field : ConfiguredModelField<Field, FieldConfig> : ConfiguredModelField<Field, FieldConfig> : ConfiguredModelField<Field, FieldConfig> : Field;
+} ? "select" extends keyof Capabilities ? Field : ConfiguredModelField<Field, FieldConfig> : ConfiguredModelField<Field, FieldConfig> : FieldConfig extends {
+    readonly capabilities: unknown;
+} ? ConfiguredModelField<Field, FieldConfig> : Field extends {
+    readonly capabilities: {
+        readonly select: unknown;
+    };
+} ? Field & ConfiguredJsonShape<FieldConfig> : ConfiguredModelField<Field, FieldConfig> : Field;
 /**
  * A discovered scalar with its configured capabilities applied, member by member,
  * and its configured Json Shape, whose type its value takes.
@@ -70,9 +76,22 @@ type ConfiguredJsonShape<FieldConfig> = [FieldConfig] extends [never] ? unknown
     readonly json: JsonShape<infer Value>;
 } ? {
     readonly json: ShapedJsonSchema<Value>;
+} : FieldConfig extends {
+    readonly json: {
+        readonly "~jsonType": infer Value;
+    };
+} ? {
+    readonly json: ShapedJsonSchema<Value>;
 } : unknown;
-/** A scalar the configuration adds, exactly as the configuration states it. */
-type AddedField<FieldConfig> = {
+/**
+ * A scalar the configuration adds, exactly as the configuration states it; a
+ * fact the build states (`"~configFacts"`) is the Contract field already.
+ */
+type AddedField<FieldConfig> = FieldConfig extends {
+    readonly kind: "scalar";
+} ? FieldConfig : DefinedField<FieldConfig>;
+/** A scalar a configuration's `definition` adds. */
+type DefinedField<FieldConfig> = {
     readonly kind: "scalar";
     readonly type: FieldConfig extends {
         readonly type: infer Type;
@@ -246,10 +265,9 @@ export type RequirementsLessComputed<Requirements, Computed> = [
 /** One member of a statement less `Computed`: its names, or its groups. */
 type LessComputed<Member, List, Computed> = Member extends "required" ? NamesLessComputed<List, Computed> : GroupsLessComputed<List, Computed>;
 /** A name tuple less `Computed`, still a tuple. */
-type NamesLessComputed<Names, Computed> = Names extends readonly [
-    infer Head,
-    ...infer Rest
-] ? Head extends Computed ? NamesLessComputed<Rest, Computed> : readonly [Head, ...NamesLessComputed<Rest, Computed>] : readonly [];
+type NamesLessComputed<Names, Computed> = Names extends readonly unknown[] ? number extends Names["length"] ? NamesListLessComputed<Exclude<Names[number], Computed>> : Names extends readonly [infer Head, ...infer Rest] ? Head extends Computed ? NamesLessComputed<Rest, Computed> : readonly [Head, ...NamesLessComputed<Rest, Computed>] : readonly [] : readonly [];
+/** The names left, as a statement's non-empty list, or the empty tuple. */
+type NamesListLessComputed<Names> = [Names] extends [never] ? readonly [] : RequiredNames<Names>;
 /** A group tuple less `Computed` reference fields; a group left with none is dropped. */
 type GroupsLessComputed<Groups, Computed> = Groups extends readonly [
     infer Group,
@@ -508,4 +526,52 @@ export type AvContractApplicationView<M extends AvAdapterModel, Cfg = AvConfigAn
 export type ClientContractView<M extends AvAdapterModel, Cfg = AvConfigAny> = [
     Cfg
 ] extends [unknown] ? [ManagedBlock<RootBlock<Cfg, "resources">>] extends [never] ? AvContractView<M, ViewBlock<ResourcesBlock<Cfg>>, ExposureStyleOf<ExposedOf<Cfg>>, ExemptionsOf<Cfg>, ExposureStyleOf<ExposedOf<OverlayOf<Cfg, "client">>>, ExemptionsOf<OverlayOf<Cfg, "client">>, ViewBlock<OverlayResourcesBlock<Cfg, "client">>, GovernedBlock<Cfg>> : AvManagedContractView<M, ViewBlock<ResourcesBlock<Cfg>>, ExposureStyleOf<ExposedOf<Cfg>>, ExemptionsOf<Cfg>, ExposureStyleOf<ExposedOf<OverlayOf<Cfg, "client">>>, ExemptionsOf<OverlayOf<Cfg, "client">>, ViewBlock<OverlayResourcesBlock<Cfg, "client">>, GovernedBlock<Cfg>, ManagedBlock<RootBlock<Cfg, "resources">>, ManagedBlock<RootBlock<Cfg, "resources">>> : never;
+/**
+ * The Contract view a pipeline stage's `ctx` and typed `$args` read: the model's
+ * Application Contract view with the configuration's facts the model's type
+ * carries applied (each shaped Json field typed by its shape, each added field
+ * present); the view with no configuration when it carries none.
+ */
+export type AvModelFactsView<M extends AvAdapterModel> = [M] extends [unknown] ? AvContractView<M, FactsBlockOf<M>, "omit", never, "omit", never, never> : never;
+/** The facts `M`'s type carries, as a view's root `fields` block; `never` when it carries none. */
+type FactsBlockOf<M> = M extends {
+    readonly "~configFacts"?: infer Facts;
+} ? Exclude<Facts, undefined> extends {
+    readonly added: infer Added;
+    readonly json: infer Json;
+} ? string extends keyof Added | keyof Json ? never : [keyof Added | keyof Json] extends [never] ? never : {
+    readonly [R in keyof Json | keyof Added]: {
+        readonly fields: {
+            readonly [F in FactKey<Json, R> | FactKey<Added, R>]: {
+                readonly definition: F extends FactKey<Json, R> ? {
+                    readonly json: {
+                        readonly "~jsonType": Json[R & keyof Json][F];
+                    };
+                } : Added[R & keyof Added][F & keyof Added[R & keyof Added]];
+            };
+        };
+    };
+} : never : never;
+/** The fields Resource `R` has facts for in one statement (`json` or `added`). */
+type FactKey<Statement, R> = R extends keyof Statement ? keyof Statement[R] : never;
+/**
+ * The Contract view a stage's ctx calls and compute's reads are typed by: the
+ * model's view with its configuration facts applied ({@link AvModelFactsView}),
+ * its create requirements less `Lift` (`"<Resource>.<field>"`).
+ */
+export type ContextContractView<M extends AvAdapterModel, Lift extends string> = [Lift] extends [never] ? AvModelFactsView<M> : AvContractView<M, FactsBlockOf<M>, "omit", never, "omit", never, {
+    readonly [R in LiftedResourceOf<Lift>]: {
+        readonly fields: {
+            readonly [F in LiftedFieldOf<Lift, R>]: {
+                readonly pipelines: {
+                    readonly compute: {
+                        readonly create: true;
+                    };
+                };
+            };
+        };
+    };
+}>;
+/** The Resources `Lift` names a field of. */
+type LiftedResourceOf<Lift extends string> = Lift extends `${infer R}.${string}` ? R : never;
 export {};

package/dist/framework/framework.factory.js

@@ -1,8 +1,9 @@
 import { compileContracts, } from "../compiler/contract.compiler.js";
 import { validateManagedDeletes } from "../compiler/managed-elsewhere.validator.js";
-import { computedFieldsOf, warnOnStaleComputedFields, } from "../config/computed-fields.js";
+import { computedFieldsOf, staleComputedFields, warnOnStaleGeneratedTypes, } from "../config/computed-fields.js";
 import { resolveFrameworkConfig, } from "../config/config.resolver.js";
 import { validateFrameworkConfig } from "../config/config.validator.js";
+import { staleConfigFacts } from "../config/config-facts.js";
 import { validateForcedOperations } from "../config/forced-operation.validator.js";
 import { AVENTARA_PROTOCOL_VERSION } from "../contracts/contract-protocol.js";
 import { recordAccessProvider } from "../policy/access-provider.registry.js";
@@ -46,13 +47,22 @@ export async function createFramework(config) {
         ]);
     }
     const resolvedConfig = resolveFrameworkConfig(config);
-    warnOnStaleComputedFields(config.adapter.computedFields, computedFieldsOf({
+    const staleComputed = staleComputedFields(config.adapter.computedFields, computedFieldsOf({
         trees: resolvedConfig.trees,
         agentExtends: resolvedConfig.agent.parent,
     }));
     const compilation = (config.prebuilt === undefined
         ? undefined
         : await prebuiltCompilation(config.prebuilt, model, config, resolvedConfig)) ?? (await compileContracts(model, resolvedConfig));
+    const staleParagraphs = [staleComputed];
+    try {
+        if (compilation.ok) {
+            staleParagraphs.push(staleConfigFacts(config.adapter.configFacts, compilation.contracts.core));
+        }
+    }
+    finally {
+        warnOnStaleGeneratedTypes(staleParagraphs);
+    }
     if (!compilation.ok) {
         throw new AvConstructionError("contract-compilation", compilation.diagnostics);
     }

package/dist/framework/operation-facade.d.ts

@@ -13,7 +13,7 @@ import type { AvState } from "../runtime/request-state.js";
 import type { AvSqlStatementBuilder } from "../transactions/sql-statement.js";
 import type { AvTransactionResponse } from "../transactions/transaction-response.js";
 import type { AccessProviderOf, ServerClientAccess } from "./access-facade.js";
-import type { AvContractApplicationView, ClientContractView, PreComputeView } from "./contract-view.js";
+import type { AvContractApplicationView, ClientContractView, ContextContractView } from "./contract-view.js";
 /**
  * A model whose Resource names are not literal — the abstract `AvAdapterModel` behind
  * the default `AvFramework` — has no Contract to type a call against, so a surface over
@@ -232,28 +232,26 @@ export type ServerClientTransactionBuilders<M extends AvAdapterModel, Cfg> = Ser
  * field the root's or the application's `compute.create` fills, when the model's
  * type states them.
  */
-export type AvContextOperations<M extends AvAdapterModel> = ContextFacade<ContextView<AvContractApplicationView<M>, AvContextComputeLift<M>>>;
-/** The ctx executor's view: `C`, its create requirements less `Lift`. */
-type ContextView<C, Lift extends string> = [Lift] extends [never] ? C : PreComputeView<C, Lift>;
+export type AvContextOperations<M extends AvAdapterModel> = ContextFacade<ContextContractView<M, AvContextComputeLift<M>>>;
 type ContextFacade<C> = C extends AvContract ? string extends AvResourceKey<C> ? unknown : {
     readonly [R in AvResourceKey<C>]: {
-        readonly [F in keyof AvOperationGrammar<C>[R]]: {
-            readonly [V in keyof AvOperationGrammar<C>[R][F]]: AvOperationCall<C, R, AvOperationGrammar<C>[R][F][V] & AvOperationIdentity, AvApplicationScalarForms, AvApplicationScalarForms, never>;
-        };
+        readonly [F in FamilyKey<C, R>]: AvContextFamilyFacade<C, R, F>;
     };
 } : never;
+/** `ctx.<Resource>.<family>` in a pipeline stage: one direct call per variant, application forms. */
+export type AvContextFamilyFacade<in out C extends AvContract, in out R extends AvResourceKey<C>, in out F extends FamilyKey<C, R>> = {
+    readonly [V in keyof AvOperationGrammar<C>[R][F]]: AvOperationCall<C, R, AvOperationGrammar<C>[R][F][V] & AvOperationIdentity, AvApplicationScalarForms, AvApplicationScalarForms, never>;
+};
 /**
  * The Resources of compute's read-only ctx: `ctx.<Resource>.find.<variant>(args)`
  * only (`find.count` included).
  */
-export type AvComputeReads<M extends AvAdapterModel> = ComputeReadFacade<AvContractApplicationView<M>>;
-type ComputeReadFacade<C> = C extends AvContract ? string extends AvResourceKey<C> ? unknown : {
-    readonly [R in AvResourceKey<C>]: {
-        readonly [F in Extract<keyof AvOperationGrammar<C>[R], "find">]: {
-            readonly [V in keyof AvOperationGrammar<C>[R][F]]: AvOperationCall<C, R, AvOperationGrammar<C>[R][F][V] & AvOperationIdentity, AvApplicationScalarForms, AvApplicationScalarForms, never>;
-        };
+export type AvComputeReads<M extends AvAdapterModel> = ComputeReadFacade<AvContextOperations<M>>;
+type ComputeReadFacade<Operations> = {
+    readonly [R in keyof Operations]: {
+        readonly [F in Extract<keyof Operations[R], "find">]: Operations[R][F];
     };
-} : never;
+};
 /** Builds the request one façade call hands to `execute`, under its request id and state. */
 export type FacadeRequest = (resource: string, identity: AvOperationIdentity, args: unknown, requestId: string, state: AvState | undefined) => AvOperationRequest;
 type FacadeExecutor = (request: AvOperationRequest, caller: PolicyCaller | undefined) => Promise<AvOperationResponse>;

package/dist/index.d.ts

@@ -34,7 +34,7 @@ export { createFramework } from "./framework/framework.factory.js";
 export type { AvFramework } from "./framework/framework.js";
 export type { AvConstructionDiagnostic, AvConstructionStage, } from "./framework/framework-construction.error.js";
 export { AvConstructionError } from "./framework/framework-construction.error.js";
-export type { AvApplicationFacade, AvApplicationFamilyFacade, AvApplicationPlainCall, AvApplicationProjectingCall, AvApplicationResourceFacade, AvAppTxFacade, AvAppTxFamilyFacade, AvAppTxPlainCall, AvAppTxProjectingCall, AvAppTxResourceFacade, AvClientFacade, AvClientFamilyFacade, AvClientPlainCall, AvClientProjectingCall, AvClientResourceFacade, AvClientTxFacade, AvClientTxFamilyFacade, AvClientTxPlainCall, AvClientTxProjectingCall, AvClientTxResourceFacade, AvServerClientFacade, AvServerClientFamilyFacade, AvServerClientPlainCall, AvServerClientProjectingCall, AvServerClientResourceFacade, AvServerClientTxFacade, AvServerClientTxFamilyFacade, AvServerClientTxPlainCall, AvServerClientTxProjectingCall, AvServerClientTxResourceFacade, } from "./framework/operation-facade.js";
+export type { AvApplicationFacade, AvApplicationFamilyFacade, AvApplicationPlainCall, AvApplicationProjectingCall, AvApplicationResourceFacade, AvAppTxFacade, AvAppTxFamilyFacade, AvAppTxPlainCall, AvAppTxProjectingCall, AvAppTxResourceFacade, AvClientFacade, AvClientFamilyFacade, AvClientPlainCall, AvClientProjectingCall, AvClientResourceFacade, AvClientTxFacade, AvClientTxFamilyFacade, AvClientTxPlainCall, AvClientTxProjectingCall, AvClientTxResourceFacade, AvContextFamilyFacade, AvServerClientFacade, AvServerClientFamilyFacade, AvServerClientPlainCall, AvServerClientProjectingCall, AvServerClientResourceFacade, AvServerClientTxFacade, AvServerClientTxFamilyFacade, AvServerClientTxPlainCall, AvServerClientTxProjectingCall, AvServerClientTxResourceFacade, } from "./framework/operation-facade.js";
 export { avLazy } from "./framework/operation-set.runner.js";
 export type { AvCreateDataInput, AvCursorInput, AvFieldKey, AvIncludeInput, AvNoAdvertisedMember, AvNullsOrder, AvOperationArgumentMap, AvOperationArgumentsFor, AvOrderByEntry, AvOrderByInput, AvProjectionEntry, AvRelationProjectionInput, AvResourceKey, AvScalarFilterOperands, AvScalarOrderInput, AvScalarWhereInput, AvSelectInput, AvSortDirection, AvUniqueWhereInput, AvUpdateDataInput, AvWhereInput, } from "./operations/operation-arguments.js";
 export type { AvDeferredOperationCall, AvOperationCall, AvOperationGrammar, AvOperationSlot, } from "./operations/operation-call.js";

package/dist/internal.d.ts

@@ -15,6 +15,7 @@ export type { AvAdapterSqlStatement, AvAdapterSqlValue, } from "./adapters/adapt
 export type { AvAdapterTransactionExecutor } from "./adapters/adapter-transaction-executor.interface.js";
 export { compileContracts } from "./compiler/contract.compiler.js";
 export { resolveFrameworkConfig } from "./config/config.resolver.js";
+export { configFactsOf } from "./config/config-facts.js";
 export { canonicalJson } from "./contracts/canonical-json.writer.js";
 export { PROJECTION_SCOPES, WRITE_SCOPES } from "./contracts/capability.js";
 export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
@@ -25,6 +26,7 @@ export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
 export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
 export { advertisedDirectives, advertisedReducers } from "./contracts/field.js";
 export { projectJsonValue } from "./contracts/json-schema.projector.js";
+export { jsonSchemaType } from "./contracts/json-schema-type.emitter.js";
 export { LIFECYCLE_TRAITS } from "./contracts/lifecycle-trait.js";
 export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from "./contracts/resource-operations.js";
 export { BUILT_IN_SCALARS } from "./contracts/scalar.js";

package/dist/internal.js

@@ -1,5 +1,6 @@
 export { compileContracts } from "./compiler/contract.compiler.js";
 export { resolveFrameworkConfig } from "./config/config.resolver.js";
+export { configFactsOf } from "./config/config-facts.js";
 export { canonicalJson } from "./contracts/canonical-json.writer.js";
 export { PROJECTION_SCOPES, WRITE_SCOPES } from "./contracts/capability.js";
 export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
@@ -9,6 +10,7 @@ export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
 export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
 export { advertisedDirectives, advertisedReducers } from "./contracts/field.js";
 export { projectJsonValue } from "./contracts/json-schema.projector.js";
+export { jsonSchemaType } from "./contracts/json-schema-type.emitter.js";
 export { LIFECYCLE_TRAITS } from "./contracts/lifecycle-trait.js";
 export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from "./contracts/resource-operations.js";
 export { BUILT_IN_SCALARS } from "./contracts/scalar.js";

package/dist/operations/operation-arguments.d.ts

@@ -1,6 +1,7 @@
 import type { AvProjectionScope, AvRelationMutationDirective, AvScalarFilterOperator, AvScalarMutationDirective, AvWriteScope, ScalarFilterMode, ToOneRelinkDirective, ToOneRewriteDirective } from "../contracts/capability.js";
 import type { AvContract } from "../contracts/contract.js";
 import type { AvProjectionScopes, AvScalarField } from "../contracts/field.js";
+import type { JsonFieldType } from "../contracts/json-shape.js";
 import type { AvScalarValueType, FieldAtom, ScalarForms } from "../contracts/scalar-value-type.js";
 import type { AvJsonValue } from "../runtime/json-value.js";
 import type { AvTransactionReference, TransactionSlotShape } from "../transactions/transaction-reference.js";
@@ -67,10 +68,28 @@ type KeysWithCapability<C extends AvContract, K extends AvResourceKey<C>, Keys e
  * values. Enum values are their member union under every map.
  */
 type UnstatedForms = ScalarForms;
-/** Field `F`'s value under `Forms`, the same as in results. */
-type ScalarValueAt<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Forms extends ScalarForms> = ScalarFieldAt<C, K, F> extends infer Field extends AvScalarField<C> ? AvScalarValueType<C, Field, Forms> : never;
+/** Field `F`'s value under `Forms`, as in results; a shaped Json value read-only. */
+type ScalarValueAt<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Forms extends ScalarForms> = ScalarFieldAt<C, K, F> extends infer Field extends AvScalarField<C> ? ReadonlyShaped<Field, AvScalarValueType<C, Field, Forms>> : never;
 /** One entry of field `F`'s value — the whole value when `F` is not a list. */
-type ScalarAtomAt<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Forms extends ScalarForms> = FieldAtom<C, ScalarFieldAt<C, K, F>, Forms>;
+type ScalarAtomAt<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Forms extends ScalarForms> = ReadonlyShaped<ScalarFieldAt<C, K, F>, FieldAtom<C, ScalarFieldAt<C, K, F>, Forms>>;
+/** `Value` read-only, deep, when `Field` is a shaped Json field; itself otherwise. */
+type ReadonlyShaped<Field, Value> = Field extends {
+    readonly json: JsonFieldType<unknown>;
+} ? ReadonlyJson<Value> : Value;
+/** A JSON value, every member and every array read-only, deep. */
+type ReadonlyJson<Value> = Value extends object ? [OptionalKeyOf<Value>] extends [never] ? {
+    readonly [K in keyof Value]: ReadonlyJson<Value[K]>;
+} : {
+    readonly [K in Exclude<keyof Value, OptionalKeyOf<Value>>]: ReadonlyJson<Value[K]>;
+} & {
+    readonly [K in OptionalKeyOf<Value>]?: ReadonlyJson<Value[K]>;
+} extends infer Members ? {
+    [K in keyof Members]: Members[K];
+} : never : Value;
+/** An object's optional members; an array has none, nor a record's index signature. */
+type OptionalKeyOf<Value> = Value extends readonly unknown[] ? never : {
+    [K in keyof Value]-?: string extends K ? never : number extends K ? never : Record<never, never> extends Pick<Value, K> ? K : never;
+}[keyof Value];
 /**
  * A `$ref` to a source whose value fits slot shape `Shape` of field `F`, typed in
  * `ReferenceForms` — the forms a source's final data is read in. `never` when

package/dist/prebuilt/core-version.generated.d.ts

@@ -1,2 +1,2 @@
 /** The version of this `@aventara/core`. */
-export declare const CORE_VERSION = "1.0.0-rc.14";
+export declare const CORE_VERSION = "1.0.0-rc.15";

package/dist/prebuilt/core-version.generated.js

@@ -1 +1 @@
-export const CORE_VERSION = "1.0.0-rc.14";
+export const CORE_VERSION = "1.0.0-rc.15";

package/dist/prebuilt/prebuilt-contracts.emitter.js

@@ -26,7 +26,10 @@ const literal = (value) => JSON.stringify(value);
 const key = (name) => name === "__proto__" ? `[${literal(name)}]` : literal(name);
 export function emitPrebuiltContracts(prebuilt) {
     const resources = Object.entries(prebuilt.fingerprints.resources).map(([name, fingerprint]) => `\t\t\t${key(name)}: ${literal(fingerprint)},\n`);
-    return `// Generated by @aventara/core from the configuration and the adapter's model. Do not edit: regenerate it.
+    return `// biome-ignore-all format: generated output
+// biome-ignore-all lint: generated output
+// biome-ignore-all assist/source/organizeImports: generated output
+// Generated by @aventara/core from the configuration and the adapter's model. Do not edit: regenerate it.
 import type { AvPrebuiltContracts } from "@aventara/core";
 
 export const aventaraContracts: AvPrebuiltContracts = {
@@ -45,6 +48,5 @@ ${resources.join("")}\t\t},
 \t\tclient: ${literal(prebuilt.contracts.client)},
 \t\tagent: ${literal(prebuilt.contracts.agent)},
 \t},
-};
-`;
+};`;
 }

package/dist/runtime/field-check.evaluator.js

@@ -12,9 +12,10 @@ const HHMM = "(?:[01]\\d|2[0-3]):[0-5]\\d";
 const IPV6_ALPHABET = /^[0-9a-fA-F:.]+$/;
 const CREDIT_CARD = /^\d(?:[ -]?\d){11,18}$/;
 const IBAN = /^[A-Z]{2}(?!00|01|99)\d{2}[A-Z0-9]{11,30}$/;
+const EMOJI_SOURCE = "^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$";
 const FORMAT_PATTERNS = {
     email: /^(?:[A-Za-z0-9_'+-]+\.)*[A-Za-z0-9_'+-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9-]*\.)+[A-Za-z]{2,}$/,
-    emoji: new RegExp("^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$", "u"),
+    emoji: new RegExp(EMOJI_SOURCE, "u"),
     uuid: /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/,
     guid: /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/,
     nanoid: /^[a-zA-Z0-9_-]{21}$/,

package/dist/runtime/field-compute.d.ts

@@ -21,33 +21,33 @@ export type AvComputeContext<M extends AvAdapterModel = AvAdapterModel> = AvComp
  * it. It receives the incoming `data` and returns the value to store; returning
  * `undefined` keeps the current value.
  */
-export type AvComputeCreate<M extends AvAdapterModel = AvAdapterModel> = (context: {
+export type AvComputeCreate<M extends AvAdapterModel = AvAdapterModel, Value = unknown> = (context: {
     readonly field: string;
     readonly value: unknown;
     readonly data: Readonly<Record<string, unknown>>;
     readonly ctx: AvComputeContext<M>;
-}) => unknown | Promise<unknown>;
+}) => Value | void | Promise<Value | void>;
 /**
  * Computes a field's value when a row is updated, whether or not the caller sent
  * it. It receives the incoming `data` and returns the value to store; returning
  * `undefined` keeps the current value.
  */
-export type AvComputeUpdate<M extends AvAdapterModel = AvAdapterModel> = (context: {
+export type AvComputeUpdate<M extends AvAdapterModel = AvAdapterModel, Value = unknown> = (context: {
     readonly field: string;
     readonly value: unknown;
     readonly data: Readonly<Record<string, unknown>>;
     readonly ctx: AvComputeContext<M>;
-}) => unknown | Promise<unknown>;
+}) => Value | void | Promise<Value | void>;
 /**
  * Computes a field's value when a row is read. It receives the stored `record`
  * and returns the value to return; returning `undefined` keeps the current value.
  */
-export type ComputeReadFunction<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>> = (context: {
+export type ComputeReadFunction<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>, Value = unknown> = (context: {
     readonly field: AvEffectiveFieldKey<M, Cfg, R>;
     readonly value: unknown;
     readonly record: Readonly<Record<AvEffectiveFieldKey<M, Cfg, R>, unknown>>;
     readonly ctx: AvComputeContext<M>;
-}) => unknown | Promise<unknown>;
+}) => Value | void | Promise<Value | void>;
 /** The fields of Resource `R` the adapter stores as scalars: what `dependsOn` may name. */
 type StoredScalarKey<M extends AvAdapterModel, R extends AvConfigResourceKey<M>> = string extends AvAdapterFieldKey<M, R> ? string : {
     [F in AvAdapterFieldKey<M, R>]: M["resources"][R]["fields"][F] extends {
@@ -58,8 +58,8 @@ type StoredScalarKey<M extends AvAdapterModel, R extends AvConfigResourceKey<M>>
  * A read compute stage: a compute function, or `{ compute, dependsOn }` naming
  * the fields it reads.
  */
-export type AvComputeRead<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>> = ComputeReadFunction<M, Cfg, R> | {
+export type AvComputeRead<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>, Value = unknown> = ComputeReadFunction<M, Cfg, R, Value> | {
     readonly dependsOn?: readonly StoredScalarKey<M, R>[];
-    readonly compute: ComputeReadFunction<M, Cfg, R>;
+    readonly compute: ComputeReadFunction<M, Cfg, R, Value>;
 };
 export {};

package/dist/runtime/pipeline.d.ts

@@ -4,8 +4,8 @@ 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, PreComputeView } from "../framework/contract-view.js";
+import type { AvApplicationScalarForms, ScalarForms } from "../contracts/scalar-value-type.js";
+import type { AvModelFactsView, PreComputeView } 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";
@@ -42,23 +42,31 @@ type AvContextFacts = {
     readonly $state: AvState;
 };
 /**
- * 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.
+ * The arguments a variant's hooks and interceptors are told: the operation's
+ * arguments under the model's Application Contract view, in the application
+ * forms, every reference resolved to its value. `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> = 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, {
+export type AvStageArguments<M extends AvAdapterModel, R extends string, F extends AvOperationFamily, V extends string> = StageArgumentsOf<AvModelFactsView<M>, R, F, V, never>;
+/**
+ * The arguments of operation `F`.`V` on `R` under the Contract view `C`, a
+ * reference position admitting an unresolved `$ref` in `References`' forms
+ * (`never`: none).
+ */
+type StageArgumentsOf<C, R extends string, F extends AvOperationFamily, V extends string, References extends ScalarForms> = string extends R ? unknown : C extends AvContract ? StageArgumentsIn<C, R, F, V, References> : unknown;
+/** {@link StageArgumentsOf} once `C` is known to be a Contract. */
+type StageArgumentsIn<C extends AvContract, R extends string, F extends AvOperationFamily, V extends string, References extends ScalarForms> = R extends AvResourceKey<C> ? AvOperationArgumentsFor<C, R, Extract<AvOperationIdentity, {
     readonly family: F;
     readonly variant: V;
-}>, AvApplicationScalarForms, AvApplicationScalarForms> : unknown;
+}>, AvApplicationScalarForms, References> : 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).
+ * `compute.create` fills (`Lift`, as `"<Resource>.<field>"`; `string`: any),
+ * and before a plan step's references are resolved, so a reference position
+ * admits an unresolved `$ref`.
  */
-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>;
+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" ? StageArgumentsOf<AvModelFactsView<M>, R, F, V, AvApplicationScalarForms> : [Lift] extends [never] ? StageArgumentsOf<AvModelFactsView<M>, R, F, V, AvApplicationScalarForms> : StageArgumentsOf<PreComputeView<AvModelFactsView<M>, Lift>, R, F, V, AvApplicationScalarForms>;
 /**
  * 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
@@ -88,9 +96,11 @@ 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; 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`.
+     * operation's arguments ({@link AvStageArguments}), deep read-only, every
+     * reference resolved; in a guard, a pipe or a filter a create may lack the fields
+     * `compute.create` fills and a reference position may hold an unresolved `$ref`
+     * ({@link AvPreComputeStageArguments}: write compute has not run, nor reference
+     * resolution); above it, `unknown`.
      */
     readonly $args: AvDeepReadonly<A>;
     /**

package/dist/transactions/transaction-slot-writer.d.ts

@@ -14,7 +14,8 @@ export type TransactionSlotValue = {
  * Installs values at transaction slot paths into one argument view: validated
  * control snapshots at validation, resolved final data at execution. A slot
  * path always names a member below `args`, so the view keeps its own
- * container kind and prototype; only the ancestors of each slot are cloned.
+ * container kind and prototype; only the ancestors of the slots are cloned,
+ * each once, so the cost is linear in the slots and the members they cross.
  */
 export declare function replaceTransactionSlotValues<T>(value: T, operation: number, slots: readonly TransactionSlotValue[]): T;
 export {};

package/dist/transactions/transaction-slot-writer.js

@@ -2,7 +2,55 @@ import { AvTransactionSlotPathError } from "./transaction-slot-path-error.js";
 function slotPathMismatch(violation) {
     throw new AvTransactionSlotPathError(violation);
 }
-function cloneContainerWithReplacement(container, property, replacement) {
+function slotNode(source) {
+    return {
+        source,
+        replaced: false,
+        replacement: undefined,
+        children: new Map(),
+    };
+}
+function layOut(root, path, value) {
+    let node = root;
+    for (let index = 0; index < path.length; index += 1) {
+        if (node.replaced) {
+            node.source = node.replacement;
+            node.replaced = false;
+            node.replacement = undefined;
+        }
+        const container = node.source;
+        if (container === null || typeof container !== "object") {
+            slotPathMismatch("non-object-ancestor");
+        }
+        const property = String(path[index]);
+        if (property === "length" && Array.isArray(container)) {
+            slotPathMismatch("absent-member");
+        }
+        let child = node.children.get(property);
+        if (child === undefined) {
+            const descriptor = Object.getOwnPropertyDescriptor(container, property);
+            if (descriptor === undefined) {
+                slotPathMismatch("absent-member");
+            }
+            child = slotNode("value" in descriptor
+                ? descriptor.value
+                : Reflect.get(container, property));
+            node.children.set(property, child);
+        }
+        node = child;
+    }
+    node.replaced = true;
+    node.replacement = value;
+    node.children.clear();
+}
+function install(node) {
+    if (node.replaced) {
+        return node.replacement;
+    }
+    if (node.children.size === 0) {
+        return node.source;
+    }
+    const container = node.source;
     const array = Array.isArray(container);
     const prototype = Object.getPrototypeOf(container);
     const clone = array ? [] : Object.create(prototype);
@@ -19,54 +67,39 @@ function cloneContainerWithReplacement(container, property, replacement) {
             lengthDescriptor = descriptor;
             continue;
         }
-        const nextDescriptor = key === property
-            ? "value" in descriptor
-                ? { ...descriptor, value: replacement }
-                : {
-                    configurable: descriptor.configurable ?? false,
-                    enumerable: descriptor.enumerable ?? false,
-                    value: replacement,
-                    writable: true,
-                }
-            : descriptor;
-        Object.defineProperty(clone, key, nextDescriptor);
+        const child = typeof key === "string" ? node.children.get(key) : undefined;
+        if (child === undefined) {
+            Object.defineProperty(clone, key, descriptor);
+            continue;
+        }
+        const replacement = install(child);
+        Object.defineProperty(clone, key, "value" in descriptor
+            ? { ...descriptor, value: replacement }
+            : {
+                configurable: descriptor.configurable ?? false,
+                enumerable: descriptor.enumerable ?? false,
+                value: replacement,
+                writable: true,
+            });
     }
     if (lengthDescriptor !== undefined) {
         Object.defineProperty(clone, "length", lengthDescriptor);
     }
     return clone;
 }
-function replaceValueInContainer(container, property, tail, replacement) {
-    const descriptor = Object.getOwnPropertyDescriptor(container, property);
-    if (descriptor === undefined) {
-        return slotPathMismatch("absent-member");
-    }
-    const child = "value" in descriptor ? descriptor.value : Reflect.get(container, property);
-    return cloneContainerWithReplacement(container, property, replaceValueAtPath(child, tail, replacement));
-}
-function replaceValueAtPath(value, path, replacement) {
-    const [head, ...tail] = path;
-    if (head === undefined) {
-        return replacement;
-    }
-    if (value === null || typeof value !== "object") {
-        return slotPathMismatch("non-object-ancestor");
-    }
-    return replaceValueInContainer(value, String(head), tail, replacement);
-}
 export function replaceTransactionSlotValues(value, operation, slots) {
-    let materialized = value;
+    const root = slotNode(value);
     for (const slot of slots) {
         const [operations, index, args, head, ...tail] = slot.path;
         if (operations !== "operations" ||
             index !== operation ||
             args !== "args" ||
             head === undefined ||
-            materialized === null ||
-            typeof materialized !== "object") {
+            value === null ||
+            typeof value !== "object") {
             return slotPathMismatch("slot-prefix");
         }
-        materialized = replaceValueInContainer(materialized, String(head), tail, slot.value);
+        layOut(root, [head, ...tail], slot.value);
     }
-    return materialized;
+    return install(root);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/core",
-  "version": "1.0.0-rc.14",
+  "version": "1.0.0-rc.15",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Core runtime, contract compiler, and extension APIs for Aventara.",
   "type": "module",

package/src/runtime/field-check.evaluator.ts

@@ -72,16 +72,18 @@ const IPV6_ALPHABET = /^[0-9a-fA-F:.]+$/;
 const CREDIT_CARD = /^\d(?:[ -]?\d){11,18}$/;
 const IBAN = /^[A-Z]{2}(?!00|01|99)\d{2}[A-Z0-9]{11,30}$/;
 
+// zod writes this one as a string source: its class mixes a combining mark
+// with the characters it combines with, on purpose, which a literal would
+// trip `noMisleadingCharacterClass` over. A named source rather than a string
+// argument, so no suppression is needed either: the generated client copies
+// this file under its own file-wide one, where a line suppression is unused.
+const EMOJI_SOURCE =
+	"^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$";
+
 const FORMAT_PATTERNS: Readonly<Partial<Record<AvFieldCheckFormat, RegExp>>> = {
 	email:
 		/^(?:[A-Za-z0-9_'+-]+\.)*[A-Za-z0-9_'+-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9-]*\.)+[A-Za-z]{2,}$/,
-	// zod writes this one as a string source: its class mixes a combining mark
-	// with the characters it combines with, on purpose.
-	// biome-ignore lint/complexity/useRegexLiterals: a literal trips noMisleadingCharacterClass
-	emoji: new RegExp(
-		"^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$",
-		"u",
-	),
+	emoji: new RegExp(EMOJI_SOURCE, "u"),
 	uuid: /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/,
 	guid: /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/,
 	nanoid: /^[a-zA-Z0-9_-]{21}$/,