cvx-kit 0.1.11 → 0.1.13

package/CHANGELOG.md

@@ -12,6 +12,41 @@ are this file's matching section.
 
 ## [Unreleased]
 
+## [0.1.13] - 2026-10-10
+
+### Added
+
+- Implement contracted operations with `command.handler(handler, options?)` and
+  `query.handler(handler, options?)` in both Promise and Effect registries.
+- Infer each handler's input and result from its operation object key, without
+  repeating the operation name; preserve existing named helpers.
+
+### Verified
+
+- Cover contract binding, validation, audits, and handler inference with 684
+  runtime tests and strict type fixtures.
+- Compile the documentation examples and test packed npm/Bun consumers with
+  and without Effect.
+
+## [0.1.12] - 2026-10-10
+
+### Added
+
+- Declare optional domain contracts with root errors, command classification,
+  and exact command/query implementation keys in both Effect and Promise registries (#26).
+- Share a registry-level command audit default with per-operation overrides,
+  preserving replay bypass, schema inference, and transactional rollback.
+- Use `createFoundation` for typed Promise registries without installing Effect.
+- Enforce reserved domain file declarations through the packaged Oxlint plugin,
+  including constructor provenance and declarative contract ownership.
+- Document both contract APIs with packed-compiled examples and audit guidance.
+
+### Verified
+
+- Cover native validation, error projection, rollback, audit selection, agent tools,
+  workflow integration, and npm/Bun consumers with and without Effect.
+- Pass 680 runtime tests, 340 lint-rule tests, and both packed-component CI smoke tests.
+
 ## [0.1.11] - 2026-10-09
 
 ### Added

package/README.md

@@ -220,6 +220,7 @@ Load it in your application's `.oxlintrc.json` and select rules:
 		"cvx/application-orchestration": "error",
 		"cvx/internal-function-ownership": "error",
 		"cvx/domain-file-responsibilities": "error",
+		"cvx/reserved-domain-file-anatomy": "error",
 		"cvx/no-raw-builders": "error",
 		"cvx/no-handwritten-references": "error",
 		"cvx/domain-import-boundaries": "error",

package/dist/contracts.d.mts

@@ -1,4 +1,5 @@
 import { ContractExecution, ContractInput, ContractOutput, ContractSchema, Decoder, LegacyParser, NeutralSchema, StandardSchema, ValidationIssue, ValidationResult, decodeContract, operationContract } from "./modules/contracts/contract.mjs";
 import { standardContract, zodContract } from "./modules/contracts/standard.mjs";
 import { ConvexContractValue, convexContract } from "./modules/contracts/convex.mjs";
-export { type ContractExecution, type ContractInput, type ContractOutput, type ContractSchema, type ConvexContractValue, type Decoder, type LegacyParser, type NeutralSchema, type StandardSchema, type ValidationIssue, type ValidationResult, convexContract, decodeContract, operationContract, standardContract, zodContract };
+import { DomainAuditInput, DomainCommandContract, DomainContract, DomainOperationContract, DomainQueryContract, defineDomainContract } from "./modules/contracts/domain.mjs";
+export { type ContractExecution, type ContractInput, type ContractOutput, type ContractSchema, type ConvexContractValue, type Decoder, type DomainAuditInput, type DomainCommandContract, type DomainContract, type DomainOperationContract, type DomainQueryContract, type LegacyParser, type NeutralSchema, type StandardSchema, type ValidationIssue, type ValidationResult, convexContract, decodeContract, defineDomainContract, operationContract, standardContract, zodContract };

package/dist/contracts.mjs

@@ -1 +1 @@
-import{decodeContract as e,operationContract as t}from"./modules/contracts/contract.mjs";import{standardContract as n,zodContract as r}from"./modules/contracts/standard.mjs";import{convexContract as i}from"./modules/contracts/convex.mjs";export{i as convexContract,e as decodeContract,t as operationContract,n as standardContract,r as zodContract};
+import{decodeContract as e,operationContract as t}from"./modules/contracts/contract.mjs";import{standardContract as n,zodContract as r}from"./modules/contracts/standard.mjs";import{convexContract as i}from"./modules/contracts/convex.mjs";import{defineDomainContract as a}from"./modules/contracts/domain.mjs";export{i as convexContract,e as decodeContract,a as defineDomainContract,t as operationContract,n as standardContract,r as zodContract};

package/dist/index.d.mts

@@ -10,4 +10,5 @@ import { RateLimiterLike, rateLimit } from "./middleware.mjs";
 import { WebhookBoundaryConfig, createWebhookBoundary, recordWebhookEvent, webhookEventsTable } from "./webhooks.mjs";
 import { createStateMachine } from "./state-machine.mjs";
 import { Change, Trigger, Triggers, appendOnly, createTriggers, noDelete, tenantOwnership, timestamps } from "./triggers.mjs";
-export { type Actor, type AgentToolHandlers, type AgentToolRecord, type AnyCommandMiddleware, type AnyQueryMiddleware, type ApplicationCommand, type AuditEntryInput, type AuditWriter, type AuditedOperation, type AuditedRegistry, type AuthBundle, type AuthFunctions, type AuthFunctionsConfig, type Change, type CommandConstructor, type CommandDefaults, type CommandMiddleware, type CrudConfig, type DefaultRole, type ErrorFactory, Foundation, type FoundationOptions, type Include, type IncludedQuery, KitError, type PermissionChecker, type QueryMiddleware, type RLSConfig, type RateLimiterLike, type Rules, type SecurityConfig, TENANT_FIELD, TIMESTAMP_FIELDS, type TableBoundaryOptions, type Trigger, Triggers, type WebhookBoundaryConfig, appendOnly, assertTenantOwned, composeRules, createAgentTools, createAuthFunctions, createCrudCommands, createInclude, createModule, createStateMachine, createTenantRules, createTriggers, createWebhookBoundary, defaultErrors, defaultRoleMap, jsonSafeZid, noDelete, paginated, rateLimit, recordWebhookEvent, requireTenantReference, tenantOwnership, tenantTable, timestamps, webhookEventsTable, zodTable, zodVariantTable };
+import { FoundationRegistry, FoundationRegistryOptions, createFoundation } from "./modules/foundation/foundation.mjs";
+export { type Actor, type AgentToolHandlers, type AgentToolRecord, type AnyCommandMiddleware, type AnyQueryMiddleware, type ApplicationCommand, type AuditEntryInput, type AuditWriter, type AuditedOperation, type AuditedRegistry, type AuthBundle, type AuthFunctions, type AuthFunctionsConfig, type Change, type CommandConstructor, type CommandDefaults, type CommandMiddleware, type CrudConfig, type DefaultRole, type ErrorFactory, Foundation, type FoundationOptions, type FoundationRegistry, type FoundationRegistryOptions, type Include, type IncludedQuery, KitError, type PermissionChecker, type QueryMiddleware, type RLSConfig, type RateLimiterLike, type Rules, type SecurityConfig, TENANT_FIELD, TIMESTAMP_FIELDS, type TableBoundaryOptions, type Trigger, Triggers, type WebhookBoundaryConfig, appendOnly, assertTenantOwned, composeRules, createAgentTools, createAuthFunctions, createCrudCommands, createFoundation, createInclude, createModule, createStateMachine, createTenantRules, createTriggers, createWebhookBoundary, defaultErrors, defaultRoleMap, jsonSafeZid, noDelete, paginated, rateLimit, recordWebhookEvent, requireTenantReference, tenantOwnership, tenantTable, timestamps, webhookEventsTable, zodTable, zodVariantTable };

package/dist/index.mjs

@@ -1 +1 @@
-import{createAgentTools as e}from"./agent-tools.mjs";import{KitError as t,defaultErrors as n}from"./errors.mjs";import{TENANT_FIELD as r,assertTenantOwned as i,composeRules as a,createTenantRules as o,requireTenantReference as s}from"./tenancy.mjs";import{createAuthFunctions as c,createInclude as l,defaultRoleMap as u}from"./auth.mjs";import{createCrudCommands as d}from"./crud.mjs";import{TIMESTAMP_FIELDS as f,createModule as p,jsonSafeZid as m,paginated as h,tenantTable as g,zodTable as _,zodVariantTable as v}from"./zod-table.mjs";import{rateLimit as y}from"./middleware.mjs";import{createWebhookBoundary as b,recordWebhookEvent as x,webhookEventsTable as S}from"./webhooks.mjs";import{createStateMachine as C}from"./state-machine.mjs";import{Triggers as w,appendOnly as T,createTriggers as E,noDelete as D,tenantOwnership as O,timestamps as k}from"./triggers.mjs";import{Foundation as A}from"./components/foundation/client.mjs";export{A as Foundation,t as KitError,r as TENANT_FIELD,f as TIMESTAMP_FIELDS,w as Triggers,T as appendOnly,i as assertTenantOwned,a as composeRules,e as createAgentTools,c as createAuthFunctions,d as createCrudCommands,l as createInclude,p as createModule,C as createStateMachine,o as createTenantRules,E as createTriggers,b as createWebhookBoundary,n as defaultErrors,u as defaultRoleMap,m as jsonSafeZid,D as noDelete,h as paginated,y as rateLimit,x as recordWebhookEvent,s as requireTenantReference,O as tenantOwnership,g as tenantTable,k as timestamps,S as webhookEventsTable,_ as zodTable,v as zodVariantTable};
+import{createAgentTools as e}from"./agent-tools.mjs";import{KitError as t,defaultErrors as n}from"./errors.mjs";import{TENANT_FIELD as r,assertTenantOwned as i,composeRules as a,createTenantRules as o,requireTenantReference as s}from"./tenancy.mjs";import{createAuthFunctions as c,createInclude as l,defaultRoleMap as u}from"./auth.mjs";import{createCrudCommands as d}from"./crud.mjs";import{TIMESTAMP_FIELDS as f,createModule as p,jsonSafeZid as m,paginated as h,tenantTable as g,zodTable as _,zodVariantTable as v}from"./zod-table.mjs";import{rateLimit as y}from"./middleware.mjs";import{createWebhookBoundary as b,recordWebhookEvent as x,webhookEventsTable as S}from"./webhooks.mjs";import{createStateMachine as C}from"./state-machine.mjs";import{Triggers as w,appendOnly as T,createTriggers as E,noDelete as D,tenantOwnership as O,timestamps as k}from"./triggers.mjs";import{Foundation as A}from"./components/foundation/client.mjs";import{createFoundation as j}from"./modules/foundation/foundation.mjs";export{A as Foundation,t as KitError,r as TENANT_FIELD,f as TIMESTAMP_FIELDS,w as Triggers,T as appendOnly,i as assertTenantOwned,a as composeRules,e as createAgentTools,c as createAuthFunctions,d as createCrudCommands,j as createFoundation,l as createInclude,p as createModule,C as createStateMachine,o as createTenantRules,E as createTriggers,b as createWebhookBoundary,n as defaultErrors,u as defaultRoleMap,m as jsonSafeZid,D as noDelete,h as paginated,y as rateLimit,x as recordWebhookEvent,s as requireTenantReference,O as tenantOwnership,g as tenantTable,k as timestamps,S as webhookEventsTable,_ as zodTable,v as zodVariantTable};

package/dist/modules/contracts/binding.d.mts

@@ -0,0 +1,26 @@
+import { DomainContract, DomainOperationContract } from "./domain.mjs";
+//#region src/modules/contracts/binding.d.ts
+declare const declaredSchemas: unique symbol;
+/** Private evidence for contextual inference; schemas are installed only at registration. */
+export type DeclaredSchemas<Entry> = {
+  readonly [declaredSchemas]: Entry;
+};
+export type BoundOperations<Operations extends Readonly<Record<keyof Entries, {
+  handler: (...arguments_: never[]) => unknown;
+}>>, Entries extends Readonly<Record<string, DomainOperationContract>>> = { [Key in keyof Entries]: Entries[Key] & Operations[Key] & {
+  input: Entries[Key]['input'];
+  result: Entries[Key]['result'];
+  handler: Operations[Key]['handler'];
+}; };
+/** Both adapters bind declarations through the same configuration boundary. */
+export declare function domainHelpers(entries: Readonly<Record<string, object>>): {
+  [k: string]: (implementation: object) => {};
+};
+/** Bind only opaque schema references; never invoke user callbacks at construction. */
+export declare function bindDomainImplementation(key: string, declaration: object, implementation: object): {};
+/** Snapshot records and verify key ownership before the executor closes over them. */
+export declare function snapshotOperations(operations: Readonly<Record<string, object>>, contract: DomainContract | undefined, section: 'commands' | 'queries', audit?: (resolution: never, context: never) => unknown): Readonly<{
+  [k: string]: Readonly<Record<string, unknown>>;
+}>;
+//#endregion
+//# sourceMappingURL=binding.d.mts.map

package/dist/modules/contracts/binding.mjs

@@ -0,0 +1,2 @@
+const e=[`input`,`result`,`classification`,`replayResult`,`wire`],t=/* @__PURE__ */ new WeakMap,n=/* @__PURE__ */ new WeakMap;function r(e){let t=Object.fromEntries(Object.keys(e).map(t=>[t,n=>i(t,e[t],n)])),r=t.handler;return t.handler=(t,i)=>{if(typeof t!=`function`&&r)return r(t);if(typeof t!=`function`)throw Error(`Invalid operation handler`);let a={...i,handler:t};return n.set(a,e),a},t}function i(n,r,i){for(let e of[`handler`,`audit`,`prepare`,`guard`,`middleware`,`context`])if(Object.prototype.hasOwnProperty.call(r,e))throw Error(`Domain contract ${n} cannot contain ${e}`);for(let t of e)if(Object.prototype.hasOwnProperty.call(i,t))throw Error(`Contracted operation ${n} cannot override ${t}`);let a={...i,...r};return t.set(a,{key:n,declaration:r}),a}function a(r,a,o,s){if(s!==void 0&&typeof s!=`function`)throw Error(`Invalid registry audit callback`);let c=a?.[o];if(a&&!c)throw Error(`Domain contract has no ${o} section`);let l=Object.keys(r);if(c&&(l.length!==Object.keys(c).length||l.some(e=>!Object.prototype.hasOwnProperty.call(c,e))))throw Error(`Contract operation keys must match exactly`);let u=l.map(a=>{let l=r[a];if(c){if(n.has(l)){if(n.get(l)!==c)throw Error(`Operation ${a} must use its own contract helper`);l=i(a,c[a],l)}let r=t.get(l);if(!r||r.key!==a||r.declaration!==c[a]||e.some(e=>l[e]!==c[a][e]))throw Error(`Operation ${a} must use its own contract helper`)}let u={...l};if(u.wire&&=Object.freeze({...u.wire}),o===`commands`){let e=u.audit;if(e!==void 0&&typeof e!=`function`)throw Error(`Invalid audit for ${a}`);if(e===void 0){if(!s)throw Error(`Command ${a} requires an audit callback`);u.audit=(e,t)=>s({operation:a,input:e.command,result:e.result},t)}}return[a,Object.freeze(u)]});return Object.freeze(Object.fromEntries(u))}export{i as bindDomainImplementation,r as domainHelpers,a as snapshotOperations};
+//# sourceMappingURL=binding.mjs.map

package/dist/modules/contracts/binding.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.mjs","names":["protectedFields","bindings","pending","domainHelpers","helpers","entries","key","bindDomainImplementation","implementation","namedHandler","handler","options","field","declaration","definition","snapshotOperations","audit","declarations","contract","section","keys","operations","original","binding","override","resolution","context"],"sources":["../../../src/modules/contracts/binding.ts"],"sourcesContent":["/* oxlint-disable anti-slop/no-object-parameters, anti-slop/no-unsafe-dictionary-type, anti-slop/no-known-value-widening, anti-slop/no-runtime-typeof, anti-slop/no-unknown-parameters, anti-slop/no-unknown-returns -- Configuration boundary validates heterogeneous own-key records and callback presence; validators remain opaque identities. */\nimport type { DomainContract, DomainOperationContract } from './domain'\n\ndeclare const declaredSchemas: unique symbol\n/** Private evidence for contextual inference; schemas are installed only at registration. */\nexport type DeclaredSchemas<Entry> = { readonly [declaredSchemas]: Entry }\nexport type BoundOperations<\n\tOperations extends Readonly<\n\t\tRecord<keyof Entries, { handler: (...arguments_: never[]) => unknown }>\n\t>,\n\tEntries extends Readonly<Record<string, DomainOperationContract>>,\n> = {\n\t[Key in keyof Entries]: Entries[Key] &\n\t\tOperations[Key] & {\n\t\t\tinput: Entries[Key]['input']\n\t\t\tresult: Entries[Key]['result']\n\t\t\thandler: Operations[Key]['handler']\n\t\t}\n}\n\n// SAFETY: this configuration boundary compares opaque fields or restores callback slots checked by the public helpers.\nconst protectedFields = ['input', 'result', 'classification', 'replayResult', 'wire'] as const\nconst bindings = new WeakMap<object, { key: string; declaration: object }>()\nconst pending = new WeakMap<object, Readonly<Record<string, object>>>()\n\n/** Both adapters bind declarations through the same configuration boundary. */\nexport function domainHelpers(entries: Readonly<Record<string, object>>) {\n\tconst helpers = Object.fromEntries(\n\t\tObject.keys(entries).map((key) => [\n\t\t\tkey,\n\t\t\t(implementation: object) => bindDomainImplementation(key, entries[key], implementation),\n\t\t]),\n\t)\n\tconst namedHandler = helpers.handler\n\thelpers.handler = (handler: Function | object, options?: object) => {\n\t\tif (typeof handler !== 'function' && namedHandler) return namedHandler(handler)\n\t\tif (typeof handler !== 'function') throw Error('Invalid operation handler')\n\t\tconst implementation = { ...options, handler }\n\t\tpending.set(implementation, entries)\n\t\treturn implementation\n\t}\n\treturn helpers\n}\n\n/** Bind only opaque schema references; never invoke user callbacks at construction. */\nexport function bindDomainImplementation(key: string, declaration: object, implementation: object) {\n\tfor (const field of ['handler', 'audit', 'prepare', 'guard', 'middleware', 'context']) {\n\t\tif (Object.prototype.hasOwnProperty.call(declaration, field))\n\t\t\tthrow Error(`Domain contract ${key} cannot contain ${field}`)\n\t}\n\tfor (const field of protectedFields) {\n\t\tif (Object.prototype.hasOwnProperty.call(implementation, field))\n\t\t\tthrow Error(`Contracted operation ${key} cannot override ${field}`)\n\t}\n\tconst definition = { ...implementation, ...declaration }\n\tbindings.set(definition, { key, declaration })\n\treturn definition\n}\n\n/** Snapshot records and verify key ownership before the executor closes over them. */\nexport function snapshotOperations(\n\toperations: Readonly<Record<string, object>>,\n\tcontract: DomainContract | undefined,\n\tsection: 'commands' | 'queries',\n\taudit?: (resolution: never, context: never) => unknown,\n) {\n\tif (audit !== undefined && typeof audit !== 'function')\n\t\tthrow Error('Invalid registry audit callback')\n\tconst declarations = contract?.[section]\n\tif (contract && !declarations) throw Error(`Domain contract has no ${section} section`)\n\tconst keys = Object.keys(operations)\n\tif (\n\t\tdeclarations &&\n\t\t(keys.length !== Object.keys(declarations).length ||\n\t\t\tkeys.some((key) => !Object.prototype.hasOwnProperty.call(declarations, key)))\n\t)\n\t\tthrow Error('Contract operation keys must match exactly')\n\tconst entries = keys.map((key) => {\n\t\tlet original = operations[key]\n\t\tif (declarations) {\n\t\t\tif (pending.has(original)) {\n\t\t\t\tif (pending.get(original) !== declarations)\n\t\t\t\t\tthrow Error(`Operation ${key} must use its own contract helper`)\n\t\t\t\toriginal = bindDomainImplementation(key, declarations[key], original)\n\t\t\t}\n\t\t\tconst binding = bindings.get(original)\n\t\t\tif (\n\t\t\t\t!binding ||\n\t\t\t\tbinding.key !== key ||\n\t\t\t\tbinding.declaration !== declarations[key] ||\n\t\t\t\tprotectedFields.some(\n\t\t\t\t\t(field) =>\n\t\t\t\t\t\t// SAFETY: this configuration boundary compares opaque fields or restores callback slots checked by the public helpers.\n\t\t\t\t\t\t(original as Record<string, unknown>)[field] !==\n\t\t\t\t\t\t// SAFETY: this configuration boundary compares opaque fields or restores callback slots checked by the public helpers.\n\t\t\t\t\t\t(declarations[key] as Record<string, unknown>)[field],\n\t\t\t\t)\n\t\t\t)\n\t\t\t\tthrow Error(`Operation ${key} must use its own contract helper`)\n\t\t}\n\t\t// SAFETY: this configuration boundary compares opaque fields or restores callback slots checked by the public helpers.\n\t\tconst definition = { ...original } as Record<string, unknown>\n\t\tif (definition.wire) {\n\t\t\t// SAFETY: wire is configuration, while its schema stays an opaque reference.\n\t\t\tdefinition.wire = Object.freeze({ ...(definition.wire as object) })\n\t\t}\n\t\tif (section === 'commands') {\n\t\t\tconst override = definition.audit\n\t\t\tif (override !== undefined && typeof override !== 'function')\n\t\t\t\tthrow Error(`Invalid audit for ${key}`)\n\t\t\tif (override === undefined) {\n\t\t\t\tif (!audit) throw Error(`Command ${key} requires an audit callback`)\n\t\t\t\tdefinition.audit = (resolution: { command: unknown; result: unknown }, context: unknown) =>\n\t\t\t\t\taudit(\n\t\t\t\t\t\t// SAFETY: this configuration boundary compares opaque fields or restores callback slots checked by the public helpers.\n\t\t\t\t\t\t{ operation: key, input: resolution.command, result: resolution.result } as never,\n\t\t\t\t\t\t// SAFETY: this configuration boundary compares opaque fields or restores callback slots checked by the public helpers.\n\t\t\t\t\t\tcontext as never,\n\t\t\t\t\t)\n\t\t\t}\n\t\t}\n\t\t// SAFETY: this configuration boundary compares opaque fields or restores callback slots checked by the public helpers.\n\t\treturn [key, Object.freeze(definition)] as const\n\t})\n\treturn Object.freeze(Object.fromEntries(entries))\n}\n"],"mappings":"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"}

package/dist/modules/contracts/domain.d.mts

@@ -0,0 +1,59 @@
+import { ContractInput, ContractOutput, ContractSchema } from "./contract.mjs";
+import { ErrorContract, ErrorDefinitions } from "./errors.mjs";
+//#region src/modules/contracts/domain.d.ts
+/** Schema-only domain vocabulary; implementations and host policies live in registries. */
+export type DomainOperationContract = {
+  readonly input: ContractSchema;
+  readonly result: ContractSchema;
+  readonly classification?: string;
+  readonly wire?: {
+    readonly schema: ContractSchema;
+    readonly project: Function;
+  };
+};
+export type DomainCommandContract = DomainOperationContract & {
+  readonly classification: string;
+  readonly replayResult?: ContractSchema;
+};
+export type DomainQueryContract = DomainOperationContract & {
+  readonly replayResult?: never;
+};
+export type DomainContract = {
+  readonly errors?: Pick<ErrorContract<ErrorDefinitions>, 'project'>;
+  readonly commands?: Readonly<Record<string, DomainCommandContract>>;
+  readonly queries?: Readonly<Record<string, DomainQueryContract>>;
+};
+type CheckedEntry<Entry extends DomainOperationContract> = {
+  readonly handler?: never;
+  readonly audit?: never;
+  readonly prepare?: never;
+  readonly guard?: never;
+  readonly middleware?: never;
+  readonly context?: never;
+  readonly wire?: Entry extends {
+    wire: {
+      schema: infer Wire;
+    };
+  } ? {
+    readonly schema: Wire;
+    readonly project: (value: ContractOutput<Entry['result']>) => ContractInput<Wire>;
+  } : never;
+} & (Entry extends {
+  replayResult: infer Replay;
+} ? {
+  readonly replayResult: ContractOutput<Replay> extends ContractOutput<Entry['result']> ? Replay : never;
+} : {});
+type CheckedSection<Section> = { readonly [Key in keyof Section]: Section[Key] extends DomainOperationContract ? CheckedEntry<Section[Key]> : never; };
+type CheckedDomain<Definition> = { readonly [Section in Extract<keyof Definition, 'commands' | 'queries'>]: CheckedSection<Definition[Section]>; };
+/** Preserve the declaration's literal keys and opaque validator/error-contract identities. */
+export declare function defineDomainContract<const Definition extends DomainContract>(definition: Definition & NoInfer<CheckedDomain<Definition>>): Definition;
+/** Exactness applies to variables as well as fresh object literals. */
+export type ExactOperationKeys<Operations, Contracts> = Exclude<keyof Operations, keyof Contracts> extends never ? Exclude<keyof Contracts, keyof Operations> extends never ? string extends keyof Contracts ? never : unknown : never : never;
+/** Correlated callback envelope for registry-level command audit. */
+export type DomainAuditInput<Commands> = { [Key in Extract<keyof Commands, string>]: Commands[Key] extends DomainOperationContract ? {
+  operation: Key;
+  input: ContractOutput<Commands[Key]['input']>;
+  result: ContractOutput<Commands[Key]['result']>;
+} : never; }[Extract<keyof Commands, string>];
+//#endregion
+//# sourceMappingURL=domain.d.mts.map

package/dist/modules/contracts/domain.mjs

@@ -0,0 +1,2 @@
+function e(e){return e}export{e as defineDomainContract};
+//# sourceMappingURL=domain.mjs.map

package/dist/modules/contracts/domain.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.mjs","names":["defineDomainContract","definition"],"sources":["../../../src/modules/contracts/domain.ts"],"sourcesContent":["import type { ContractSchema, ContractInput, ContractOutput } from './contract'\nimport type { ErrorContract, ErrorDefinitions } from './errors'\n\n/** Schema-only domain vocabulary; implementations and host policies live in registries. */\nexport type DomainOperationContract = {\n\treadonly input: ContractSchema\n\treadonly result: ContractSchema\n\treadonly classification?: string\n\treadonly wire?: { readonly schema: ContractSchema; readonly project: Function }\n}\nexport type DomainCommandContract = DomainOperationContract & {\n\treadonly classification: string\n\treadonly replayResult?: ContractSchema\n}\nexport type DomainQueryContract = DomainOperationContract & { readonly replayResult?: never }\nexport type DomainContract = {\n\treadonly errors?: Pick<ErrorContract<ErrorDefinitions>, 'project'>\n\treadonly commands?: Readonly<Record<string, DomainCommandContract>>\n\treadonly queries?: Readonly<Record<string, DomainQueryContract>>\n}\n\ntype CheckedEntry<Entry extends DomainOperationContract> = {\n\treadonly handler?: never\n\treadonly audit?: never\n\treadonly prepare?: never\n\treadonly guard?: never\n\treadonly middleware?: never\n\treadonly context?: never\n\treadonly wire?: Entry extends { wire: { schema: infer Wire } }\n\t\t? {\n\t\t\t\treadonly schema: Wire\n\t\t\t\treadonly project: (value: ContractOutput<Entry['result']>) => ContractInput<Wire>\n\t\t\t}\n\t\t: never\n} & (Entry extends { replayResult: infer Replay }\n\t? {\n\t\t\treadonly replayResult: ContractOutput<Replay> extends ContractOutput<Entry['result']>\n\t\t\t\t? Replay\n\t\t\t\t: never\n\t\t}\n\t: {})\ntype CheckedSection<Section> = {\n\treadonly [Key in keyof Section]: Section[Key] extends DomainOperationContract\n\t\t? CheckedEntry<Section[Key]>\n\t\t: never\n}\ntype CheckedDomain<Definition> = {\n\treadonly [Section in Extract<keyof Definition, 'commands' | 'queries'>]: CheckedSection<\n\t\tDefinition[Section]\n\t>\n}\n\n/** Preserve the declaration's literal keys and opaque validator/error-contract identities. */\nexport function defineDomainContract<const Definition extends DomainContract>(\n\tdefinition: Definition & NoInfer<CheckedDomain<Definition>>,\n): Definition {\n\treturn definition\n}\n\n/** Exactness applies to variables as well as fresh object literals. */\nexport type ExactOperationKeys<Operations, Contracts> =\n\tExclude<keyof Operations, keyof Contracts> extends never\n\t\t? Exclude<keyof Contracts, keyof Operations> extends never\n\t\t\t? string extends keyof Contracts\n\t\t\t\t? never\n\t\t\t\t: unknown\n\t\t\t: never\n\t\t: never\n\n/** Correlated callback envelope for registry-level command audit. */\nexport type DomainAuditInput<Commands> = {\n\t[Key in Extract<keyof Commands, string>]: Commands[Key] extends DomainOperationContract\n\t\t? {\n\t\t\t\toperation: Key\n\t\t\t\tinput: ContractOutput<Commands[Key]['input']>\n\t\t\t\tresult: ContractOutput<Commands[Key]['result']>\n\t\t\t}\n\t\t: never\n}[Extract<keyof Commands, string>]\n"],"mappings":"AAqDA,SAAgBA,EACf,EACa,CACb,OAAOC,CACR"}

package/dist/modules/effect/command.d.mts

@@ -2,7 +2,10 @@ import { ContractOutput, ContractSchema } from "../contracts/contract.mjs";
 import { OperationPublicResult, SelectedOperation } from "../contracts/exposure.mjs";
 import { Observability } from "../../components/foundation/modules/observability/observability.mjs";
 import { AuditEntryInput } from "../../components/foundation/client.mjs";
+import { DomainAuditInput, DomainCommandContract, DomainContract } from "../contracts/domain.mjs";
 import { CallbackError, CallbackRequirements, CheckedEffectOperation, EffectOperationArgument, EffectOperationError, EffectOperationRequirements, EffectOperationResult, EffectValue, UnwrappedDefaultError, UnwrappedDefaultRequirements, ValidatedEffectOperations, effectOperationFactory } from "./operation.mjs";
+import { BoundOperations } from "../contracts/binding.mjs";
+import { AuditValue, AuditedOperations, DomainEffectFactory, DomainEffectImplementations, ExactDomainOperations, SharedEffectFactory } from "./domain.mjs";
 import { Effect } from "effect";
 //#region src/modules/effect/command.d.ts
 type Supported<Value> = Value | PromiseLike<Value> | Effect.Effect<Value, unknown, unknown>;
@@ -57,6 +60,41 @@ export declare function createEffectCommand<Resolve extends Resolver, const Oper
   exec: <Key extends Extract<keyof Operations, string>>(operation: Key, input: EffectOperationArgument<Operations[Key]>, host: HostOf<Resolve>) => Effect.Effect<EffectOperationResult<Operations[Key]>, ErrorOf<Operations[Key], Resolve, Dependencies, Guard>, RequirementsOf<Operations[Key], Resolve, Dependencies, Guard>>;
 };
 /** Bind trusted application policies without exposing a loose public command kernel. */
