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

package/dist/runtime/computed-read-runtime.js

@@ -1,17 +1,14 @@
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
-import { FrameworkError } from "./framework-error.js";
-import { INTERNAL_FAILURE_MESSAGE } from "./operation-response.js";
+import { AvComputedValueError } from "./computed-value.error.js";
 import { normalizeScalarFieldValue } from "./scalar-runtime.js";
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function readBehavior(value) {
+function readCompute(value) {
     if (typeof value === "function") {
         return { compute: value, dependsOn: [] };
     }
-    if (value === undefined ||
-        value === false ||
-        typeof value.compute !== "function") {
+    if (value === undefined || typeof value.compute !== "function") {
         return undefined;
     }
     return {
@@ -19,6 +16,16 @@ function readBehavior(value) {
         dependsOn: value.dependsOn ?? [],
     };
 }
+function storedScalar(model, resource, field) {
+    const resources = model.resources;
+    const fields = Object.hasOwn(resources, resource)
+        ? resources[resource]?.fields
+        : undefined;
+    const entry = fields !== undefined && Object.hasOwn(fields, field)
+        ? fields[field]
+        : undefined;
+    return isRecord(entry) && entry.kind === "scalar";
+}
 function appendUnique(values, value) {
     if (!values.includes(value)) {
         values.push(value);
@@ -35,18 +42,17 @@ function supportsProjection(request) {
     }
     return request.variant !== "count";
 }
-function addScalarProjection(core, active, behaviors, resourceName, fieldName, adapterSelect, requested, computed) {
+function addScalarProjection(core, model, active, compute, resourceName, fieldName, adapterSelect, requested, computed) {
     const activeField = lookupField(lookupResource(active, resourceName), fieldName);
     if (activeField?.kind !== "scalar") {
         return;
     }
     appendUnique(requested, fieldName);
-    const behavior = readBehavior(behaviors?.[resourceName]?.fields[fieldName]?.read);
-    if (behavior !== undefined) {
+    const stage = readCompute(compute?.[resourceName]?.[fieldName]?.read);
+    if (stage !== undefined) {
         appendUnique(computed, fieldName);
-        for (const dependency of behavior.dependsOn) {
-            const dependencyField = lookupField(lookupResource(core, resourceName), dependency);
-            if (dependencyField?.kind === "scalar") {
+        for (const dependency of stage.dependsOn) {
+            if (storedScalar(model, resourceName, dependency)) {
                 appendUniqueProjection(adapterSelect, dependency);
             }
         }
@@ -71,7 +77,7 @@ function projectionEntry(entry) {
 function withoutProjectionChoice(value) {
     return Object.fromEntries(Object.entries(value).filter(([key]) => key !== "select" && key !== "include"));
 }
-function defaultProjectionLevel(core, active, behaviors, resourceName) {
+function defaultProjectionLevel(core, model, active, compute, resourceName) {
     const activeResource = lookupResource(active, resourceName);
     const adapterSelect = [];
     const requested = [];
@@ -81,7 +87,7 @@ function defaultProjectionLevel(core, active, behaviors, resourceName) {
             if (field.kind !== "scalar" || field.capabilities.select !== true) {
                 continue;
             }
-            addScalarProjection(core, active, behaviors, resourceName, fieldName, adapterSelect, requested, computed);
+            addScalarProjection(core, model, active, compute, resourceName, fieldName, adapterSelect, requested, computed);
         }
     }
     return {
@@ -95,25 +101,25 @@ function defaultProjectionLevel(core, active, behaviors, resourceName) {
         },
     };
 }
-function planRelationProjection(core, active, behaviors, field, value) {
+function planRelationProjection(core, model, active, compute, field, value) {
     if (!isRecord(value)) {
-        return defaultProjectionLevel(core, active, behaviors, field.target);
+        return defaultProjectionLevel(core, model, active, compute, field.target);
     }
     if (Array.isArray(value.select)) {
-        return planSelectLevel(core, active, behaviors, field.target, value.select, true);
+        return planSelectLevel(core, model, active, compute, field.target, value.select, true);
     }
     if (Array.isArray(value.include)) {
-        return planIncludeLevel(core, active, behaviors, field.target, value.include);
+        return planIncludeLevel(core, model, active, compute, field.target, value.include);
     }
-    return defaultProjectionLevel(core, active, behaviors, field.target);
+    return defaultProjectionLevel(core, model, active, compute, field.target);
 }
-function planRelationEntry(core, active, behaviors, resourceName, fieldName, value) {
+function planRelationEntry(core, model, active, compute, resourceName, fieldName, value) {
     const activeField = lookupField(lookupResource(active, resourceName), fieldName);
     const coreField = lookupField(lookupResource(core, resourceName), fieldName);
     if (activeField?.kind !== "relation" || coreField?.kind !== "relation") {
         return undefined;
     }
-    const nested = planRelationProjection(core, active, behaviors, coreField, value);
+    const nested = planRelationProjection(core, model, active, compute, coreField, value);
     return {
         adapterEntry: {
             [fieldName]: {
@@ -128,7 +134,7 @@ function planRelationEntry(core, active, behaviors, resourceName, fieldName, val
         },
     };
 }
-function planSelectLevel(core, active, behaviors, resourceName, select, collectReducers = false) {
+function planSelectLevel(core, model, active, compute, resourceName, select, collectReducers = false) {
     const activeResource = lookupResource(active, resourceName);
     const coreResource = lookupResource(core, resourceName);
     const adapterSelect = [];
@@ -160,11 +166,11 @@ function planSelectLevel(core, active, behaviors, resourceName, select, collectR
             const activeField = lookupField(activeResource, entry);
             const coreField = lookupField(coreResource, entry);
             if (activeField?.kind === "scalar") {
-                addScalarProjection(core, active, behaviors, resourceName, entry, adapterSelect, requested, computed);
+                addScalarProjection(core, model, active, compute, resourceName, entry, adapterSelect, requested, computed);
                 continue;
             }
             if (activeField?.kind === "relation" && coreField?.kind === "relation") {
-                const plannedRelation = planRelationEntry(core, active, behaviors, resourceName, entry, undefined);
+                const plannedRelation = planRelationEntry(core, model, active, compute, resourceName, entry, undefined);
                 if (plannedRelation !== undefined) {
                     appendUnique(requested, entry);
                     adapterSelect.push(plannedRelation.adapterEntry);
@@ -181,7 +187,7 @@ function planSelectLevel(core, active, behaviors, resourceName, select, collectR
             continue;
         }
         const [fieldName, nestedValue] = relationEntry;
-        const plannedRelation = planRelationEntry(core, active, behaviors, resourceName, fieldName, nestedValue);
+        const plannedRelation = planRelationEntry(core, model, active, compute, resourceName, fieldName, nestedValue);
         if (plannedRelation === undefined) {
             adapterSelect.push(entry);
             continue;
@@ -195,15 +201,15 @@ function planSelectLevel(core, active, behaviors, resourceName, select, collectR
         plan: { resource: resourceName, requested, computed, relations, reducers },
     };
 }
-function planIncludeLevel(core, active, behaviors, resourceName, include) {
-    const defaults = defaultProjectionLevel(core, active, behaviors, resourceName);
+function planIncludeLevel(core, model, active, compute, resourceName, include) {
+    const defaults = defaultProjectionLevel(core, model, active, compute, resourceName);
     const adapterSelect = [...defaults.select];
     const requested = [...defaults.plan.requested];
     const computed = [...defaults.plan.computed];
     const relations = [];
     for (const entry of include) {
         if (typeof entry === "string") {
-            const plannedRelation = planRelationEntry(core, active, behaviors, resourceName, entry, undefined);
+            const plannedRelation = planRelationEntry(core, model, active, compute, resourceName, entry, undefined);
             if (plannedRelation === undefined) {
                 continue;
             }
@@ -217,7 +223,7 @@ function planIncludeLevel(core, active, behaviors, resourceName, include) {
             continue;
         }
         const [fieldName, nestedValue] = relationEntry;
-        const plannedRelation = planRelationEntry(core, active, behaviors, resourceName, fieldName, nestedValue);
+        const plannedRelation = planRelationEntry(core, model, active, compute, resourceName, fieldName, nestedValue);
         if (plannedRelation === undefined) {
             continue;
         }
@@ -242,7 +248,7 @@ function replaceWithInternalSelect(args, select) {
     internal.select = select;
     return internal;
 }
-export function planReadOperation(core, active, behaviors, request, args) {
+export function planReadOperation(core, model, active, compute, request, args) {
     if (!isRecord(args) || !supportsProjection(request)) {
         return { arguments: args, projection: undefined, materialize: false };
     }
@@ -252,7 +258,7 @@ export function planReadOperation(core, active, behaviors, request, args) {
         return { arguments: args, projection: undefined, materialize: false };
     }
     if (Array.isArray(args.select)) {
-        const planned = planSelectLevel(core, active, behaviors, request.resource, args.select);
+        const planned = planSelectLevel(core, model, active, compute, request.resource, args.select);
         return {
             arguments: replaceWithInternalSelect(args, planned.select),
             projection: planned.plan,
@@ -260,27 +266,21 @@ export function planReadOperation(core, active, behaviors, request, args) {
         };
     }
     if (Array.isArray(args.include)) {
-        const planned = planIncludeLevel(core, active, behaviors, request.resource, args.include);
+        const planned = planIncludeLevel(core, model, active, compute, request.resource, args.include);
         return {
             arguments: replaceWithInternalSelect(args, planned.select),
             projection: planned.plan,
             materialize: true,
         };
     }
-    const defaults = defaultProjectionLevel(core, active, behaviors, request.resource);
+    const defaults = defaultProjectionLevel(core, model, active, compute, request.resource);
     return {
         arguments: { ...args, select: defaults.select },
         projection: defaults.plan,
         materialize: defaults.plan.computed.length > 0,
     };
 }
-function behaviorFailure(issues) {
-    throw new FrameworkError("A3000", {
-        message: INTERNAL_FAILURE_MESSAGE,
-        issues,
-    });
-}
-async function materializeRelation(active, behaviors, request, relation, value, contextFactory) {
+async function materializeRelation(active, compute, request, relation, value, contextFactory) {
     if (value === null || value === undefined) {
         return value;
     }
@@ -288,11 +288,11 @@ async function materializeRelation(active, behaviors, request, relation, value,
         if (!Array.isArray(value)) {
             return value;
         }
-        return Promise.all(value.map((entry) => materializeRecord(active, behaviors, request, relation.projection, entry, contextFactory)));
+        return Promise.all(value.map((entry) => materializeRecord(active, compute, request, relation.projection, entry, contextFactory)));
     }
-    return materializeRecord(active, behaviors, request, relation.projection, value, contextFactory);
+    return materializeRecord(active, compute, request, relation.projection, value, contextFactory);
 }
-async function materializeRecord(active, behaviors, request, plan, value, contextFactory) {
+async function materializeRecord(active, compute, request, plan, value, contextFactory) {
     if (!isRecord(value)) {
         return value;
     }
@@ -303,24 +303,30 @@ async function materializeRecord(active, behaviors, request, plan, value, contex
     const record = { ...value };
     for (const fieldName of plan.computed) {
         const field = lookupField(resource, fieldName);
-        const behavior = readBehavior(behaviors?.[plan.resource]?.fields[fieldName]?.read);
-        if (field?.kind !== "scalar" || behavior === undefined) {
+        const stage = readCompute(compute?.[plan.resource]?.[fieldName]?.read);
+        if (field?.kind !== "scalar" || stage === undefined) {
             continue;
         }
-        const computedValue = await behavior.compute({
-            scope: request.scope,
-            resource: plan.resource,
+        const computedValue = await stage.compute({
             field: fieldName,
             value: record[fieldName],
             record,
-            operation: contextFactory(),
+            ctx: contextFactory(),
         });
         if (computedValue === undefined) {
             continue;
         }
-        const validation = normalizeScalarFieldValue(active, field, computedValue, "runtime", ["behaviors", plan.resource, fieldName, "read"]);
+        const validation = normalizeScalarFieldValue(active, field, computedValue, "runtime", [
+            "resources",
+            plan.resource,
+            "fields",
+            fieldName,
+            "pipelines",
+            "compute",
+            "read",
+        ]);
         if (!validation.ok) {
-            behaviorFailure(validation.issues);
+            throw new AvComputedValueError(plan.resource, fieldName, "read", validation.issues);
         }
         record[fieldName] = validation.value;
     }
@@ -328,19 +334,19 @@ async function materializeRecord(active, behaviors, request, plan, value, contex
         if (!Object.hasOwn(record, relation.field)) {
             continue;
         }
-        record[relation.field] = await materializeRelation(active, behaviors, request, relation, record[relation.field], contextFactory);
+        record[relation.field] = await materializeRelation(active, compute, request, relation, record[relation.field], contextFactory);
     }
     return Object.fromEntries(plan.requested
         .filter((fieldName) => Object.hasOwn(record, fieldName))
         .map((fieldName) => [fieldName, record[fieldName]]));
 }
-export async function materializeReadOperation(active, behaviors, request, plan, value, contextFactory) {
+export async function materializeReadOperation(active, compute, request, plan, value, contextFactory) {
     const projection = plan.projection;
     if (!plan.materialize || projection === undefined) {
         return value;
     }
     if (Array.isArray(value)) {
-        return Promise.all(value.map((entry) => materializeRecord(active, behaviors, request, projection, entry, contextFactory)));
+        return Promise.all(value.map((entry) => materializeRecord(active, compute, request, projection, entry, contextFactory)));
     }
-    return materializeRecord(active, behaviors, request, projection, value, contextFactory);
+    return materializeRecord(active, compute, request, projection, value, contextFactory);
 }

package/dist/runtime/computed-value.error.d.ts

@@ -0,0 +1,13 @@
+import type { AvValidationIssue } from "../operations/validation-code.js";
+/**
+ * What the diagnostics channel receives when a computed value — a read or write
+ * compute stage's return — is one its Contract refuses: the developer's broken code,
+ * never the caller's. It is thrown, not a deliberate outcome, so the framework's
+ * boundary answers the caller the generic `A3000` and reports this error, with the
+ * issues, exactly once.
+ */
+export declare class AvComputedValueError extends Error {
+    readonly issues: readonly AvValidationIssue[];
+    readonly name = "AvComputedValueError";
+    constructor(resource: string, field: string, stage: "read" | "create" | "update", issues: readonly AvValidationIssue[]);
+}

package/dist/runtime/computed-value.error.js

@@ -0,0 +1,9 @@
+export class AvComputedValueError extends Error {
+    issues;
+    name = "AvComputedValueError";
+    constructor(resource, field, stage, issues) {
+        const [first] = issues;
+        super(`The compute.${stage} stage of ${resource}.${field} returned a value its Contract refuses${first === undefined ? "." : ` (${first.code}: ${first.message})`}`);
+        this.issues = issues;
+    }
+}

package/dist/runtime/context-executor.runtime.d.ts

@@ -0,0 +1,59 @@
+import type { AvAdapter } from "../adapters/adapter.interface.js";
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
+import type { AvAdapterTransactionExecutor } from "../adapters/adapter-transaction-executor.interface.js";
+import type { AvRequestOrigin } from "../config/config-layer.js";
+import type { AvContract } from "../contracts/contract.js";
+import type { AvOperationFamily } from "../operations/operation-identity.js";
+import { type AvDiagnosticsSink } from "./diagnostics-reporter.js";
+import type { AvComputeContext } from "./field-compute.js";
+import type { MisuseReporter } from "./misuse-reporter.js";
+import type { ApplicationOperationRequest } from "./operation-request.js";
+import type { AvOperationResponse } from "./operation-response.js";
+import type { AvContext, AvTransactionContext, AvTransportContext } from "./pipeline.js";
+import type { AvState } from "./request-state.js";
+/** Where a ctx's calls run: inside the open transaction, or standalone. */
+export type ExecutorScope<M extends AvAdapterModel = AvAdapterModel> = {
+    /** The request id every call of this ctx carries: its stage's request's. */
+    readonly requestId: string;
+    /** The open transaction's executor; `undefined` outside any transaction. */
+    readonly transaction: AvAdapterTransactionExecutor<M> | undefined;
+    /** The request's state, which every call of this ctx inherits. */
+    readonly state: AvState;
+};
+/** The `$` facts a ctx states, as own data properties. */
+export type ContextFacts = {
+    readonly $origin: AvRequestOrigin;
+    readonly $requestId: string;
+    readonly $transport?: AvTransportContext;
+    readonly $contract: AvContract;
+    readonly $operation?: {
+        readonly resource: string;
+        readonly family: AvOperationFamily;
+        readonly variant: string;
+        readonly nested?: true;
+    };
+    readonly $args: unknown;
+};
+/** Runs one raw application-origin call in `transaction`, or standalone. Total. */
+export type RawOperationRunner<M extends AvAdapterModel> = (request: ApplicationOperationRequest, transaction: AvAdapterTransactionExecutor<M> | undefined) => Promise<AvOperationResponse>;
+export type ContextExecutorDependencies<M extends AvAdapterModel> = {
+    /** The model, as construction read it once: the ctx's Resources. */
+    readonly model: M;
+    readonly adapter: AvAdapter<M>;
+    /** The Application Contract: a `ctx.$transaction` needs its transactions. */
+    readonly application: AvContract;
+    readonly diagnostics: AvDiagnosticsSink | undefined;
+    readonly misuse: MisuseReporter;
+    readonly run: RawOperationRunner<M>;
+};
+/** Builds the ctx every stage is told. */
+export type ContextExecutor<M extends AvAdapterModel = AvAdapterModel> = {
+    /** An operation stage's ctx: its facts and the full executor. */
+    readonly operation: (scope: ExecutorScope<M>, facts: ContextFacts) => AvContext;
+    /** A Resource transaction stage's ctx: the plan as `$args`, the full executor. */
+    readonly transaction: (scope: ExecutorScope<M>, facts: ContextFacts) => AvTransactionContext;
+    /** Compute's read-only ctx: the facts, and `find.*` reads only. */
+    readonly compute: (scope: ExecutorScope<M>, facts: ContextFacts) => AvComputeContext;
+};
+/** Builds the ctx factory of one Framework over its model. */
+export declare function createContextExecutor<M extends AvAdapterModel>(dependencies: ContextExecutorDependencies<M>): ContextExecutor<M>;

package/dist/runtime/context-executor.runtime.js

@@ -0,0 +1,275 @@
+import { isOperationVariantAvailable } from "../contracts/resource-operations.js";
+import { parseOperationIdentity } from "../operations/operation-identity.js";
+import { validationIssue } from "../operations/validation-code.js";
+import { readSqlTemplate } from "../transactions/sql-statement.js";
+import { normalizeSqlValue } from "../transactions/sql-statement.validator.js";
+import { AvTransactionIntegrityError } from "../transactions/transaction-integrity-error.js";
+import { transactionInfrastructureFailure } from "../transactions/transaction-response.js";
+import { copyAtDoor, refuseCallerData } from "./caller-data.door.js";
+import { createReporter, } from "./diagnostics-reporter.js";
+import { AdapterBoundary, sanitizeOperationFailure } from "./error-boundary.js";
+import { thrownFailure } from "./framework-error.factory.js";
+import { operationFailure } from "./operation-response.js";
+import { mapValidationOutcome } from "./outcome-mapper.js";
+import { readonlyView } from "./readonly-value.js";
+const COMPUTE_STATE = "Compute's ctx.$state";
+const STATE = Symbol("aventara.context");
+const READ_FAMILY = "find";
+function readOnlyRefusal(member) {
+    return new TypeError(`Compute's ctx is read-only: ${member} is not available in a compute stage. Put effects on other rows in an after hook.`);
+}
+function refusedStatement(issues) {
+    return mapValidationOutcome(issues);
+}
+function unavailable(message) {
+    return operationFailure("A2002", {
+        message,
+        issues: [validationIssue("V1006", [], message)],
+    });
+}
+export function createContextExecutor(dependencies) {
+    const { adapter, misuse } = dependencies;
+    const model = dependencies.model;
+    const stateOf = (context) => context[STATE];
+    const reporterOf = (scope) => createReporter(dependencies.diagnostics, {
+        kind: "transaction",
+        origin: "application",
+        requestId: scope.requestId,
+    });
+    const call = async (scope, resource, identity, args) => {
+        const response = await dependencies.run({
+            ...identity,
+            origin: "application",
+            resource,
+            requestId: scope.requestId,
+            state: scope.state,
+            arguments: args === undefined ? {} : args,
+        }, scope.transaction);
+        if (response.cause !== null) {
+            throw thrownFailure(response);
+        }
+        return response.data;
+    };
+    const resourceTree = (scope, resource, readOnly) => {
+        const families = {};
+        const operations = model.resources[resource]?.operations ?? {};
+        for (const [family, variants] of Object.entries(operations)) {
+            if (readOnly && family !== READ_FAMILY) {
+                continue;
+            }
+            const leaves = {};
+            for (const [variant, availability] of Object.entries(variants ?? {})) {
+                const identity = parseOperationIdentity(family, variant);
+                if (identity !== undefined &&
+                    isOperationVariantAvailable(availability)) {
+                    leaves[variant] = (args) => call(scope, resource, identity, args);
+                }
+            }
+            families[family] = Object.freeze(leaves);
+        }
+        if (readOnly) {
+            const tree = Object.create(Object.prototype);
+            for (const [family, leaves] of Object.entries(families)) {
+                Object.defineProperty(tree, family, {
+                    value: leaves,
+                    enumerable: true,
+                });
+            }
+            for (const family of Object.keys(operations)) {
+                if (family === READ_FAMILY) {
+                    continue;
+                }
+                Object.defineProperty(tree, family, {
+                    get() {
+                        throw readOnlyRefusal(`ctx.${resource}.${family}`);
+                    },
+                    enumerable: false,
+                });
+            }
+            return Object.freeze(tree);
+        }
+        return Object.freeze(families);
+    };
+    const statementOf = (strings, values) => {
+        if (adapter.sqlStatements !== true) {
+            return {
+                ok: false,
+                response: unavailable("SQL statements are not available on this Adapter."),
+            };
+        }
+        const text = readSqlTemplate(strings, values.length);
+        if (text === undefined) {
+            return {
+                ok: false,
+                response: refusedStatement([
+                    validationIssue("V1001", ["strings"], "SQL must be written as a tagged template: ctx.$sql`…`."),
+                ]),
+            };
+        }
+        const copy = copyAtDoor([...values]);
+        if (!copy.ok) {
+            return {
+                ok: false,
+                response: refusedStatement([
+                    refuseCallerData(copy.error, ["values"], { origin: "application" }, misuse),
+                ]),
+            };
+        }
+        const bound = [];
+        const issues = [];
+        for (const [position, value] of copy.value.entries()) {
+            const normalized = normalizeSqlValue(value, ["values", position]);
+            if (normalized.ok) {
+                bound.push(normalized.value);
+            }
+            else {
+                issues.push(...normalized.issues);
+            }
+        }
+        if (issues.length > 0) {
+            return { ok: false, response: refusedStatement(issues) };
+        }
+        return { ok: true, statement: { strings: text, values: bound } };
+    };
+    const executeStatement = async (runner, inTransaction, statement, report) => {
+        if (inTransaction && typeof runner.executeSql !== "function") {
+            const error = new AvTransactionIntegrityError("statement-unavailable");
+            report(error, "A3002");
+            throw thrownFailure(transactionInfrastructureFailure());
+        }
+        const boundary = new AdapterBoundary();
+        try {
+            return await boundary.execute(async () => {
+                if (typeof runner.executeSql !== "function") {
+                    throw new TypeError("Adapter declares sqlStatements but has no executeSql.");
+                }
+                const rows = await runner.executeSql(statement);
+                if (!Array.isArray(rows)) {
+                    throw new TypeError("Adapter executeSql must resolve the statement's rows as an array.");
+                }
+                return [...rows];
+            });
+        }
+        catch (error) {
+            throw thrownFailure(sanitizeOperationFailure(error, boundary.originOf(error), report, {
+                path: ["values"],
+                arguments: statement.values,
+            }));
+        }
+    };
+    const openTransaction = async (scope, work) => {
+        if (typeof adapter.transaction !== "function") {
+            throw thrownFailure(unavailable("Transactions are not available on this Adapter."));
+        }
+        let thrown;
+        try {
+            return await adapter.transaction(async (executor) => {
+                try {
+                    return await work(executor);
+                }
+                catch (error) {
+                    thrown = { error };
+                    throw error;
+                }
+            });
+        }
+        catch (error) {
+            if (thrown !== undefined && error === thrown.error) {
+                throw error;
+            }
+            reporterOf(scope)(error, "A3002");
+            throw thrownFailure(transactionInfrastructureFailure());
+        }
+    };
+    const sql = async (scope, strings, values) => {
+        const prepared = statementOf(strings, values);
+        if (!prepared.ok) {
+            throw thrownFailure(prepared.response);
+        }
+        const report = reporterOf(scope);
+        const open = scope.transaction;
+        return open !== undefined
+            ? executeStatement(open, true, prepared.statement, report)
+            : executeStatement(adapter, false, prepared.statement, report);
+    };
+    const contextOf = (prototype, scope, facts, readOnly = false) => {
+        const context = Object.create(prototype);
+        Object.defineProperty(context, STATE, {
+            value: { scope, facts, resources: new Map() },
+        });
+        for (const [key, value] of Object.entries(facts)) {
+            if (value !== undefined) {
+                Object.defineProperty(context, key, { value, enumerable: true });
+            }
+        }
+        Object.defineProperty(context, "$state", {
+            value: readOnly ? readonlyView(scope.state, COMPUTE_STATE) : scope.state,
+            enumerable: true,
+        });
+        return context;
+    };
+    const transactionOf = (prototype) => (context, work) => {
+        const { scope, facts } = stateOf(context);
+        if (typeof work !== "function") {
+            return Promise.reject(new TypeError("ctx.$transaction takes an async callback: (tx) => …"));
+        }
+        const run = work;
+        if (scope.transaction !== undefined) {
+            return (async () => run(context))();
+        }
+        if (dependencies.application.transactions === "none") {
+            return Promise.reject(thrownFailure(unavailable("Transactions are not available on the application Contract.")));
+        }
+        return openTransaction(scope, (executor) => run(contextOf(prototype, {
+            requestId: scope.requestId,
+            transaction: executor,
+            state: scope.state,
+        }, facts)));
+    };
+    const prototypeOf = (readOnly) => {
+        const prototype = {};
+        for (const resource of Object.keys(model.resources)) {
+            Object.defineProperty(prototype, resource, {
+                get() {
+                    const state = stateOf(this);
+                    let tree = state.resources.get(resource);
+                    if (tree === undefined) {
+                        tree = resourceTree(state.scope, resource, readOnly);
+                        state.resources.set(resource, tree);
+                    }
+                    return tree;
+                },
+            });
+        }
+        if (readOnly) {
+            for (const member of ["$sql", "$transaction"]) {
+                Object.defineProperty(prototype, member, {
+                    get() {
+                        throw readOnlyRefusal(`ctx.${member}`);
+                    },
+                });
+            }
+            return Object.freeze(prototype);
+        }
+        const transaction = transactionOf(prototype);
+        Object.defineProperty(prototype, "$sql", {
+            get() {
+                const { scope } = stateOf(this);
+                return (strings, ...values) => sql(scope, strings, values);
+            },
+        });
+        Object.defineProperty(prototype, "$transaction", {
+            get() {
+                return (work) => transaction(this, work);
+            },
+        });
+        return Object.freeze(prototype);
+    };
+    const full = prototypeOf(false);
+    const reads = prototypeOf(true);
+    return {
+        operation: (scope, facts) => contextOf(full, scope, facts),
+        transaction: (scope, facts) => contextOf(full, scope, facts),
+        compute: (scope, facts) => contextOf(reads, scope, facts, true),
+    };
+}