@aventara/core 0.1.0-pilot.3 → 1.0.0-rc.0

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

@@ -6,43 +6,50 @@ import type { ResolvedFrameworkConfig } from "../config/config.resolver.js";
 import type { Contract } from "../contracts/contract.js";
 import type { OperationValidationOptions, SemanticOperationArguments } from "../operations/operation-validator.js";
 import type { FrameworkTransactionRequest } from "../transactions/transaction-request.js";
-import { type CreateRequirementTable } from "./create-requirement.js";
+import { type ArgumentsSource } from "./caller-data.door.js";
+import { type RecordWriteFacts } from "./create-requirement.js";
 import type { DiagnosticsReporter } from "./diagnostics-reporter.js";
 import type { ClientProtocolIdentity, FrameworkOperationRequest, OperationExecutionRequest } from "./operation-request.js";
 import type { OperationFailureResponse, OperationResponse } from "./operation-response.js";
+import { type NormalizationWrite } from "./scalar-runtime.js";
 export type OperationRuntimeDependencies<M extends AdapterModel> = {
     readonly adapter: Adapter<M>;
     readonly contracts: FrameworkContracts;
     readonly config: ResolvedFrameworkConfig<M>;
 };
 /**
- * What a validated operation's pipeline needs: everything except the root Adapter.
- * Its single Adapter call goes through the executor passed beside it, so inside a
+ * What a validated operation's pipeline needs: everything except the root Adapter. Its
+ * single Adapter call goes through the executor passed beside it, so inside a
  * transaction plan the root Adapter is unreachable by type.
  */
 export type OperationPipelineDependencies<M extends AdapterModel> = Omit<OperationRuntimeDependencies<M>, "adapter"> & {
-    /** The Adapter's create requirements, read once at construction. */
-    readonly createRequirements: CreateRequirementTable;
+    /**
+     * The Adapter's create requirements and referential edges, read once at
+     * construction.
+     */
+    readonly recordWrites: RecordWriteFacts;
 };
 /**
  * The executor core owns no diagnostics channel: the framework factory owns
  * it and hands in one reporter already bound to this request, so every
  * boundary — including the outermost totality guard, which runs outside this
- * function — reports through the same channel.
+ * function — reports through the same channel. `source` says whether the
+ * request's arguments are the caller's own objects, copied at the door, or data
+ * no caller holds (see {@link ArgumentsSource}).
  */
-export type FrameworkOperationExecutor = (request: FrameworkOperationRequest, report: DiagnosticsReporter) => Promise<OperationResponse>;
-/** Selects the Contract of the request's execution scope for both execution seams. */
+export type FrameworkOperationExecutor = (request: FrameworkOperationRequest, report: DiagnosticsReporter, source: ArgumentsSource) => Promise<OperationResponse>;
+/** Selects the Contract of the request's origin. */
 export declare function activeContract(contracts: FrameworkContracts, request: FrameworkOperationRequest | FrameworkTransactionRequest): Contract;
 /** Creates the transport-independent operation executor owned by core. */
 export declare function createOperationRuntime<M extends AdapterModel>(dependencies: OperationRuntimeDependencies<M>): FrameworkOperationExecutor;