-export declare function bindEffectCommand<const Dependencies extends EffectCommandDependencies>(dependencies: Dependencies): <Resolve extends Resolver, const Operations extends Registry<DomainOf<Resolve>>, Guard = never>(configuration: EffectCommandConfiguration<Resolve, Operations, Guard> & HostCompatible<Resolve, Dependencies>) => ReturnType<typeof createEffectCommand<Resolve, Operations, Dependencies, Guard>>;
+export declare function bindEffectCommand<const Dependencies extends EffectCommandDependencies>(dependencies: Dependencies): {
+  <Resolve extends Resolver, const Contract extends DomainContract & {
+    commands: Readonly<Record<string, DomainCommandContract>>;
+  }, const Operations extends DomainEffectImplementations<DomainOf<Resolve>, Contract['commands'], true>, Mode extends true, Guard = never>(configuration: {
+    contract: Contract & NoInfer<Operations extends ExactDomainOperations<Operations, Contract['commands']> & ValidatedEffectOperations<Operations> ? unknown : never>;
+    context: Resolve;
+    audit?: never;
+    operations: (define: DomainEffectFactory<DomainOf<Resolve>, Contract['commands'], Mode, never, NoInfer<CallbackError<Guard>>, NoInfer<CallbackRequirements<Guard>>>) => Operations;
+    defaults?: {
+      guard?: (context: DomainOf<Resolve>) => Guard;
+    };
+  } & HostCompatible<Resolve, Dependencies>): ReturnType<typeof createEffectCommand<Resolve, BoundOperations<Operations, Contract['commands']> & { [Key in keyof Contract['commands']]: {
+    classification: Contract['commands'][Key]['classification'];
+    audit: Operations[Key]['audit'];
+  }; }, Dependencies, Guard>>;
+  <Resolve extends Resolver, const Contract extends DomainContract & {
+    commands: Readonly<Record<string, DomainCommandContract>>;
+  }, const Operations extends DomainEffectImplementations<DomainOf<Resolve>, Contract['commands']>, Returned extends AuditValue, Guard = never>(configuration: {
+    contract: Contract & NoInfer<Operations extends ExactDomainOperations<Operations, Contract['commands']> & ValidatedEffectOperations<Operations> ? unknown : never>;
+    context: Resolve;
+    audit: (resolution: DomainAuditInput<Contract['commands']>, context: DomainOf<Resolve>) => Returned;
+    operations: (define: DomainEffectFactory<DomainOf<Resolve>, Contract['commands'], true, [Returned] extends [never] ? never : (resolution: never, context: never) => Returned, NoInfer<CallbackError<Guard>>, NoInfer<CallbackRequirements<Guard>>>) => Operations;
+    defaults?: {
+      guard?: (context: DomainOf<Resolve>) => Guard;
+    };
+  } & HostCompatible<Resolve, Dependencies>): ReturnType<typeof createEffectCommand<Resolve, AuditedOperations<BoundOperations<Operations, Contract['commands']>, (resolution: never, context: never) => Returned>, Dependencies, Guard>>;
+  <Resolve extends Resolver, const Operations extends Readonly<Record<string, Pick<Operation, "classification" | "handler" | "input" | "result"> & CheckedEffectOperation<EffectValue<ReturnType<Resolve>>>>>, Returned extends AuditValue, Guard>(configuration: {
+    context: Resolve;
+    audit: (resolution: DomainAuditInput<Operations>, context: DomainOf<Resolve>) => Returned;
+    operations: (define: SharedEffectFactory<DomainOf<Resolve>, Guard>) => Operations & NoInfer<ValidatedEffectOperations<Operations>>;
+    defaults?: {
+      guard?: (context: DomainOf<Resolve>) => Guard;
+    };
+  } & HostCompatible<Resolve, Dependencies>): ReturnType<typeof createEffectCommand<Resolve, AuditedOperations<Operations, (resolution: never, context: never) => Returned>, Dependencies, Guard>>;
+  <Resolve extends Resolver, const Operations extends Registry<DomainOf<Resolve>>, Guard = never>(configuration: EffectCommandConfiguration<Resolve, Operations, Guard> & HostCompatible<Resolve, Dependencies>): ReturnType<typeof createEffectCommand<Resolve, Operations, Dependencies, Guard>>;
+};
 //#endregion
 //# sourceMappingURL=command.d.mts.map

package/dist/modules/effect/command.mjs

@@ -1,2 +1,2 @@
-import{selectOperation as e}from"../contracts/exposure.mjs";import{normalizeEffect as t,observationFailure as n}from"./normalize.mjs";import{effectOperationFactory as r}from"./operation.mjs";import{decodeEffectContract as i}from"./schema.mjs";import{CommandPermissionError as a,executeCommandLifecycle as o}from"../../components/foundation/modules/command/lifecycle.mjs";import{Effect as s,Exit as c}from"effect";const l={succeed:s.succeed,suspend:s.suspend,flatMap:s.flatMap};function u(u){let d=u.operations(r()),p=(e,r,p)=>s.suspend(()=>{if(!Object.prototype.hasOwnProperty.call(d,e))throw Error(`The selected command operation is not configured`);let m=d[e];return s.flatMap(i(m.input,r),r=>{let d=r,h=u.observability.start({operation:e,classification:m.classification}),g=u.context;return t(()=>g(p)).pipe(s.flatMap(n=>o(l,{operation:e,classification:m.classification,context:n,command:d,permission:m.permission===void 0?void 0:()=>t(()=>{if(!u.checkPermission)throw new a(e);return u.checkPermission(p,{permission:m.permission,operation:e})}).pipe(s.asVoid),prepare:()=>t(()=>m.prepare?.(n,d)).pipe(s.map(e=>e?.kind===`execute`?{kind:`execute`,complete:e.complete?n=>t(()=>e.complete(n)).pipe(s.asVoid):void 0}:e)),decodeReplay:e=>i(m.replayResult??m.result,e),middleware:m.middleware?[e=>f(()=>m.middleware({...e,input:d}))]:[],defaultGuard:e=>t(()=>u.defaults?.guard?.(e)).pipe(s.asVoid),guard:e=>t(()=>m.guard?.(e,d)).pipe(s.asVoid),run:e=>f(()=>m.handler(d,e)),decodeResult:e=>i(m.result,e),audit:e=>t(()=>m.audit({command:d,result:e},n)),writeAudit:e=>t(()=>u.writeAudit(p,e)),aggregates:m.aggregates})),s.onExit(e=>s.sync(()=>{c.isSuccess(e)?h.completed():h.failed(n(e.cause))})))})});return{withContext(e){return{exec:(t,n)=>p(t,n,e)}},expose(t,n){if(!Object.hasOwn(d,n))throw Error(`The selected command operation is not configured`);return e(t,`mutation`,n,d[n])},exec:p}}function d(e){return function(t){return u({...t,...e})}}function f(e){return t(e)}export{d as bindEffectCommand,u as createEffectCommand};
+import{selectOperation as e}from"../contracts/exposure.mjs";import{normalizeEffect as t,observationFailure as n}from"./normalize.mjs";import{effectOperationFactory as r}from"./operation.mjs";import{decodeEffectContract as i}from"./schema.mjs";import{CommandPermissionError as a,executeCommandLifecycle as o}from"../../components/foundation/modules/command/lifecycle.mjs";import{snapshotOperations as s}from"../contracts/binding.mjs";import{domainEffectFactory as c}from"./domain.mjs";import{Effect as l,Exit as u}from"effect";const d={succeed:l.succeed,suspend:l.suspend,flatMap:l.flatMap};function f(s){let c=s.operations(r()),f=(e,r,f)=>l.suspend(()=>{if(!Object.prototype.hasOwnProperty.call(c,e))throw Error(`The selected command operation is not configured`);let p=c[e];return l.flatMap(i(p.input,r),r=>{let c=r,h=s.observability.start({operation:e,classification:p.classification}),g=s.context;return t(()=>g(f)).pipe(l.flatMap(n=>o(d,{operation:e,classification:p.classification,context:n,command:c,permission:p.permission===void 0?void 0:()=>t(()=>{if(!s.checkPermission)throw new a(e);return s.checkPermission(f,{permission:p.permission,operation:e})}).pipe(l.asVoid),prepare:()=>t(()=>p.prepare?.(n,c)).pipe(l.map(e=>e?.kind===`execute`?{kind:`execute`,complete:e.complete?n=>t(()=>e.complete(n)).pipe(l.asVoid):void 0}:e)),decodeReplay:e=>i(p.replayResult??p.result,e),middleware:p.middleware?[e=>m(()=>p.middleware({...e,input:c}))]:[],defaultGuard:e=>t(()=>s.defaults?.guard?.(e)).pipe(l.asVoid),guard:e=>t(()=>p.guard?.(e,c)).pipe(l.asVoid),run:e=>m(()=>p.handler(c,e)),decodeResult:e=>i(p.result,e),audit:e=>t(()=>p.audit({command:c,result:e},n)),writeAudit:e=>t(()=>s.writeAudit(f,e)),aggregates:p.aggregates})),l.onExit(e=>l.sync(()=>{u.isSuccess(e)?h.completed():h.failed(n(e.cause))})))})});return{withContext(e){return{exec:(t,n)=>f(t,n,e)}},expose(t,n){if(!Object.hasOwn(c,n))throw Error(`The selected command operation is not configured`);return e(t,`mutation`,n,c[n])},exec:f}}function p(e){function t(t){let n=t.contract?c(t.contract.commands??{},!0):r(),i=s(t.operations(n),t.contract,`commands`,t.audit);return f({...t,...e,operations:()=>i})}return t}function m(e){return t(e)}export{p as bindEffectCommand,f as createEffectCommand};
 //# sourceMappingURL=command.mjs.map