-/** Validates the request-level protocol identity shared by both execution seams. */
+/** Validates the request-level protocol identity. */
 export declare function validateProtocolIdentity(contracts: FrameworkContracts, request: FrameworkOperationRequest | FrameworkTransactionRequest): OperationFailureResponse | undefined;
 /**
- * The stale-client check on one client protocol identity: the protocol version
- * first (`A2006`), then the ClientContract hash (`A2005`). Exact match only. The
- * one implementation — the protocol's decoders and absence answers
- * (`@aventara/core/protocol`) call it too, so a stale client hears the same
- * envelope whichever layer answers.
+ * The stale-client check on one client protocol identity: the protocol version first
+ * (`A2006`), then the ClientContract hash (`A2005`). Exact match only. The one
+ * implementation — the protocol's decoders and absence answers
+ * (`@aventara/core/protocol`) call it too, so a stale client hears the same envelope
+ * whichever layer answers.
  */
 export declare function protocolIdentityFailure(contracts: FrameworkContracts, protocol: ClientProtocolIdentity): OperationFailureResponse | undefined;
 export type ValidatedOperationArguments = {
@@ -52,26 +59,11 @@ export type ValidatedOperationArguments = {
     readonly ok: false;
     readonly response: OperationFailureResponse;
 };
-/** Reusable per-operation Framework Validation Layer argument seam. */
-export declare function validateOperationRequest(contract: Contract, request: FrameworkOperationRequest, options?: OperationValidationOptions): ValidatedOperationArguments;
+/** Validates one operation's arguments through the Framework Validation Layer. */
+export declare function validateOperationRequest(contract: Contract, request: FrameworkOperationRequest, options?: OperationValidationOptions, write?: NormalizationWrite): ValidatedOperationArguments;
 /**
  * Everything after the Framework Validation Layer: the developer/runtime path
- * wrapped in the post-validation error boundary. Validation failures never reach
- * this function, so developer filters never see them.
- *
- * `executor` is the operation's single Adapter call site: standalone execution
- * passes the Adapter itself, a transaction plan passes the transaction-scoped
- * executor its Adapter callback received. Every call owns one AdapterBoundary, so
- * A3001/A3000 origin stays classified per operation.
- *
- * The parameter types keep two values out of reach: `dependencies` carries no root
- * Adapter, so the executor is the only Adapter this function can call, and
- * `request` carries no `arguments`, so no stage can read the unvalidated view
- * instead of `validatedArguments`.
- *
- * `argumentsPath` is the framework's own address for these arguments —
- * `["arguments"]` standalone, `["operations", i, "args"]` inside a plan. The
- * response boundary needs it to decide whether a thrower-supplied issue path
- * denotes the caller's own arguments or is unvouched text.
+ * wrapped in the post-validation error boundary. Validation failures never
+ * reach this function, so developer filters never see them.
  */
 export declare function executeValidatedOperation<M extends AdapterModel>(dependencies: OperationPipelineDependencies<M>, request: OperationExecutionRequest, contract: Contract, validatedArguments: unknown, argumentsPath: readonly (string | number)[], executor: AdapterOperationExecutor<M>, report: DiagnosticsReporter): Promise<OperationResponse>;

package/dist/runtime/operation-runtime.js

@@ -1,32 +1,34 @@
 import { AVENTARA_PROTOCOL_VERSION } from "../contracts/contract-protocol.js";
-import { validateOperationArguments } from "../operations/operation-validator.js";
+import { findOperationAvailabilityIssue, validateOperationArguments, } from "../operations/operation-validator.js";
+import { copyAtDoor, misuseIdentityOf, refuseCallerData, } from "./caller-data.door.js";
 import { materializeReadOperation, planReadOperation, } from "./computed-read-runtime.js";
-import { missingCreateValues, } from "./create-requirement.js";
+import { createRequirementIssues, recordWriteFactsOf, } from "./create-requirement.js";
 import { AdapterBoundary, OPERATION_ARGUMENTS_PATH, resolveOperationFailure, sanitizeOperationFailure, } from "./error-boundary.js";
+import { createMisuseReporter, } from "./misuse-reporter.js";
 import { applyWriteFieldBehaviors, stripVirtualMutationInput, } from "./mutation-planner.js";
 import { internalFailure, operationFailure } from "./operation-response.js";
 import { mapOperationOutcome, mapValidationOutcome } from "./outcome-mapper.js";
-import { validateOperationOutput } from "./output-validator.js";
+import { OutputValidationError, validateOperationOutput, } from "./output-validator.js";
 import { refusePipeOutput } from "./pipe-output.validator.js";
-import { normalizeOperationScalarValues } from "./scalar-runtime.js";
+import { normalizeOperationScalarValues, } from "./scalar-runtime.js";
 export function activeContract(contracts, request) {
-    return request.scope === "application"
+    return request.origin === "application"
         ? contracts.application
         : contracts.client;
 }
 function activeScopeConfig(config, request) {
-    return request.scope === "application" ? config.application : config.client;
+    return request.origin === "application" ? config.application : config.client;
 }
 function pipelineContext(contract, request, args) {
     return {
         contract,
-        scope: request.scope,
+        origin: request.origin,
         resource: request.resource,
         family: request.family,
         variant: request.variant,
         args,
         requestId: request.requestId,
-        ...(request.scope === "client" && request.transport !== undefined
+        ...(request.origin === "client" && request.transport !== undefined
             ? { transport: request.transport }
             : {}),
     };
@@ -37,24 +39,30 @@ function forbidden() {
     });
 }
 function outputAccepted(contract, request, projection, data, report) {
+    let validation;
     try {
-        return validateOperationOutput(contract, request, projection, data).ok;
+        validation = validateOperationOutput(contract, request, projection, data);
     }
     catch (error) {
         report(error, "A3000");
         return false;
     }
+    if (!validation.ok) {
+        report(new OutputValidationError(request, validation.issues), "A3000");
+    }
+    return validation.ok;
 }
 export function createOperationRuntime(dependencies) {
     const pipelineDependencies = {
         contracts: dependencies.contracts,
         config: dependencies.config,
-        createRequirements: dependencies.adapter.createRequirements ?? {},
+        recordWrites: recordWriteFactsOf(dependencies.adapter),
     };
-    return async (request, report) => {
+    const misuse = createMisuseReporter(dependencies.config.misuse);
+    return async (request, report, source) => {
         let validated;
         try {
-            validated = validateOperation(dependencies, request);
+            validated = validateOperation(dependencies, request, source, misuse);
         }
         catch (error) {
             return sanitizeOperationFailure(error, "runtime", report, {
@@ -68,20 +76,31 @@ export function createOperationRuntime(dependencies) {
         return executeValidatedOperation(pipelineDependencies, request, validated.contract, validated.arguments, OPERATION_ARGUMENTS_PATH, dependencies.adapter, report);
     };
 }
-function validateOperation(dependencies, request) {
+function validateOperation(dependencies, request, source, misuse) {
     const protocolFailure = validateProtocolIdentity(dependencies.contracts, request);
     if (protocolFailure !== undefined) {
         return rejected(protocolFailure);
     }
     const contract = activeContract(dependencies.contracts, request);
-    const validation = validateOperationRequest(contract, request);
+    let owned = request;
+    if (source === "caller" &&
+        findOperationAvailabilityIssue(contract, request) === undefined) {
+        const copy = copyAtDoor(request.arguments);
+        if (!copy.ok) {
+            return rejected(mapValidationOutcome([
+                refuseCallerData(copy.error, OPERATION_ARGUMENTS_PATH, misuseIdentityOf(request), misuse),
+            ]));
+        }
+        owned = { ...request, arguments: copy.value };
+    }
+    const validation = validateOperationRequest(contract, owned, undefined, "in-place");
     if (!validation.ok) {
         return rejected(validation.response);
     }
     return { ok: true, contract, arguments: validation.arguments };
 }
 export function validateProtocolIdentity(contracts, request) {
-    return request.scope === "client"
+    return request.origin === "client"
         ? protocolIdentityFailure(contracts, request.protocol)
         : undefined;
 }
@@ -98,12 +117,12 @@ export function protocolIdentityFailure(contracts, protocol) {
     }
     return undefined;
 }
-export function validateOperationRequest(contract, request, options) {
+export function validateOperationRequest(contract, request, options, write = "copy") {
     const validation = validateOperationArguments(contract, request, options);
     if (!validation.ok) {
         return { ok: false, response: mapValidationOutcome(validation.issues) };
     }
-    const scalarNormalization = normalizeOperationScalarValues(contract, { ...request, arguments: validation.arguments }, request.scope, options);
+    const scalarNormalization = normalizeOperationScalarValues(contract, { ...request, arguments: validation.arguments }, request.origin, options, write);
     return scalarNormalization.ok
         ? { ok: true, arguments: scalarNormalization.arguments }
         : {
@@ -144,7 +163,7 @@ export async function executeValidatedOperation(dependencies, request, contract,
             }
         }
         args = await applyWriteFieldBehaviors({ core: dependencies.contracts.core, active: contract }, scopeConfig.behaviors, request, args, () => pipelineContext(contract, request, args));
-        const missing = missingCreateValues(contract, dependencies.createRequirements, request, args, argumentsPath);
+        const missing = createRequirementIssues(contract, dependencies.recordWrites, request, args, argumentsPath);
         if (missing.length > 0) {
             return mapValidationOutcome(missing);
         }

package/dist/runtime/outcome-mapper.js

@@ -42,11 +42,21 @@ export function mapOperationOutcome(operation, data) {
         ? absenceOutcome(rule.absence)
         : operationSuccess(data, rule.success);
 }
+function stepRelativeHead(issue) {
+    const path = issue.path;
+    return path?.[0] === "operations" && typeof path[1] === "number"
+        ? path[2]
+        : path?.[0];
+}
+function namesUnavailableOperation(issue) {
+    const head = stepRelativeHead(issue);
+    return issue.code === "V1006" && (head === "family" || head === "variant");
+}
 function validationCode(issues) {
-    if (issues.some((issue) => issue.path?.[0] === "resource")) {
+    if (issues.some((issue) => issue.code !== "V1019" && stepRelativeHead(issue) === "resource")) {
         return "A2001";
     }
-    if (issues.some((issue) => issue.path?.[0] === "operation")) {
+    if (issues.some(namesUnavailableOperation)) {
         return "A2002";
     }
     if (issues.some((issue) => issue.code === "V1010" ||

package/dist/runtime/output-validator.d.ts

@@ -11,6 +11,16 @@ export type OutputValidationResult = {
 type OutputOperation = OperationIdentity & {
     readonly resource: string;
 };
+/**
+ * The error the diagnostics channel receives when a result fails output
+ * validation: whose result it was and what the validator found. The caller
+ * receives the generic `A3000` and never this.
+ */
+export declare class OutputValidationError extends Error {
+    readonly issues: readonly ValidationIssue[];
+    readonly name = "OutputValidationError";
+    constructor(operation: OutputOperation, issues: readonly ValidationIssue[]);
+}
 /** Validate final operation output against fixed cardinality and executed projection. */
 export declare function validateOperationOutput(contract: Contract, operation: OutputOperation, projection: ReadProjectionPlan | undefined, value: unknown): OutputValidationResult;
 export {};

package/dist/runtime/output-validator.js

@@ -168,6 +168,17 @@ function validateProjection(contract, operation, projection, value) {
         ? validateExactRecord(contract, value, projection, ["data"])
         : { ok: true };
 }
+export class OutputValidationError extends Error {
+    issues;
+    name = "OutputValidationError";
+    constructor(operation, issues) {
+        const [first] = issues;
+        super(`The result of ${operation.resource}.${operation.family}.${operation.variant} does not satisfy its Contract${first === undefined
+            ? "."
+            : ` at "${(first.path ?? []).join(".")}" (${first.code}: ${first.message})`}`);
+        this.issues = issues;
+    }
+}
 export function validateOperationOutput(contract, operation, projection, value) {
     const cardinality = validateOperationOutputCardinality(operation, value);
     return cardinality.ok

package/dist/runtime/owned-execution.registry.d.ts

@@ -0,0 +1,13 @@
+import type { ClientTransactionRequest } from "../transactions/transaction-request.js";
+import type { TransactionResponse } from "../transactions/transaction-response.js";
+import type { ClientOperationRequest } from "./operation-request.js";
+import type { OperationResponse } from "./operation-response.js";
+/** The two entries that run a request the protocol decoded itself, uncopied. */
+export type OwnedExecution = {
+    readonly execute: (request: ClientOperationRequest) => Promise<OperationResponse>;
+    readonly executeTransaction: (request: ClientTransactionRequest) => Promise<TransactionResponse>;
+};
+/** Records `framework`'s owned entries; called once, at construction. */
+export declare function recordOwnedExecution(framework: object, execution: OwnedExecution): void;
+/** `framework`'s owned entries, or `undefined` for anything `createFramework` did not return. */
+export declare function ownedExecutionOf(framework: object): OwnedExecution | undefined;

package/dist/runtime/owned-execution.registry.js

@@ -0,0 +1,7 @@
+const OWNED_EXECUTIONS = new WeakMap();
+export function recordOwnedExecution(framework, execution) {
+    OWNED_EXECUTIONS.set(framework, execution);
+}
+export function ownedExecutionOf(framework) {
+    return OWNED_EXECUTIONS.get(framework);
+}

package/dist/runtime/pipeline.d.ts

@@ -5,43 +5,16 @@ import type { Contract } from "../contracts/contract.js";
 import type { OperationFamily } from "../operations/operation-identity.js";
 import type { FrameworkError } from "./framework-error.js";
 /**
- * What a pipeline is told about the HTTP request a client-origin operation arrived
- * on — a **deliberate exception** to core's transport-agnosticism.
- *
- * Core never parses HTTP to fill it. `@aventara/core/protocol`'s decoders do, with
- * header names **lower-cased** and a repeated header's values joined with `", "`
- * (RFC 9110 §5.3), so a pipeline reads one spelling. An application-scope request
- * carries none (`ClientOperationRequest.transport` is optional).
+ * What a pipeline is told about the HTTP request a client-origin operation arrived on.
  */
 export type PipelineTransportContext = {
     readonly method: "POST";
     readonly headers: Readonly<Record<string, string>>;
 };
-/**
- * What a pipeline callback is told about the operation it is wrapping.
- *
- * `resource` reads its key set from the **AdapterModel**, not from a `Contract`:
- * `Contract["resources"]` is an open `Record<string, …>`, so the `C extends
- * Contract` parameter this type used to take could never name the Resources an
- * author actually has — it erased to `string`. `M` can name them, and
- * configuration cannot add Resources, so `M` is the whole answer.
- *
- * A `Cfg` parameter here would be referenced nowhere — `biome` flags it
- * (`lint/correctness/noUnusedVariables`) and it would encode no semantic
- * dependency. `FrameworkScopeConfig` already has the precedent one line above
- * `pipelines`: `fields` takes `M` only.
- *
- * `contract` stays the erased {@link Contract} deliberately: a compiled Contract
- * is passive semantic data whose result "stays untyped by design". Threading
- * configuration into it would rebuild the authoring-config-to-compiled-contract
- * bridge this work bypasses.
- *
- * Under the default `M` the key set degenerates to `string`, so an unannotated
- * `PipelineContext` is what it was before.
- */
+/** What a pipeline callback is told about the operation it is wrapping. */
 export type PipelineContext<M extends AdapterModel = AdapterModel> = {
     readonly contract: Contract;
-    readonly scope: RequestOrigin;
+    readonly origin: RequestOrigin;
     readonly resource: FrameworkResourceKey<M>;
     readonly family: OperationFamily;
     readonly variant: string;
@@ -49,9 +22,33 @@ export type PipelineContext<M extends AdapterModel = AdapterModel> = {
     readonly requestId: string;
     readonly transport?: PipelineTransportContext;
 };
-export type Guard<M extends AdapterModel = AdapterModel> = (context: PipelineContext<M>) => boolean | undefined | Promise<boolean | undefined>;
-export type Pipe<M extends AdapterModel = AdapterModel> = (args: unknown, context: PipelineContext<M>) => unknown | Promise<unknown>;
-export type BeforeHook<M extends AdapterModel = AdapterModel> = (context: PipelineContext<M>) => void | Promise<void>;
-export type AfterHook<M extends AdapterModel = AdapterModel> = (result: unknown, context: PipelineContext<M>) => void | Promise<void>;
-export type Interceptor<M extends AdapterModel = AdapterModel> = (context: PipelineContext<M>, next: () => Promise<unknown>) => Promise<unknown>;
-export type Filter<M extends AdapterModel = AdapterModel> = (error: unknown, context: PipelineContext<M>) => FrameworkError | undefined | Promise<FrameworkError | undefined>;
+/** Allows or denies an operation; returning `false` answers `A4001`. */
+export type Guard<M extends AdapterModel = AdapterModel> = {
+    guard(context: PipelineContext<M>): boolean | undefined | Promise<boolean | undefined>;
+}["guard"];
+/**
+ * Transforms the arguments before the operation runs; returning `undefined`
+ * keeps them as they are.
+ */
+export type Pipe<M extends AdapterModel = AdapterModel> = {
+    pipe(args: unknown, context: PipelineContext<M>): unknown | Promise<unknown>;
+}["pipe"];
+/** Runs just before the operation executes. */
+export type BeforeHook<M extends AdapterModel = AdapterModel> = {
+    before(context: PipelineContext<M>): void | Promise<void>;
+}["before"];
+/** Runs after the operation succeeds, with its result. */
+export type AfterHook<M extends AdapterModel = AdapterModel> = {
+    after(result: unknown, context: PipelineContext<M>): void | Promise<void>;
+}["after"];
+/** Wraps the operation's execution; call `next()` to run it and get its result. */
+export type Interceptor<M extends AdapterModel = AdapterModel> = {
+    intercept(context: PipelineContext<M>, next: () => Promise<unknown>): Promise<unknown>;
+}["intercept"];
+/**
+ * Turns a thrown error into a {@link FrameworkError} to answer with; returning
+ * `undefined` passes the error on.
+ */
+export type Filter<M extends AdapterModel = AdapterModel> = {
+    filter(error: unknown, context: PipelineContext<M>): FrameworkError | undefined | Promise<FrameworkError | undefined>;
+}["filter"];

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

@@ -1,33 +1,8 @@
 /**
  * Core's referential-action vocabulary, and the transitive cascade closure the
  * transaction planner reads.
- *
- * The facts are an Adapter's: which relation edges exist, and what deleting a
- * referenced row does to the rows that reference it. So the words here are
- * Aventara's, stated as the effect on the referencing rows, and an Adapter
- * translates its own provider's vocabulary into them.
- *
- * None of this enters a Contract. It is not part of the semantic model a Contract
- * is compiled from, so it moves no Contract value and no hash; it is a planning
- * fact, read once when the Framework is constructed.
- */
-/**
- * What deleting a referenced row does to the rows that reference it.
- *
- * - `cascade` — they are deleted with it, and their own referencing rows in turn
- *   (SQL `ON DELETE CASCADE`).
- * - `restrict` — the delete is refused while they reference it (`RESTRICT`).
- * - `noAction` — the delete is refused while they reference it (`NO ACTION`).
- *   Measured identical to `restrict` on both pilot engines: neither declares the
- *   constraint `DEFERRABLE`, so the end-of-statement check answers one delete
- *   exactly as `RESTRICT` does. It stays a distinct word because it is a distinct
- *   schema fact.
- * - `setNull` — they are kept, the reference set to null (`SET NULL`).
- * - `setDefault` — they are kept, the reference set to its column default (`SET
- *   DEFAULT`).
- *
- * Only `cascade` takes rows away, so only `cascade` is followed by the closure.
  */
+/** What deleting a referenced row does to the rows that reference it. */
 export type ReferentialDeleteEffect = "cascade" | "restrict" | "noAction" | "setNull" | "setDefault";
 /**
  * One relation edge whose referencing side holds the reference.
@@ -48,6 +23,13 @@ export type ReferentialEdge = {
     readonly field: string;
     /** The Resource the edge points AT — the one whose deletion fires `onDelete`. */
     readonly target: string;
+    /**
+     * The scalar fields of the ENCLOSING Resource that hold the reference, in the
+     * order the store pairs them with the `target`'s key. A record that writes the
+     * relation `field` and any of these names the reference twice and is refused;
+     * a required relation may be written through all of them instead.
+     */
+    readonly references: readonly string[];
     /** What deleting a `target` row does to rows of the ENCLOSING Resource. */
     readonly onDelete: ReferentialDeleteEffect;
 };

package/dist/runtime/request-envelope.validator.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationIssue } from "../operations/validation-code.js";
+/** The issues of one malformed operation request envelope; empty when well formed. */
+export declare function validateOperationEnvelope(request: unknown): readonly ValidationIssue[];
+/** The issues of one malformed transaction request envelope; empty when well formed. */
+export declare function validateTransactionEnvelope(request: unknown): readonly ValidationIssue[];

package/dist/runtime/request-envelope.validator.js

@@ -0,0 +1,118 @@
+const ORIGINS = ["application", "client"];
+const OPERATION_IDENTITY_MEMBERS = ["resource", "family", "variant"];
+export function validateOperationEnvelope(request) {
+    if (!isRecord(request)) {
+        return [issue([], "V1001", "Operation request must be an object.")];
+    }
+    const issues = [...originAndIdentityIssues(request)];
+    for (const member of OPERATION_IDENTITY_MEMBERS) {
+        const failure = requiredStringIssue(request, member);
+        if (failure !== undefined) {
+            issues.push(failure);
+        }
+    }
+    return issues;
+}
+export function validateTransactionEnvelope(request) {
+    if (!isRecord(request)) {
+        return [issue([], "V1001", "Transaction request must be an object.")];
+    }
+    return originAndIdentityIssues(request);
+}
+function originAndIdentityIssues(request) {
+    const issues = [];
+    const origin = request.origin;
+    if (origin === undefined) {
+        issues.push(issue(["origin"], "V1000", 'Required property "origin" is missing.'));
+    }
+    else if (typeof origin !== "string") {
+        issues.push(issue(["origin"], "V1001", "Request origin must be a string."));
+    }
+    else if (!ORIGINS.includes(origin)) {
+        issues.push(issue(["origin"], "V1002", 'Request origin must be "application" or "client".'));
+    }
+    const requestId = request.requestId;
+    if (requestId === undefined || requestId === "") {
+        issues.push(issue(["requestId"], "V1000", 'Required property "requestId" is missing or empty.'));
+    }
+    else if (typeof requestId !== "string") {
+        issues.push(issue(["requestId"], "V1001", "Request id must be a string."));
+    }
+    if (origin === "client") {
+        issues.push(...protocolIssues(request.protocol));
+        if (request.transport !== undefined) {
+            issues.push(...transportIssues(request.transport));
+        }
+    }
+    else if (origin === "application") {
+        for (const member of ["protocol", "transport"]) {
+            if (request[member] !== undefined) {
+                issues.push(issue([member], "V1005", `Property "${member}" belongs to a client request, not an application one.`));
+            }
+        }
+    }
+    return issues;
+}
+function protocolIssues(protocol) {
+    if (protocol === undefined) {
+        return [
+            issue(["protocol"], "V1000", 'Required property "protocol" is missing from a client request.'),
+        ];
+    }
+    if (!isRecord(protocol)) {
+        return [
+            issue(["protocol"], "V1001", "Protocol identity must be an object."),
+        ];
+    }
+    const issues = [];
+    if (protocol.version === undefined) {
+        issues.push(issue(["protocol", "version"], "V1000", 'Required property "version" is missing.'));
+    }
+    else if (!Number.isInteger(protocol.version)) {
+        issues.push(issue(["protocol", "version"], "V1001", "Protocol version must be an integer."));
+    }
+    if (protocol.hash === undefined) {
+        issues.push(issue(["protocol", "hash"], "V1000", 'Required property "hash" is missing.'));
+    }
+    else if (typeof protocol.hash !== "string") {
+        issues.push(issue(["protocol", "hash"], "V1001", "Protocol hash must be a string."));
+    }
+    return issues;
+}
+function transportIssues(transport) {
+    if (!isRecord(transport)) {
+        return [
+            issue(["transport"], "V1001", "Transport metadata must be an object."),
+        ];
+    }
+    const issues = [];
+    if (transport.method !== "POST") {
+        issues.push(issue(["transport", "method"], "V1001", 'Transport method must be "POST".'));
+    }
+    const headers = transport.headers;
+    if (!isRecord(headers)) {
+        issues.push(issue(["transport", "headers"], "V1001", "Transport headers must be an object."));
+        return issues;
+    }
+    for (const [name, value] of Object.entries(headers)) {
+        if (typeof value !== "string") {
+            issues.push(issue(["transport", "headers", name], "V1001", "A transport header value must be a string."));
+        }
+    }
+    return issues;
+}
+function requiredStringIssue(request, member) {
+    const value = request[member];
+    if (value === undefined) {
+        return issue([member], "V1000", `Required property "${member}" is missing.`);
+    }
+    return typeof value === "string"
+        ? undefined
+        : issue([member], "V1001", `Property "${member}" must be a string.`);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function issue(path, code, message) {
+    return { path, code, message };
+}

package/dist/runtime/request-id.d.ts

@@ -1,13 +1,6 @@
 /**
- * The request id of one façade call or transaction run: the caller's
- * `ExecutionOptions.requestId` when it is a non-empty string, otherwise a minted
- * one. Nothing is refused (the call runs either way); the empty string is read
- * as absent, because it names nothing a log line or a diagnostic could be
- * correlated by.
- *
- * Read as `unknown` because the façades are total for untyped callers too: a
- * value the type refuses — a non-string id, a non-object options argument, a
- * getter that throws — is ignored rather than carried into a `string` slot or
- * thrown out of a call that must resolve.
+ * The request id of one call or transaction run: the caller's
+ * `ExecutionOptions.requestId` when it is a non-empty string, otherwise a new
+ * one. Any other value is ignored.
  */
 export declare function requestIdOf(options: unknown): string;