package/dist/modules/effect/command.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"command.mjs","names":["effectLifecycle","Effect","createEffectCommand","operations","configuration","effectOperationFactory","exec","operation","definition","decodeEffectContract","input","command","decoded","observation","resolve","normalizeEffect","host","executeCommandLifecycle","CommandPermissionError","context","preparation","result","value","normalizeCommandResult","input_","enriched","entry","Exit","exit","observationFailure","selectOperation","owner","bindEffectCommand","dependencies","invoke"],"sources":["../../../src/modules/effect/command.ts"],"sourcesContent":["import { Effect, Exit } from 'effect'\nimport type { AuditEntryInput } from '../../components/foundation/client'\nimport type { ContractSchema } from '../contracts/contract'\nimport {\n\tselectOperation,\n\ttype SelectedOperation,\n\ttype OperationPublicResult,\n} from '../contracts/exposure'\nimport { decodeEffectContract } from './schema'\n// oxlint-disable-next-line cvx/component-boundaries -- SAFETY: Internal optional adapter shares the Effect-free Foundation lifecycle and types without entering the Convex component deployment graph.\nimport {\n\tCommandPermissionError,\n\texecuteCommandLifecycle,\n\ttype ExecutionKind,\n\ttype LifecycleAlgebra,\n\ttype LifecyclePreparation,\n} from '../../components/foundation/modules/command/lifecycle'\n// oxlint-disable-next-line cvx/component-boundaries -- SAFETY: Internal optional adapter shares the Effect-free Foundation lifecycle and types without entering the Convex component deployment graph.\nimport type { Observability } from '../../components/foundation/modules/observability/observability'\nimport { normalizeEffect, observationFailure } from './normalize'\nimport {\n\teffectOperationFactory,\n\ttype CallbackError,\n\ttype CallbackRequirements,\n\ttype EffectValue,\n\ttype EffectOperationArgument,\n\ttype EffectOperationInput,\n\ttype EffectOperationHandlerResult,\n\ttype EffectPreparation,\n\ttype EffectOperationResult,\n\ttype EffectOperationError,\n\ttype EffectOperationRequirements,\n\ttype CheckedEffectOperation,\n\ttype UnwrappedDefaultError,\n\ttype UnwrappedDefaultRequirements,\n\ttype ValidatedEffectOperations,\n} from './operation'\n\ntype Supported<Value> = Value | PromiseLike<Value> | Effect.Effect<Value, unknown, unknown>\n// Heterogeneous storage constraints preserve concrete callbacks in inferred definitions.\n// oxlint-disable-next-line anti-slop/no-unknown-returns -- Internal callback storage; selected definitions retain concrete return contracts.\ntype Callback = (...arguments_: never[]) => Supported<unknown>\n// oxlint-disable-next-line anti-slop/no-unknown-returns -- Resolver constraint captures its concrete return in Resolve; it never exposes this storage type at exec.\ntype Resolver = (host: never) => Supported<unknown>\ntype HostOf<Resolve extends Resolver> = Parameters<Resolve>[0]\ntype DomainOf<Resolve extends Resolver> = EffectValue<ReturnType<Resolve>>\ntype Operation = {\n\tinput: ContractSchema\n\tresult: ContractSchema\n\tclassification: string\n\thandler: Callback\n\taudit: Callback\n\tguard?: Callback\n\tprepare?: Callback\n\tmiddleware?: Callback\n\tpermission?: string\n\taggregates?: readonly string[]\n\treplayResult?: ContractSchema\n}\ntype Registry<Context> = Readonly<\n\tRecord<\n\t\tstring,\n\t\tPick<Operation, 'input' | 'result' | 'classification' | 'handler' | 'audit'> &\n\t\t\tCheckedEffectOperation<Context>\n\t>\n>\nexport type EffectCommandDependencies = {\n\tobservability: Observability\n\tcheckPermission?: (\n\t\thost: never,\n\t\tinput: { permission: string; operation: string },\n\t) => Supported<void>\n\t// oxlint-disable-next-line anti-slop/no-unknown-returns -- Audit writer storage; its concrete return/error/services remain in Dependencies.\n\twriteAudit: (host: never, entry: AuditEntryInput) => Supported<unknown>\n}\ntype HostParameter<Policy> = [Exclude<Policy, undefined>] extends [never]\n\t? unknown\n\t: // oxlint-disable-next-line anti-slop/no-unknown-returns -- Conditional parameter-extraction predicate, not an executable callback contract.\n\t\tExclude<Policy, undefined> extends (...arguments_: infer Arguments) => Supported<unknown>\n\t\t? Arguments extends []\n\t\t\t? unknown\n\t\t\t: Arguments[0]\n\t\t: unknown\ntype PolicyHost<Dependencies extends EffectCommandDependencies> = HostParameter<\n\tDependencies['writeAudit']\n> &\n\tHostParameter<Dependencies['checkPermission']>\ntype HostCompatible<Resolve extends Resolver, Dependencies extends EffectCommandDependencies> = [\n\tHostOf<Resolve>,\n] extends [PolicyHost<Dependencies>]\n\t? unknown\n\t: { context: never }\ntype Factory<Resolve extends Resolver, Guard> = ReturnType<\n\ttypeof effectOperationFactory<\n\t\tDomainOf<Resolve>,\n\t\tRecord<never, never>,\n\t\tNoInfer<CallbackError<Guard>>,\n\t\tNoInfer<CallbackRequirements<Guard>>\n\t>\n>\nexport type EffectCommandConfiguration<\n\tResolve extends Resolver,\n\tOperations extends Registry<DomainOf<Resolve>>,\n\tGuard,\n> = {\n\tcontext: Resolve\n\toperations: (\n\t\tdefine: Factory<Resolve, Guard>,\n\t) => Operations & NoInfer<ValidatedEffectOperations<Operations>>\n\tdefaults?: { guard?: (context: DomainOf<Resolve>) => Guard }\n}\ntype ErrorOf<Definition, Resolve, Dependencies, Guard> =\n\t| EffectOperationError<Definition>\n\t| CallbackError<Resolve | Dependencies[keyof Dependencies]>\n\t| UnwrappedDefaultError<Definition, Guard>\ntype RequirementsOf<Definition, Resolve, Dependencies, Guard> =\n\t| EffectOperationRequirements<Definition>\n\t| CallbackRequirements<Resolve | Dependencies[keyof Dependencies]>\n\t| UnwrappedDefaultRequirements<Definition, Guard>\ninterface EffectExecution extends ExecutionKind {\n\treadonly type: Effect.Effect<this['value'], unknown, unknown>\n}\nconst effectLifecycle: LifecycleAlgebra<EffectExecution> = {\n\tsucceed: Effect.succeed,\n\tsuspend: Effect.suspend,\n\tflatMap: Effect.flatMap,\n}\ntype RuntimeOperation<Context, Input, Raw, Result> = {\n\tinput: ContractSchema\n\tresult: ContractSchema\n\tclassification: string\n\tpermission?: string\n\taggregates?: readonly string[]\n\treplayResult?: ContractSchema\n\thandler: (input: Input, context: Context) => Supported<Raw>\n\tguard?: (context: Context, input: Input) => Supported<void>\n\tprepare?: (\n\t\tcontext: Context,\n\t\tinput: Input,\n\t) => Supported<EffectPreparation<Result, unknown, unknown>>\n\taudit: (\n\t\tresolution: { command: Input; result: Result },\n\t\tcontext: Context,\n\t) => Supported<Omit<AuditEntryInput, 'classification'> | null>\n\tmiddleware?: (input: {\n\t\toperation: string\n\t\tcommand: Input\n\t\tinput: Input\n\t\tcontext: Context\n\t\tnext: (options?: { context?: object }) => Effect.Effect<Raw, unknown, unknown>\n\t}) => Supported<Raw>\n}\n\n/** Internal registry constructor: the public Foundation binds host policies once. */\nexport function createEffectCommand<\n\tResolve extends Resolver,\n\tconst Operations extends Registry<DomainOf<Resolve>>,\n\tconst Dependencies extends EffectCommandDependencies,\n\tGuard = never,\n>(\n\tconfiguration: EffectCommandConfiguration<Resolve, Operations, Guard> &\n\t\tDependencies &\n\t\tHostCompatible<Resolve, Dependencies>,\n) {\n\tconst operations: Operations =\n\t\tconfiguration.operations(\n\t\t\teffectOperationFactory<\n\t\t\t\tDomainOf<Resolve>,\n\t\t\t\tRecord<never, never>,\n\t\t\t\tCallbackError<Guard>,\n\t\t\t\tCallbackRequirements<Guard>\n\t\t\t>(),\n\t\t)\n\tconst exec = <Key extends Extract<keyof Operations, string>>(\n\t\toperation: Key,\n\t\tinput: EffectOperationArgument<Operations[Key]>,\n\t\thost: HostOf<Resolve>,\n\t): Effect.Effect<\n\t\tEffectOperationResult<Operations[Key]>,\n\t\tErrorOf<Operations[Key], Resolve, Dependencies, Guard>,\n\t\tRequirementsOf<Operations[Key], Resolve, Dependencies, Guard>\n\t> => {\n\t\tconst execution = Effect.suspend(() => {\n\t\t\tif (!Object.prototype.hasOwnProperty.call(operations, operation))\n\t\t\t\tthrow Error('The selected command operation is not configured')\n\t\t\t// SAFETY: this helper checked selected callbacks against their parsed schemas and domain context.\n\t\t\tconst definition = operations[operation] as Operations[Key] &\n\t\t\t\tRuntimeOperation<\n\t\t\t\t\tDomainOf<Resolve>,\n\t\t\t\t\tEffectOperationInput<Operations[Key]>,\n\t\t\t\t\tEffectOperationHandlerResult<Operations[Key]>,\n\t\t\t\t\tEffectOperationResult<Operations[Key]>\n\t\t\t\t>\n\t\t\t// SAFETY: selected command input was parsed by its own paired schema.\n\t\t\treturn Effect.flatMap(decodeEffectContract(definition.input, input), (decoded) => {\n\t\t\t\t// SAFETY: the selected operation's decoder owns this concrete domain input.\n\t\t\t\tconst command = decoded as EffectOperationInput<Operations[Key]>\n\t\t\t\tconst observation = configuration.observability.start({\n\t\t\t\t\toperation,\n\t\t\t\t\tclassification: definition.classification,\n\t\t\t\t})\n\t\t\t\t// SAFETY: resolver identity owns its concrete invocation return and host parameter.\n\t\t\t\tconst resolve = configuration.context as (host: HostOf<Resolve>) => ReturnType<Resolve>\n\t\t\t\treturn normalizeEffect(() => resolve(host)).pipe(\n\t\t\t\t\tEffect.flatMap((context) => {\n\t\t\t\t\t\tconst lifecycle = executeCommandLifecycle<\n\t\t\t\t\t\t\tEffectExecution,\n\t\t\t\t\t\t\tDomainOf<Resolve>,\n\t\t\t\t\t\t\tEffectOperationInput<Operations[Key]>,\n\t\t\t\t\t\t\tEffectOperationHandlerResult<Operations[Key]>,\n\t\t\t\t\t\t\tEffectOperationResult<Operations[Key]>\n\t\t\t\t\t\t>(effectLifecycle, {\n\t\t\t\t\t\t\toperation,\n\t\t\t\t\t\t\tclassification: definition.classification,\n\t\t\t\t\t\t\tcontext,\n\t\t\t\t\t\t\tcommand,\n\t\t\t\t\t\t\tpermission:\n\t\t\t\t\t\t\t\tdefinition.permission === undefined\n\t\t\t\t\t\t\t\t\t? undefined\n\t\t\t\t\t\t\t\t\t: () =>\n\t\t\t\t\t\t\t\t\t\t\tnormalizeEffect(() => {\n\t\t\t\t\t\t\t\t\t\t\t\tif (!configuration.checkPermission)\n\t\t\t\t\t\t\t\t\t\t\t\t\tthrow new CommandPermissionError(operation)\n\t\t\t\t\t\t\t\t\t\t\t\t// SAFETY: HostCompatible proves this invocation satisfies the configured policy host.\n\t\t\t\t\t\t\t\t\t\t\t\treturn configuration.checkPermission(host as never, {\n\t\t\t\t\t\t\t\t\t\t\t\t\tpermission: definition.permission!,\n\t\t\t\t\t\t\t\t\t\t\t\t\toperation,\n\t\t\t\t\t\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t\t\t\t\t}).pipe(Effect.asVoid),\n\t\t\t\t\t\t\tprepare: () =>\n\t\t\t\t\t\t\t\tnormalizeEffect(() => definition.prepare?.(context, command)).pipe(\n\t\t\t\t\t\t\t\t\tEffect.map((preparation) => {\n\t\t\t\t\t\t\t\t\t\tif (preparation?.kind !== 'execute') return preparation\n\t\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\tkind: 'execute',\n\t\t\t\t\t\t\t\t\t\t\tcomplete: preparation.complete\n\t\t\t\t\t\t\t\t\t\t\t\t? (result) =>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tnormalizeEffect(() => preparation.complete!(result)).pipe(\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tEffect.asVoid,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t\t\t\t\t\t: undefined,\n\t\t\t\t\t\t\t\t\t\t} satisfies LifecyclePreparation<\n\t\t\t\t\t\t\t\t\t\t\tEffectExecution,\n\t\t\t\t\t\t\t\t\t\t\tEffectOperationResult<Operations[Key]>\n\t\t\t\t\t\t\t\t\t\t>\n\t\t\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t// SAFETY: the selected final replay contract owns this result; operation types retain its E/R.\n\t\t\t\t\t\t\tdecodeReplay: (value) =>\n\t\t\t\t\t\t\t\tdecodeEffectContract(\n\t\t\t\t\t\t\t\t\tdefinition.replayResult ?? definition.result,\n\t\t\t\t\t\t\t\t\tvalue,\n\t\t\t\t\t\t\t\t) as Effect.Effect<EffectOperationResult<Operations[Key]>, unknown, unknown>,\n\t\t\t\t\t\t\tmiddleware: definition.middleware\n\t\t\t\t\t\t\t\t? [\n\t\t\t\t\t\t\t\t\t\t(input_) =>\n\t\t\t\t\t\t\t\t\t\t\tnormalizeCommandResult(() =>\n\t\t\t\t\t\t\t\t\t\t\t\tdefinition.middleware!({ ...input_, input: command }),\n\t\t\t\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t\t\t]\n\t\t\t\t\t\t\t\t: [],\n\t\t\t\t\t\t\tdefaultGuard: (enriched) =>\n\t\t\t\t\t\t\t\tnormalizeEffect(() => configuration.defaults?.guard?.(enriched)).pipe(\n\t\t\t\t\t\t\t\t\tEffect.asVoid,\n\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\tguard: (enriched) =>\n\t\t\t\t\t\t\t\tnormalizeEffect(() => definition.guard?.(enriched, command)).pipe(Effect.asVoid),\n\t\t\t\t\t\t\trun: (enriched) =>\n\t\t\t\t\t\t\t\tnormalizeCommandResult(() => definition.handler(command, enriched)),\n\t\t\t\t\t\t\t// SAFETY: the selected contract owns the decoded result; the public operation retains decoder E/R.\n\t\t\t\t\t\t\tdecodeResult: (value) =>\n\t\t\t\t\t\t\t\tdecodeEffectContract(definition.result, value) as Effect.Effect<\n\t\t\t\t\t\t\t\t\tEffectOperationResult<Operations[Key]>,\n\t\t\t\t\t\t\t\t\tunknown,\n\t\t\t\t\t\t\t\t\tunknown\n\t\t\t\t\t\t\t\t>,\n\t\t\t\t\t\t\taudit: (result) =>\n\t\t\t\t\t\t\t\tnormalizeEffect(() => definition.audit({ command, result }, context)),\n\t\t\t\t\t\t\twriteAudit: (entry) =>\n\t\t\t\t\t\t\t\tnormalizeEffect(() => {\n\t\t\t\t\t\t\t\t\t// SAFETY: HostCompatible proves this invocation satisfies the configured writer host.\n\t\t\t\t\t\t\t\t\treturn configuration.writeAudit(host as never, entry)\n\t\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\taggregates: definition.aggregates,\n\t\t\t\t\t\t})\n\t\t\t\t\t\treturn lifecycle\n\t\t\t\t\t}),\n\t\t\t\t\tEffect.onExit((exit) =>\n\t\t\t\t\t\tEffect.sync(() => {\n\t\t\t\t\t\t\tif (Exit.isSuccess(exit)) observation.completed()\n\t\t\t\t\t\t\telse observation.failed(observationFailure(exit.cause))\n\t\t\t\t\t\t}),\n\t\t\t\t\t),\n\t\t\t\t)\n\t\t\t})\n\t\t})\n\t\t// SAFETY: dispatch selects exactly this operation; callbacks preserve the concrete definition/policy E/R.\n\t\treturn execution as Effect.Effect<\n\t\t\tEffectOperationResult<Operations[Key]>,\n\t\t\tErrorOf<Operations[Key], Resolve, Dependencies, Guard>,\n\t\t\tRequirementsOf<Operations[Key], Resolve, Dependencies, Guard>\n\t\t>\n\t}\n\treturn {\n\t\t/** Bind invocation context without resolving it or running an operation. */\n\t\twithContext(context: HostOf<Resolve>) {\n\t\t\treturn {\n\t\t\t\texec: <Key extends Extract<keyof Operations, string>>(\n\t\t\t\t\toperation: Key,\n\t\t\t\t\tinput: EffectOperationArgument<Operations[Key]>,\n\t\t\t\t) => exec(operation, input, context),\n\t\t\t}\n\t\t},\n\t\texpose<const Owner extends symbol, const Key extends Extract<keyof Operations, string>>(\n\t\t\towner: Owner,\n\t\t\toperation: Key,\n\t\t): SelectedOperation<\n\t\t\tOwner,\n\t\t\tKey,\n\t\t\tOperations[Key]['input'],\n\t\t\tOperationPublicResult<Operations[Key]>\n\t\t> {\n\t\t\tif (!Object.hasOwn(operations, operation))\n\t\t\t\tthrow Error('The selected command operation is not configured')\n\t\t\treturn selectOperation(owner, 'mutation', operation, operations[operation])\n\t\t},\n\t\texec,\n\t}\n}\n\n/** Bind trusted application policies without exposing a loose public command kernel. */\nexport function bindEffectCommand<const Dependencies extends EffectCommandDependencies>(\n\tdependencies: Dependencies,\n) {\n\treturn function command<\n\t\tResolve extends Resolver,\n\t\tconst Operations extends Registry<DomainOf<Resolve>>,\n\t\tGuard = never,\n\t>(\n\t\tconfiguration: EffectCommandConfiguration<Resolve, Operations, Guard> &\n\t\t\tHostCompatible<Resolve, Dependencies>,\n\t): ReturnType<typeof createEffectCommand<Resolve, Operations, Dependencies, Guard>> {\n\t\treturn createEffectCommand<Resolve, Operations, Dependencies, Guard>({\n\t\t\t...configuration,\n\t\t\t...dependencies,\n\t\t})\n\t}\n}\n\nfunction normalizeCommandResult<Value>(\n\tinvoke: () => Supported<Value>,\n): Effect.Effect<Value, unknown, unknown> {\n\t// SAFETY: selected definition helper checks the callback's normalized success against the schema input.\n\treturn normalizeEffect(invoke) as Effect.Effect<Value, unknown, unknown>\n}\n"],"mappings":"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"}
+{"version":3,"file":"command.mjs","names":["effectLifecycle","Effect","createEffectCommand","operations","configuration","effectOperationFactory","exec","operation","definition","decodeEffectContract","input","command","decoded","observation","resolve","normalizeEffect","host","executeCommandLifecycle","CommandPermissionError","context","preparation","result","value","normalizeCommandResult","input_","enriched","entry","Exit","exit","observationFailure","selectOperation","owner","bindEffectCommand","definitions","domainEffectFactory","snapshotOperations","dependencies","invoke"],"sources":["../../../src/modules/effect/command.ts"],"sourcesContent":["/* oxlint-disable anti-slop/no-unknown-returns, anti-slop/no-unsafe-dictionary-type -- Overload implementation storage is erased; public signatures retain concrete values, errors and services. */\nimport { Effect, Exit } from 'effect'\nimport type { AuditEntryInput } from '../../components/foundation/client'\nimport type { ContractSchema } from '../contracts/contract'\nimport {\n\tselectOperation,\n\ttype SelectedOperation,\n\ttype OperationPublicResult,\n} from '../contracts/exposure'\nimport { decodeEffectContract } from './schema'\n// oxlint-disable-next-line cvx/component-boundaries -- SAFETY: Internal optional adapter shares the Effect-free Foundation lifecycle and types without entering the Convex component deployment graph.\nimport {\n\tCommandPermissionError,\n\texecuteCommandLifecycle,\n\ttype ExecutionKind,\n\ttype LifecycleAlgebra,\n\ttype LifecyclePreparation,\n} from '../../components/foundation/modules/command/lifecycle'\n// oxlint-disable-next-line cvx/component-boundaries -- SAFETY: Internal optional adapter shares the Effect-free Foundation lifecycle and types without entering the Convex component deployment graph.\nimport type { Observability } from '../../components/foundation/modules/observability/observability'\nimport { normalizeEffect, observationFailure } from './normalize'\nimport {\n\teffectOperationFactory,\n\ttype CallbackError,\n\ttype CallbackRequirements,\n\ttype EffectValue,\n\ttype EffectOperationArgument,\n\ttype EffectOperationInput,\n\ttype EffectOperationHandlerResult,\n\ttype EffectPreparation,\n\ttype EffectOperationResult,\n\ttype EffectOperationError,\n\ttype EffectOperationRequirements,\n\ttype CheckedEffectOperation,\n\ttype UnwrappedDefaultError,\n\ttype UnwrappedDefaultRequirements,\n\ttype ValidatedEffectOperations,\n} from './operation'\n\nimport type { DomainContract, DomainCommandContract, DomainAuditInput } from '../contracts/domain'\nimport { snapshotOperations, type BoundOperations } from '../contracts/binding'\nimport {\n\tdomainEffectFactory,\n\ttype DomainEffectFactory,\n\ttype DomainEffectImplementations,\n\ttype ExactDomainOperations,\n\ttype AuditedOperations,\n\ttype SharedEffectFactory,\n\ttype AuditValue,\n} from './domain'\n\ntype Supported<Value> = Value | PromiseLike<Value> | Effect.Effect<Value, unknown, unknown>\n// Heterogeneous storage constraints preserve concrete callbacks in inferred definitions.\n// oxlint-disable-next-line anti-slop/no-unknown-returns -- Internal callback storage; selected definitions retain concrete return contracts.\ntype Callback = (...arguments_: never[]) => Supported<unknown>\n// oxlint-disable-next-line anti-slop/no-unknown-returns -- Resolver constraint captures its concrete return in Resolve; it never exposes this storage type at exec.\ntype Resolver = (host: never) => Supported<unknown>\ntype HostOf<Resolve extends Resolver> = Parameters<Resolve>[0]\ntype DomainOf<Resolve extends Resolver> = EffectValue<ReturnType<Resolve>>\ntype Operation = {\n\tinput: ContractSchema\n\tresult: ContractSchema\n\tclassification: string\n\thandler: Callback\n\taudit: Callback\n\tguard?: Callback\n\tprepare?: Callback\n\tmiddleware?: Callback\n\tpermission?: string\n\taggregates?: readonly string[]\n\treplayResult?: ContractSchema\n}\ntype Registry<Context> = Readonly<\n\tRecord<\n\t\tstring,\n\t\tPick<Operation, 'input' | 'result' | 'classification' | 'handler' | 'audit'> &\n\t\t\tCheckedEffectOperation<Context>\n\t>\n>\nexport type EffectCommandDependencies = {\n\tobservability: Observability\n\tcheckPermission?: (\n\t\thost: never,\n\t\tinput: { permission: string; operation: string },\n\t) => Supported<void>\n\t// oxlint-disable-next-line anti-slop/no-unknown-returns -- Audit writer storage; its concrete return/error/services remain in Dependencies.\n\twriteAudit: (host: never, entry: AuditEntryInput) => Supported<unknown>\n}\ntype HostParameter<Policy> = [Exclude<Policy, undefined>] extends [never]\n\t? unknown\n\t: // oxlint-disable-next-line anti-slop/no-unknown-returns -- Conditional parameter-extraction predicate, not an executable callback contract.\n\t\tExclude<Policy, undefined> extends (...arguments_: infer Arguments) => Supported<unknown>\n\t\t? Arguments extends []\n\t\t\t? unknown\n\t\t\t: Arguments[0]\n\t\t: unknown\ntype PolicyHost<Dependencies extends EffectCommandDependencies> = HostParameter<\n\tDependencies['writeAudit']\n> &\n\tHostParameter<Dependencies['checkPermission']>\ntype HostCompatible<Resolve extends Resolver, Dependencies extends EffectCommandDependencies> = [\n\tHostOf<Resolve>,\n] extends [PolicyHost<Dependencies>]\n\t? unknown\n\t: { context: never }\ntype Factory<Resolve extends Resolver, Guard> = ReturnType<\n\ttypeof effectOperationFactory<\n\t\tDomainOf<Resolve>,\n\t\tRecord<never, never>,\n\t\tNoInfer<CallbackError<Guard>>,\n\t\tNoInfer<CallbackRequirements<Guard>>\n\t>\n>\nexport type EffectCommandConfiguration<\n\tResolve extends Resolver,\n\tOperations extends Registry<DomainOf<Resolve>>,\n\tGuard,\n> = {\n\tcontext: Resolve\n\toperations: (\n\t\tdefine: Factory<Resolve, Guard>,\n\t) => Operations & NoInfer<ValidatedEffectOperations<Operations>>\n\tdefaults?: { guard?: (context: DomainOf<Resolve>) => Guard }\n}\ntype ErrorOf<Definition, Resolve, Dependencies, Guard> =\n\t| EffectOperationError<Definition>\n\t| CallbackError<Resolve | Dependencies[keyof Dependencies]>\n\t| UnwrappedDefaultError<Definition, Guard>\ntype RequirementsOf<Definition, Resolve, Dependencies, Guard> =\n\t| EffectOperationRequirements<Definition>\n\t| CallbackRequirements<Resolve | Dependencies[keyof Dependencies]>\n\t| UnwrappedDefaultRequirements<Definition, Guard>\ninterface EffectExecution extends ExecutionKind {\n\treadonly type: Effect.Effect<this['value'], unknown, unknown>\n}\nconst effectLifecycle: LifecycleAlgebra<EffectExecution> = {\n\tsucceed: Effect.succeed,\n\tsuspend: Effect.suspend,\n\tflatMap: Effect.flatMap,\n}\ntype RuntimeOperation<Context, Input, Raw, Result> = {\n\tinput: ContractSchema\n\tresult: ContractSchema\n\tclassification: string\n\tpermission?: string\n\taggregates?: readonly string[]\n\treplayResult?: ContractSchema\n\thandler: (input: Input, context: Context) => Supported<Raw>\n\tguard?: (context: Context, input: Input) => Supported<void>\n\tprepare?: (\n\t\tcontext: Context,\n\t\tinput: Input,\n\t) => Supported<EffectPreparation<Result, unknown, unknown>>\n\taudit: (\n\t\tresolution: { command: Input; result: Result },\n\t\tcontext: Context,\n\t) => Supported<Omit<AuditEntryInput, 'classification'> | null>\n\tmiddleware?: (input: {\n\t\toperation: string\n\t\tcommand: Input\n\t\tinput: Input\n\t\tcontext: Context\n\t\tnext: (options?: { context?: object }) => Effect.Effect<Raw, unknown, unknown>\n\t}) => Supported<Raw>\n}\n\n/** Internal registry constructor: the public Foundation binds host policies once. */\nexport function createEffectCommand<\n\tResolve extends Resolver,\n\tconst Operations extends Registry<DomainOf<Resolve>>,\n\tconst Dependencies extends EffectCommandDependencies,\n\tGuard = never,\n>(\n\tconfiguration: EffectCommandConfiguration<Resolve, Operations, Guard> &\n\t\tDependencies &\n\t\tHostCompatible<Resolve, Dependencies>,\n) {\n\tconst operations: Operations =\n\t\tconfiguration.operations(\n\t\t\teffectOperationFactory<\n\t\t\t\tDomainOf<Resolve>,\n\t\t\t\tRecord<never, never>,\n\t\t\t\tCallbackError<Guard>,\n\t\t\t\tCallbackRequirements<Guard>\n\t\t\t>(),\n\t\t)\n\tconst exec = <Key extends Extract<keyof Operations, string>>(\n\t\toperation: Key,\n\t\tinput: EffectOperationArgument<Operations[Key]>,\n\t\thost: HostOf<Resolve>,\n\t): Effect.Effect<\n\t\tEffectOperationResult<Operations[Key]>,\n\t\tErrorOf<Operations[Key], Resolve, Dependencies, Guard>,\n\t\tRequirementsOf<Operations[Key], Resolve, Dependencies, Guard>\n\t> => {\n\t\tconst execution = Effect.suspend(() => {\n\t\t\tif (!Object.prototype.hasOwnProperty.call(operations, operation))\n\t\t\t\tthrow Error('The selected command operation is not configured')\n\t\t\t// SAFETY: this helper checked selected callbacks against their parsed schemas and domain context.\n\t\t\tconst definition = operations[operation] as Operations[Key] &\n\t\t\t\tRuntimeOperation<\n\t\t\t\t\tDomainOf<Resolve>,\n\t\t\t\t\tEffectOperationInput<Operations[Key]>,\n\t\t\t\t\tEffectOperationHandlerResult<Operations[Key]>,\n\t\t\t\t\tEffectOperationResult<Operations[Key]>\n\t\t\t\t>\n\t\t\t// SAFETY: selected command input was parsed by its own paired schema.\n\t\t\treturn Effect.flatMap(decodeEffectContract(definition.input, input), (decoded) => {\n\t\t\t\t// SAFETY: the selected operation's decoder owns this concrete domain input.\n\t\t\t\tconst command = decoded as EffectOperationInput<Operations[Key]>\n\t\t\t\tconst observation = configuration.observability.start({\n\t\t\t\t\toperation,\n\t\t\t\t\tclassification: definition.classification,\n\t\t\t\t})\n\t\t\t\t// SAFETY: resolver identity owns its concrete invocation return and host parameter.\n\t\t\t\tconst resolve = configuration.context as (host: HostOf<Resolve>) => ReturnType<Resolve>\n\t\t\t\treturn normalizeEffect(() => resolve(host)).pipe(\n\t\t\t\t\tEffect.flatMap((context) => {\n\t\t\t\t\t\tconst lifecycle = executeCommandLifecycle<\n\t\t\t\t\t\t\tEffectExecution,\n\t\t\t\t\t\t\tDomainOf<Resolve>,\n\t\t\t\t\t\t\tEffectOperationInput<Operations[Key]>,\n\t\t\t\t\t\t\tEffectOperationHandlerResult<Operations[Key]>,\n\t\t\t\t\t\t\tEffectOperationResult<Operations[Key]>\n\t\t\t\t\t\t>(effectLifecycle, {\n\t\t\t\t\t\t\toperation,\n\t\t\t\t\t\t\tclassification: definition.classification,\n\t\t\t\t\t\t\tcontext,\n\t\t\t\t\t\t\tcommand,\n\t\t\t\t\t\t\tpermission:\n\t\t\t\t\t\t\t\tdefinition.permission === undefined\n\t\t\t\t\t\t\t\t\t? undefined\n\t\t\t\t\t\t\t\t\t: () =>\n\t\t\t\t\t\t\t\t\t\t\tnormalizeEffect(() => {\n\t\t\t\t\t\t\t\t\t\t\t\tif (!configuration.checkPermission)\n\t\t\t\t\t\t\t\t\t\t\t\t\tthrow new CommandPermissionError(operation)\n\t\t\t\t\t\t\t\t\t\t\t\t// SAFETY: HostCompatible proves this invocation satisfies the configured policy host.\n\t\t\t\t\t\t\t\t\t\t\t\treturn configuration.checkPermission(host as never, {\n\t\t\t\t\t\t\t\t\t\t\t\t\tpermission: definition.permission!,\n\t\t\t\t\t\t\t\t\t\t\t\t\toperation,\n\t\t\t\t\t\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t\t\t\t\t}).pipe(Effect.asVoid),\n\t\t\t\t\t\t\tprepare: () =>\n\t\t\t\t\t\t\t\tnormalizeEffect(() => definition.prepare?.(context, command)).pipe(\n\t\t\t\t\t\t\t\t\tEffect.map((preparation) => {\n\t\t\t\t\t\t\t\t\t\tif (preparation?.kind !== 'execute') return preparation\n\t\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\tkind: 'execute',\n\t\t\t\t\t\t\t\t\t\t\tcomplete: preparation.complete\n\t\t\t\t\t\t\t\t\t\t\t\t? (result) =>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tnormalizeEffect(() => preparation.complete!(result)).pipe(Effect.asVoid)\n\t\t\t\t\t\t\t\t\t\t\t\t: undefined,\n\t\t\t\t\t\t\t\t\t\t} satisfies LifecyclePreparation<\n\t\t\t\t\t\t\t\t\t\t\tEffectExecution,\n\t\t\t\t\t\t\t\t\t\t\tEffectOperationResult<Operations[Key]>\n\t\t\t\t\t\t\t\t\t\t>\n\t\t\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t// SAFETY: the selected final replay contract owns this result; operation types retain its E/R.\n\t\t\t\t\t\t\tdecodeReplay: (value) =>\n\t\t\t\t\t\t\t\tdecodeEffectContract(\n\t\t\t\t\t\t\t\t\tdefinition.replayResult ?? definition.result,\n\t\t\t\t\t\t\t\t\tvalue,\n\t\t\t\t\t\t\t\t) as Effect.Effect<EffectOperationResult<Operations[Key]>, unknown, unknown>,\n\t\t\t\t\t\t\tmiddleware: definition.middleware\n\t\t\t\t\t\t\t\t? [\n\t\t\t\t\t\t\t\t\t\t(input_) =>\n\t\t\t\t\t\t\t\t\t\t\tnormalizeCommandResult(() =>\n\t\t\t\t\t\t\t\t\t\t\t\tdefinition.middleware!({ ...input_, input: command }),\n\t\t\t\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t\t\t]\n\t\t\t\t\t\t\t\t: [],\n\t\t\t\t\t\t\tdefaultGuard: (enriched) =>\n\t\t\t\t\t\t\t\tnormalizeEffect(() => configuration.defaults?.guard?.(enriched)).pipe(\n\t\t\t\t\t\t\t\t\tEffect.asVoid,\n\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\tguard: (enriched) =>\n\t\t\t\t\t\t\t\tnormalizeEffect(() => definition.guard?.(enriched, command)).pipe(Effect.asVoid),\n\t\t\t\t\t\t\trun: (enriched) =>\n\t\t\t\t\t\t\t\tnormalizeCommandResult(() => definition.handler(command, enriched)),\n\t\t\t\t\t\t\t// SAFETY: the selected contract owns the decoded result; the public operation retains decoder E/R.\n\t\t\t\t\t\t\tdecodeResult: (value) =>\n\t\t\t\t\t\t\t\tdecodeEffectContract(definition.result, value) as Effect.Effect<\n\t\t\t\t\t\t\t\t\tEffectOperationResult<Operations[Key]>,\n\t\t\t\t\t\t\t\t\tunknown,\n\t\t\t\t\t\t\t\t\tunknown\n\t\t\t\t\t\t\t\t>,\n\t\t\t\t\t\t\taudit: (result) =>\n\t\t\t\t\t\t\t\tnormalizeEffect(() => definition.audit({ command, result }, context)),\n\t\t\t\t\t\t\twriteAudit: (entry) =>\n\t\t\t\t\t\t\t\tnormalizeEffect(() => {\n\t\t\t\t\t\t\t\t\t// SAFETY: HostCompatible proves this invocation satisfies the configured writer host.\n\t\t\t\t\t\t\t\t\treturn configuration.writeAudit(host as never, entry)\n\t\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\taggregates: definition.aggregates,\n\t\t\t\t\t\t})\n\t\t\t\t\t\treturn lifecycle\n\t\t\t\t\t}),\n\t\t\t\t\tEffect.onExit((exit) =>\n\t\t\t\t\t\tEffect.sync(() => {\n\t\t\t\t\t\t\tif (Exit.isSuccess(exit)) observation.completed()\n\t\t\t\t\t\t\telse observation.failed(observationFailure(exit.cause))\n\t\t\t\t\t\t}),\n\t\t\t\t\t),\n\t\t\t\t)\n\t\t\t})\n\t\t})\n\t\t// SAFETY: dispatch selects exactly this operation; callbacks preserve the concrete definition/policy E/R.\n\t\treturn execution as Effect.Effect<\n\t\t\tEffectOperationResult<Operations[Key]>,\n\t\t\tErrorOf<Operations[Key], Resolve, Dependencies, Guard>,\n\t\t\tRequirementsOf<Operations[Key], Resolve, Dependencies, Guard>\n\t\t>\n\t}\n\treturn {\n\t\t/** Bind invocation context without resolving it or running an operation. */\n\t\twithContext(context: HostOf<Resolve>) {\n\t\t\treturn {\n\t\t\t\texec: <Key extends Extract<keyof Operations, string>>(\n\t\t\t\t\toperation: Key,\n\t\t\t\t\tinput: EffectOperationArgument<Operations[Key]>,\n\t\t\t\t) => exec(operation, input, context),\n\t\t\t}\n\t\t},\n\t\texpose<const Owner extends symbol, const Key extends Extract<keyof Operations, string>>(\n\t\t\towner: Owner,\n\t\t\toperation: Key,\n\t\t): SelectedOperation<\n\t\t\tOwner,\n\t\t\tKey,\n\t\t\tOperations[Key]['input'],\n\t\t\tOperationPublicResult<Operations[Key]>\n\t\t> {\n\t\t\tif (!Object.hasOwn(operations, operation))\n\t\t\t\tthrow Error('The selected command operation is not configured')\n\t\t\treturn selectOperation(owner, 'mutation', operation, operations[operation])\n\t\t},\n\t\texec,\n\t}\n}\n\n/** Bind trusted application policies without exposing a loose public command kernel. */\nexport function bindEffectCommand<const Dependencies extends EffectCommandDependencies>(\n\tdependencies: Dependencies,\n) {\n\ttype LooseRegistry<Context> = Readonly<\n\t\tRecord<\n\t\t\tstring,\n\t\t\tPick<Operation, 'input' | 'result' | 'classification' | 'handler'> &\n\t\t\t\tCheckedEffectOperation<Context>\n\t\t>\n\t>\n\n\tfunction command<\n\t\tResolve extends Resolver,\n\t\tconst Contract extends DomainContract & {\n\t\t\tcommands: Readonly<Record<string, DomainCommandContract>>\n\t\t},\n\t\tconst Operations extends DomainEffectImplementations<\n\t\t\tDomainOf<Resolve>,\n\t\t\tContract['commands'],\n\t\t\ttrue\n\t\t>,\n\t\tMode extends true,\n\t\tGuard = never,\n\t>(\n\t\tconfiguration: {\n\t\t\tcontract: Contract &\n\t\t\t\tNoInfer<\n\t\t\t\t\tOperations extends ExactDomainOperations<Operations, Contract['commands']> &\n\t\t\t\t\t\tValidatedEffectOperations<Operations>\n\t\t\t\t\t\t? unknown\n\t\t\t\t\t\t: never\n\t\t\t\t>\n\t\t\tcontext: Resolve\n\t\t\taudit?: never\n\t\t\toperations: (\n\t\t\t\tdefine: DomainEffectFactory<\n\t\t\t\t\tDomainOf<Resolve>,\n\t\t\t\t\tContract['commands'],\n\t\t\t\t\tMode,\n\t\t\t\t\tnever,\n\t\t\t\t\tNoInfer<CallbackError<Guard>>,\n\t\t\t\t\tNoInfer<CallbackRequirements<Guard>>\n\t\t\t\t>,\n\t\t\t) => Operations\n\t\t\tdefaults?: { guard?: (context: DomainOf<Resolve>) => Guard }\n\t\t} & HostCompatible<Resolve, Dependencies>,\n\t): ReturnType<\n\t\ttypeof createEffectCommand<\n\t\t\tResolve,\n\t\t\tBoundOperations<Operations, Contract['commands']> & {\n\t\t\t\t[Key in keyof Contract['commands']]: {\n\t\t\t\t\tclassification: Contract['commands'][Key]['classification']\n\t\t\t\t\taudit: Operations[Key]['audit']\n\t\t\t\t}\n\t\t\t},\n\t\t\tDependencies,\n\t\t\tGuard\n\t\t>\n\t>\n\tfunction command<\n\t\tResolve extends Resolver,\n\t\tconst Contract extends DomainContract & {\n\t\t\tcommands: Readonly<Record<string, DomainCommandContract>>\n\t\t},\n\t\tconst Operations extends DomainEffectImplementations<DomainOf<Resolve>, Contract['commands']>,\n\t\tReturned extends AuditValue,\n\t\tGuard = never,\n\t>(\n\t\tconfiguration: {\n\t\t\tcontract: Contract &\n\t\t\t\tNoInfer<\n\t\t\t\t\tOperations extends ExactDomainOperations<Operations, Contract['commands']> &\n\t\t\t\t\t\tValidatedEffectOperations<Operations>\n\t\t\t\t\t\t? unknown\n\t\t\t\t\t\t: never\n\t\t\t\t>\n\t\t\tcontext: Resolve\n\t\t\taudit: (\n\t\t\t\tresolution: DomainAuditInput<Contract['commands']>,\n\t\t\t\tcontext: DomainOf<Resolve>,\n\t\t\t) => Returned\n\t\t\toperations: (\n\t\t\t\tdefine: DomainEffectFactory<\n\t\t\t\t\tDomainOf<Resolve>,\n\t\t\t\t\tContract['commands'],\n\t\t\t\t\ttrue,\n\t\t\t\t\t[Returned] extends [never] ? never : (resolution: never, context: never) => Returned,\n\t\t\t\t\tNoInfer<CallbackError<Guard>>,\n\t\t\t\t\tNoInfer<CallbackRequirements<Guard>>\n\t\t\t\t>,\n\t\t\t) => Operations\n\t\t\tdefaults?: { guard?: (context: DomainOf<Resolve>) => Guard }\n\t\t} & HostCompatible<Resolve, Dependencies>,\n\t): ReturnType<\n\t\ttypeof createEffectCommand<\n\t\t\tResolve,\n\t\t\tAuditedOperations<\n\t\t\t\tBoundOperations<Operations, Contract['commands']>,\n\t\t\t\t(resolution: never, context: never) => Returned\n\t\t\t>,\n\t\t\tDependencies,\n\t\t\tGuard\n\t\t>\n\t>\n\tfunction command<\n\t\tResolve extends Resolver,\n\t\tconst Operations extends LooseRegistry<DomainOf<Resolve>>,\n\t\tReturned extends AuditValue,\n\t\tGuard,\n\t>(\n\t\tconfiguration: {\n\t\t\tcontext: Resolve\n\t\t\taudit: (resolution: DomainAuditInput<Operations>, context: DomainOf<Resolve>) => Returned\n\t\t\toperations: (\n\t\t\t\tdefine: SharedEffectFactory<DomainOf<Resolve>, Guard>,\n\t\t\t) => Operations & NoInfer<ValidatedEffectOperations<Operations>>\n\t\t\tdefaults?: { guard?: (context: DomainOf<Resolve>) => Guard }\n\t\t} & HostCompatible<Resolve, Dependencies>,\n\t): ReturnType<\n\t\ttypeof createEffectCommand<\n\t\t\tResolve,\n\t\t\tAuditedOperations<Operations, (resolution: never, context: never) => Returned>,\n\t\t\tDependencies,\n\t\t\tGuard\n\t\t>\n\t>\n\n\tfunction command<\n\t\tResolve extends Resolver,\n\t\tconst Operations extends Registry<DomainOf<Resolve>>,\n\t\tGuard = never,\n\t>(\n\t\tconfiguration: EffectCommandConfiguration<Resolve, Operations, Guard> &\n\t\t\tHostCompatible<Resolve, Dependencies>,\n\t): ReturnType<typeof createEffectCommand<Resolve, Operations, Dependencies, Guard>>\n\tfunction command(configuration: {\n\t\tcontext: Resolver\n\t\tcontract?: DomainContract\n\t\taudit?: (resolution: never, context: never) => AuditValue\n\t\toperations: (define: never) => Readonly<Record<string, object>>\n\t\tdefaults?: { guard?: (context: never) => unknown }\n\t}): unknown {\n\t\tconst definitions = configuration.contract\n\t\t\t? domainEffectFactory(configuration.contract.commands ?? {}, true)\n\t\t\t: effectOperationFactory()\n\t\tconst operations = snapshotOperations(\n\t\t\tconfiguration.operations(\n\t\t\t\t// SAFETY: the overload chooses this exact inline or contracted helper factory.\n\t\t\t\tdefinitions as never,\n\t\t\t),\n\t\t\tconfiguration.contract,\n\t\t\t'commands',\n\t\t\tconfiguration.audit,\n\t\t)\n\t\t// SAFETY: overloads check callbacks and schemas; binding validates exact keys and snapshots runtime records.\n\t\treturn createEffectCommand({\n\t\t\t...configuration,\n\t\t\t...dependencies,\n\t\t\toperations: () => operations,\n\t\t} as never)\n\t}\n\treturn command\n}\n\nfunction normalizeCommandResult<Value>(\n\tinvoke: () => Supported<Value>,\n): Effect.Effect<Value, unknown, unknown> {\n\t// SAFETY: selected definition helper checks the callback's normalized success against the schema input.\n\treturn normalizeEffect(invoke) as Effect.Effect<Value, unknown, unknown>\n}\n"],"mappings":"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"}

package/dist/modules/effect/crud.d.mts

@@ -177,6 +177,7 @@ export declare function createEffectCrud<const Options extends EffectFoundationO
     }, [Effect.Effect<EffectValue<Insert>, CallbackError<Insert>, CallbackRequirements<Insert>> | Effect.Effect<Partial<z.core.input<Table["storage"]>> | undefined, CallbackError<Enrich>, CallbackRequirements<Enrich>> | Effect.Effect<Id<Table>, never, never>] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [Effect.Effect<EffectValue<Insert>, CallbackError<Insert>, CallbackRequirements<Insert>> | Effect.Effect<Partial<z.core.input<Table["storage"]>> | undefined, CallbackError<Enrich>, CallbackRequirements<Enrich>> | Effect.Effect<Id<Table>, never, never>] extends [Effect.Effect<infer _A_1, infer _E, infer R>] ? R : never>, RequiredOverride<Configuration, "create">>>>) => never) | undefined;
   } & {
     classification: string;
+  } & {
     audit: (resolution: {
       command: z.infer<Table["commandInput"]>;
       result: {
@@ -242,6 +243,7 @@ export declare function createEffectCrud<const Options extends EffectFoundationO
     }, CallbackError<Patch>, CallbackRequirements<Patch>>, RequiredOverride<Configuration, "update">>>>>) => never) | undefined;
   } & {
     classification: string;
+  } & {
     audit: (resolution: {
       command: z.infer<Table["tools"]["update"]>;
       result: {
@@ -307,6 +309,7 @@ export declare function createEffectCrud<const Options extends EffectFoundationO
     }, CallbackError<Patch>, CallbackRequirements<Patch>>, RequiredOverride<Configuration, "archive">>>>>) => never) | undefined;
   } & {
     classification: string;
+  } & {
     audit: (resolution: {
       command: z.infer<Table["tools"]["id"]>;
       result: {
@@ -499,6 +502,7 @@ export declare function createEffectCrud<const Options extends EffectFoundationO
     }, [Effect.Effect<EffectValue<Insert>, CallbackError<Insert>, CallbackRequirements<Insert>> | Effect.Effect<Partial<z.core.input<Table["storage"]>> | undefined, CallbackError<Enrich>, CallbackRequirements<Enrich>> | Effect.Effect<Id<Table>, never, never>] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [Effect.Effect<EffectValue<Insert>, CallbackError<Insert>, CallbackRequirements<Insert>> | Effect.Effect<Partial<z.core.input<Table["storage"]>> | undefined, CallbackError<Enrich>, CallbackRequirements<Enrich>> | Effect.Effect<Id<Table>, never, never>] extends [Effect.Effect<infer _A_1, infer _E, infer R>] ? R : never>, RequiredOverride<Configuration, "create">>>>) => never) | undefined;
   } & {
     classification: string;
+  } & {
     audit: (resolution: {
       command: z.infer<Table["commandInput"]>;
       result: {
@@ -564,6 +568,7 @@ export declare function createEffectCrud<const Options extends EffectFoundationO
     }, CallbackError<Patch>, CallbackRequirements<Patch>>, RequiredOverride<Configuration, "update">>>>>) => never) | undefined;
   } & {
     classification: string;
+  } & {
     audit: (resolution: {
       command: z.infer<Table["tools"]["update"]>;
       result: {
@@ -629,6 +634,7 @@ export declare function createEffectCrud<const Options extends EffectFoundationO
     }, CallbackError<Patch>, CallbackRequirements<Patch>>, RequiredOverride<Configuration, "archive">>>>>) => never) | undefined;
   } & {
     classification: string;
+  } & {
     audit: (resolution: {
       command: z.infer<Table["tools"]["id"]>;
       result: {

package/dist/modules/effect/domain.d.mts

@@ -0,0 +1,72 @@
+import { ContractInput, ContractOutput, ContractSchema } from "../contracts/contract.mjs";
+import { AuditEntryInput } from "../../components/foundation/client.mjs";
+import { DomainOperationContract, ExactOperationKeys } from "../contracts/domain.mjs";
+import { CallbackError, CallbackRequirements, CheckedEffectDefinition, CheckedEffectOperation, EffectPreparation, OperationDefinition, effectOperationFactory } from "./operation.mjs";
+import { DeclaredSchemas } from "../contracts/binding.mjs";
+import { Effect } from "effect";
+//#region src/modules/effect/domain.d.ts
+type Supported<A> = A | PromiseLike<A> | Effect.Effect<A, unknown, unknown>;
+type Audit = Omit<AuditEntryInput, 'classification'> | null;
+declare const domainKey: unique symbol;
+type BoundKey<Key> = {
+  readonly [domainKey]: Key;
+};
+type Schemas<Entry extends DomainOperationContract> = Pick<Entry, 'input' | 'result'> & Omit<Entry, 'input' | 'result'>;
+type Forbidden = {
+  input?: never;
+  result?: never;
+  classification?: never;
+  replayResult?: never;
+  wire?: never;
+};
+type AuditCallback<Context, Entry extends DomainOperationContract, Value> = (resolution: {
+  command: ContractOutput<Entry['input']>;
+  result: ContractOutput<Entry['result']>;
+}, context: Context) => Value;
+export type SelectedAudit<Definition, Default> = Definition extends {
+  audit: infer Override;
+} ? Override : 'audit' extends keyof Definition ? Exclude<Definition['audit' & keyof Definition], undefined> | Default : Default;
+export type AuditedOperations<Operations, Default> = { [Key in keyof Operations]: Omit<Operations[Key], 'audit'> & {
+  audit: SelectedAudit<Operations[Key], Default>;
+}; };
+export type ExactDomainOperations<Operations, Contracts> = ExactOperationKeys<Operations, Contracts> & { [Key in keyof Operations]: Operations[Key] extends BoundKey<Key> ? Operations[Key] : never; };
+type Helper<Context, Entry extends DomainOperationContract, Key, Command extends boolean, Default, BaseError, BaseRequirements> = <Handler extends Supported<ContractInput<Entry['result']>>, Guard extends Supported<void> = never, Preparation extends Supported<EffectPreparation<ContractOutput<Entry['result']>, unknown, unknown>> = never, const Aggregates extends readonly string[] = readonly string[], AuditReturned extends Supported<Audit> = never, Middleware extends Supported<ContractInput<Entry['result']>> = never, const Metadata extends object = Record<never, never>, const Definition extends object = object>(implementation: Definition & Forbidden & Omit<OperationDefinition<Context, Entry['input'], Entry['result'], Record<never, never>, Aggregates, Handler, Guard, Preparation, AuditReturned, Middleware, Metadata, BaseError, BaseRequirements, ContractSchema, never>, 'input' | 'result' | 'classification' | 'replayResult' | 'wire'> & (Command extends true ? [Default] extends [never] ? {
+  audit: AuditCallback<Context, Entry, AuditReturned>;
+} : {} : {
+  audit?: never;
+  prepare?: never;
+  aggregates?: never;
+})) => DeclaredSchemas<Entry> & CheckedEffectDefinition<Context, Schemas<Entry> & Definition & BoundKey<Key>, BaseError, BaseRequirements>;
+type HandlerArguments<Options, Command extends boolean, Default, RequiredAudit> = Command extends true ? [Default] extends [never] ? [options: Options & RequiredAudit] : [options?: Options] : [options?: Options];
+type HandlerHelper<Context, Entries extends Readonly<Record<string, DomainOperationContract>>, Command extends boolean, Default, BaseError, BaseRequirements> = <const Input extends ContractSchema, const Result extends ContractSchema, Key extends keyof Entries, Handler extends Supported<ContractInput<Result>>, Guard extends Supported<void> = never, Preparation extends Supported<EffectPreparation<ContractOutput<Result>, unknown, unknown>> = never, const Aggregates extends readonly string[] = readonly string[], AuditReturned extends Supported<Audit> = never, Middleware extends Supported<ContractInput<Result>> = never, const Metadata extends object = Record<never, never>, const Definition extends object = object>(handler: (input: ContractOutput<Input>, context: Context) => Handler, ...options: HandlerArguments<Definition & Forbidden & {
+  handler?: never;
+} & Omit<OperationDefinition<Context, Input, Result, Record<never, never>, Aggregates, Handler, Guard, Preparation, AuditReturned, Middleware, Metadata, BaseError, BaseRequirements, ContractSchema, never>, 'handler' | 'input' | 'result' | 'classification' | 'replayResult' | 'wire'> & (Command extends true ? {} : {
+  audit?: never;
+  prepare?: never;
+  aggregates?: never;
+}), Command, Default, {
+  audit: AuditCallback<Context, {
+    input: Input;
+    result: Result;
+  }, AuditReturned>;
+}>) => DeclaredSchemas<{
+  input: Input;
+  result: Result;
+}> & {
+  handler: (input: ContractOutput<Input>, context: Context) => NoInfer<Handler>;
+} & NoInfer<Definition> & BoundKey<Key> & CheckedEffectDefinition<Context, NoInfer<Definition> & {
+  handler: (input: ContractOutput<Input>, context: Context) => Handler;
+} & BoundKey<Key>, BaseError, BaseRequirements>;
+export type DomainEffectFactory<Context, Entries extends Readonly<Record<string, DomainOperationContract>>, Command extends boolean, Default = never, BaseError = never, BaseRequirements = never> = { [Kind in Command extends true ? 'command' : 'query']: { readonly [Key in keyof Entries]: Helper<Context, Entries[Key], Key, Command, Default, BaseError, BaseRequirements>; } & {
+  handler: HandlerHelper<Context, Entries, Command, Default, BaseError, BaseRequirements>;
+}; };
+export type DomainEffectImplementations<Context, Entries extends Readonly<Record<string, DomainOperationContract>>, Required extends boolean = false> = { [Key in keyof Entries]: DeclaredSchemas<Pick<Entries[Key], 'input' | 'result'>> & BoundKey<Key> & CheckedEffectOperation<Context> & {
+  handler: (input: ContractOutput<Entries[Key]['input']>, context: Context) => Supported<ContractInput<Entries[Key]['result']>>;
+} & (Required extends true ? {
+  audit: AuditCallback<Context, Entries[Key], Supported<Audit>>;
+} : {}); };
+export declare function domainEffectFactory<Context, Entries extends Readonly<Record<string, DomainOperationContract>>, Command extends boolean, Default, Guard>(entries: Entries, command: Command): DomainEffectFactory<Context, Entries, Command, Default, CallbackError<Guard>, CallbackRequirements<Guard>>;
+export type SharedEffectFactory<Context, Guard> = ReturnType<typeof effectOperationFactory<Context, Record<never, never>, NoInfer<CallbackError<Guard>>, NoInfer<CallbackRequirements<Guard>>, false>>;
+export type AuditValue = Supported<Audit>;
+//#endregion
+//# sourceMappingURL=domain.d.mts.map

package/dist/modules/effect/domain.mjs

@@ -0,0 +1,2 @@
+import{domainHelpers as e}from"../contracts/binding.mjs";function t(t,n){let r=e(t);return{[n?`command`:`query`]:r}}export{t as domainEffectFactory};
+//# sourceMappingURL=domain.mjs.map

package/dist/modules/effect/domain.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.mjs","names":["domainEffectFactory","helpers","domainHelpers","entries","command"],"sources":["../../../src/modules/effect/domain.ts"],"sourcesContent":["/* oxlint-disable anti-slop/no-object-parameters -- Internal helper storage is heterogeneous; the exported mapped signatures validate the schema-paired implementation. */\nimport type { Effect } from 'effect'\nimport type { AuditEntryInput } from '../../components/foundation/client'\nimport type { ContractInput, ContractOutput, ContractSchema } from '../contracts/contract'\nimport type { DomainOperationContract, ExactOperationKeys } from '../contracts/domain'\nimport { domainHelpers, type DeclaredSchemas } from '../contracts/binding'\nimport {\n\teffectOperationFactory,\n\ttype OperationDefinition,\n\ttype CheckedEffectDefinition,\n\ttype CheckedEffectOperation,\n\ttype CallbackError,\n\ttype CallbackRequirements,\n\ttype EffectPreparation,\n} from './operation'\n\ntype Supported<A> = A | PromiseLike<A> | Effect.Effect<A, unknown, unknown>\ntype Audit = Omit<AuditEntryInput, 'classification'> | null\ndeclare const domainKey: unique symbol\ntype BoundKey<Key> = { readonly [domainKey]: Key }\ntype Schemas<Entry extends DomainOperationContract> = Pick<Entry, 'input' | 'result'> &\n\tOmit<Entry, 'input' | 'result'>\ntype Forbidden = {\n\tinput?: never\n\tresult?: never\n\tclassification?: never\n\treplayResult?: never\n\twire?: never\n}\ntype AuditCallback<Context, Entry extends DomainOperationContract, Value> = (\n\tresolution: { command: ContractOutput<Entry['input']>; result: ContractOutput<Entry['result']> },\n\tcontext: Context,\n) => Value\nexport type SelectedAudit<Definition, Default> = Definition extends { audit: infer Override }\n\t? Override\n\t: 'audit' extends keyof Definition\n\t\t? Exclude<Definition['audit' & keyof Definition], undefined> | Default\n\t\t: Default\nexport type AuditedOperations<Operations, Default> = {\n\t[Key in keyof Operations]: Omit<Operations[Key], 'audit'> & {\n\t\taudit: SelectedAudit<Operations[Key], Default>\n\t}\n}\nexport type ExactDomainOperations<Operations, Contracts> = ExactOperationKeys<\n\tOperations,\n\tContracts\n> & {\n\t[Key in keyof Operations]: Operations[Key] extends BoundKey<Key> ? Operations[Key] : never\n}\n\ntype Helper<\n\tContext,\n\tEntry extends DomainOperationContract,\n\tKey,\n\tCommand extends boolean,\n\tDefault,\n\tBaseError,\n\tBaseRequirements,\n> = <\n\tHandler extends Supported<ContractInput<Entry['result']>>,\n\tGuard extends Supported<void> = never,\n\tPreparation extends Supported<\n\t\tEffectPreparation<ContractOutput<Entry['result']>, unknown, unknown>\n\t> = never,\n\tconst Aggregates extends readonly string[] = readonly string[],\n\tAuditReturned extends Supported<Audit> = never,\n\tMiddleware extends Supported<ContractInput<Entry['result']>> = never,\n\tconst Metadata extends object = Record<never, never>,\n\tconst Definition extends object = object,\n>(\n\timplementation: Definition &\n\t\tForbidden &\n\t\tOmit<\n\t\t\tOperationDefinition<\n\t\t\t\tContext,\n\t\t\t\tEntry['input'],\n\t\t\t\tEntry['result'],\n\t\t\t\tRecord<never, never>,\n\t\t\t\tAggregates,\n\t\t\t\tHandler,\n\t\t\t\tGuard,\n\t\t\t\tPreparation,\n\t\t\t\tAuditReturned,\n\t\t\t\tMiddleware,\n\t\t\t\tMetadata,\n\t\t\t\tBaseError,\n\t\t\t\tBaseRequirements,\n\t\t\t\tContractSchema,\n\t\t\t\tnever\n\t\t\t>,\n\t\t\t'input' | 'result' | 'classification' | 'replayResult' | 'wire'\n\t\t> &\n\t\t(Command extends true\n\t\t\t? [Default] extends [never]\n\t\t\t\t? { audit: AuditCallback<Context, Entry, AuditReturned> }\n\t\t\t\t: {}\n\t\t\t: { audit?: never; prepare?: never; aggregates?: never }),\n) => DeclaredSchemas<Entry> &\n\tCheckedEffectDefinition<\n\t\tContext,\n\t\tSchemas<Entry> & Definition & BoundKey<Key>,\n\t\tBaseError,\n\t\tBaseRequirements\n\t>\n\ntype HandlerArguments<\n\tOptions,\n\tCommand extends boolean,\n\tDefault,\n\tRequiredAudit,\n> = Command extends true\n\t? [Default] extends [never]\n\t\t? [options: Options & RequiredAudit]\n\t\t: [options?: Options]\n\t: [options?: Options]\n\ntype HandlerHelper<\n\tContext,\n\tEntries extends Readonly<Record<string, DomainOperationContract>>,\n\tCommand extends boolean,\n\tDefault,\n\tBaseError,\n\tBaseRequirements,\n> = <\n\tconst Input extends ContractSchema,\n\tconst Result extends ContractSchema,\n\tKey extends keyof Entries,\n\tHandler extends Supported<ContractInput<Result>>,\n\tGuard extends Supported<void> = never,\n\tPreparation extends Supported<EffectPreparation<ContractOutput<Result>, unknown, unknown>> =\n\t\tnever,\n\tconst Aggregates extends readonly string[] = readonly string[],\n\tAuditReturned extends Supported<Audit> = never,\n\tMiddleware extends Supported<ContractInput<Result>> = never,\n\tconst Metadata extends object = Record<never, never>,\n\tconst Definition extends object = object,\n>(\n\thandler: (input: ContractOutput<Input>, context: Context) => Handler,\n\t...options: HandlerArguments<\n\t\tDefinition &\n\t\t\tForbidden & { handler?: never } & Omit<\n\t\t\t\tOperationDefinition<\n\t\t\t\t\tContext,\n\t\t\t\t\tInput,\n\t\t\t\t\tResult,\n\t\t\t\t\tRecord<never, never>,\n\t\t\t\t\tAggregates,\n\t\t\t\t\tHandler,\n\t\t\t\t\tGuard,\n\t\t\t\t\tPreparation,\n\t\t\t\t\tAuditReturned,\n\t\t\t\t\tMiddleware,\n\t\t\t\t\tMetadata,\n\t\t\t\t\tBaseError,\n\t\t\t\t\tBaseRequirements,\n\t\t\t\t\tContractSchema,\n\t\t\t\t\tnever\n\t\t\t\t>,\n\t\t\t\t'handler' | 'input' | 'result' | 'classification' | 'replayResult' | 'wire'\n\t\t\t> &\n\t\t\t(Command extends true ? {} : { audit?: never; prepare?: never; aggregates?: never }),\n\t\tCommand,\n\t\tDefault,\n\t\t{ audit: AuditCallback<Context, { input: Input; result: Result }, AuditReturned> }\n\t>\n) => DeclaredSchemas<{ input: Input; result: Result }> & {\n\thandler: (input: ContractOutput<Input>, context: Context) => NoInfer<Handler>\n} & NoInfer<Definition> &\n\tBoundKey<Key> &\n\tCheckedEffectDefinition<\n\t\tContext,\n\t\tNoInfer<Definition> & {\n\t\t\thandler: (input: ContractOutput<Input>, context: Context) => Handler\n\t\t} & BoundKey<Key>,\n\t\tBaseError,\n\t\tBaseRequirements\n\t>\n\nexport type DomainEffectFactory<\n\tContext,\n\tEntries extends Readonly<Record<string, DomainOperationContract>>,\n\tCommand extends boolean,\n\tDefault = never,\n\tBaseError = never,\n\tBaseRequirements = never,\n> = {\n\t[Kind in Command extends true ? 'command' : 'query']: {\n\t\treadonly [Key in keyof Entries]: Helper<\n\t\t\tContext,\n\t\t\tEntries[Key],\n\t\t\tKey,\n\t\t\tCommand,\n\t\t\tDefault,\n\t\t\tBaseError,\n\t\t\tBaseRequirements\n\t\t>\n\t} & { handler: HandlerHelper<Context, Entries, Command, Default, BaseError, BaseRequirements> }\n}\n\nexport type DomainEffectImplementations<\n\tContext,\n\tEntries extends Readonly<Record<string, DomainOperationContract>>,\n\tRequired extends boolean = false,\n> = {\n\t[Key in keyof Entries]: DeclaredSchemas<Pick<Entries[Key], 'input' | 'result'>> &\n\t\tBoundKey<Key> &\n\t\tCheckedEffectOperation<Context> & {\n\t\t\thandler: (\n\t\t\t\tinput: ContractOutput<Entries[Key]['input']>,\n\t\t\t\tcontext: Context,\n\t\t\t) => Supported<ContractInput<Entries[Key]['result']>>\n\t\t} & (Required extends true\n\t\t\t? { audit: AuditCallback<Context, Entries[Key], Supported<Audit>> }\n\t\t\t: {})\n}\n\nexport function domainEffectFactory<\n\tContext,\n\tEntries extends Readonly<Record<string, DomainOperationContract>>,\n\tCommand extends boolean,\n\tDefault,\n\tGuard,\n>(\n\tentries: Entries,\n\tcommand: Command,\n): DomainEffectFactory<\n\tContext,\n\tEntries,\n\tCommand,\n\tDefault,\n\tCallbackError<Guard>,\n\tCallbackRequirements<Guard>\n> {\n\tconst helpers = domainHelpers(entries)\n\t// SAFETY: helper signatures check callbacks; registration pairs drafts with their declarations.\n\treturn { [command ? 'command' : 'query']: helpers } as DomainEffectFactory<\n\t\tContext,\n\t\tEntries,\n\t\tCommand,\n\t\tDefault,\n\t\tCallbackError<Guard>,\n\t\tCallbackRequirements<Guard>\n\t>\n}\n\nexport type SharedEffectFactory<Context, Guard> = ReturnType<\n\ttypeof effectOperationFactory<\n\t\tContext,\n\t\tRecord<never, never>,\n\t\tNoInfer<CallbackError<Guard>>,\n\t\tNoInfer<CallbackRequirements<Guard>>,\n\t\tfalse\n\t>\n>\nexport type AuditValue = Supported<Audit>\n"],"mappings":"yDAwNA,SAAgBA,EAOf,EACA,EAQC,CACD,IAAMC,EAAUC,EAAcC,CAAO,EAErC,MAAO,EAAGC,EAAU,UAAY,SAAUH,CAAQ,CAQnD"}

package/dist/modules/effect/operation.d.mts

@@ -90,7 +90,7 @@ type Audit<Aggregates extends readonly string[]> = Omit<AuditEntryInput, 'classi
     id: string;
   };
 };
-type OperationDefinition<Context, Input extends ContractSchema, Output extends ContractSchema, Extension, Aggregates extends readonly string[], Handler, Guard, Preparation, AuditResult, Middleware, Metadata, BaseError, BaseRequirements, Wire extends ContractSchema, Replay extends ContractSchema> = {
+export type OperationDefinition<Context, Input extends ContractSchema, Output extends ContractSchema, Extension, Aggregates extends readonly string[], Handler, Guard, Preparation, AuditResult, Middleware, Metadata, BaseError, BaseRequirements, Wire extends ContractSchema, Replay extends ContractSchema> = {
   input: Input;
   result: Output;
   handler: (input: ContractOutput<Input>, context: Context & Extension) => Handler;
@@ -120,15 +120,16 @@ type OperationDefinition<Context, Input extends ContractSchema, Output extends C
  * and returned Effect channels when middleware comes first. TypeScript processes
  * context-sensitive object callbacks in declaration order.
  */
-export declare function effectOperationFactory<Context, Extension extends Record<string, unknown> = Record<never, never>, BaseError = never, BaseRequirements = never>(): {
+export declare function effectOperationFactory<Context, Extension extends Record<string, unknown> = Record<never, never>, BaseError = never, BaseRequirements = never, AuditRequired extends boolean = true>(): {
   operation: <const Input extends ContractSchema, const Output extends ContractSchema, Handler extends Supported<ContractInput<Output>>, Guard extends Supported<void> = never, Preparation extends Supported<EffectPreparation<ContractOutput<Output>, unknown, unknown>> = never, const Aggregates extends readonly string[] = readonly string[], AuditResult extends Supported<Audit<Aggregates> | null> = never, Middleware extends Supported<ContractInput<Output>> = never, const Metadata extends object = Record<never, never>, const Wire extends ContractSchema = ContractSchema, const Replay extends ContractSchema = never, const Definition extends object = object>(definition: Definition & OperationDefinition<Context, Input, Output, Extension, Aggregates, Handler, Guard, Preparation, AuditResult, Middleware, Metadata, BaseError, BaseRequirements, Wire, Replay>) => CheckedEffectDefinition<Context, typeof definition, BaseError, BaseRequirements>;
   command: <const Input extends ContractSchema, const Output extends ContractSchema, Handler extends Supported<ContractInput<Output>>, Guard extends Supported<void> = never, Preparation extends Supported<EffectPreparation<ContractOutput<Output>, unknown, unknown>> = never, const Aggregates extends readonly string[] = readonly string[], AuditResult extends Supported<Audit<Aggregates> | null> = never, Middleware extends Supported<ContractInput<Output>> = never, const Metadata extends object = Record<never, never>, const Wire extends ContractSchema = ContractSchema, const Replay extends ContractSchema = never, const Definition extends object = object>(definition: Definition & OperationDefinition<Context, Input, Output, Extension, Aggregates, Handler, Guard, Preparation, AuditResult, Middleware, Metadata, BaseError, BaseRequirements, Wire, Replay> & {
     classification: string;
+  } & (AuditRequired extends true ? {
     audit: (resolution: {
       command: ContractOutput<Input>;
       result: ContractOutput<Output>;
     }, context: Context) => AuditResult;
-  }) => CheckedEffectDefinition<Context, typeof definition, BaseError, BaseRequirements>;
+  } : {})) => CheckedEffectDefinition<Context, typeof definition, BaseError, BaseRequirements>;
   query: <const Input extends ContractSchema, const Output extends ContractSchema, Handler extends Supported<ContractInput<Output>>, Guard extends Supported<void> = never, Middleware extends Supported<ContractInput<Output>> = never, const Metadata extends object = Record<never, never>, const Wire extends ContractSchema = ContractSchema, const Replay extends ContractSchema = never, const Definition extends object = object>(definition: Definition & OperationDefinition<Context, Input, Output, Extension, readonly string[], Handler, Guard, never, never, Middleware, Metadata, BaseError, BaseRequirements, Wire, Replay> & {
     prepare?: never;
     audit?: never;