@yielded/auth-persistence 0.1.0-beta.24 → 0.1.0-beta.26

package/dist/internal/sql-commit.d.mts

@@ -0,0 +1,72 @@
+import { PersistenceMappingError } from "./mapping-error.mjs";
+import { Cause, Context, Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { Statement } from "effect/sql/Statement";
+import { CommitDiscarded, CommitPending, CurrentCommitJournal, LifecycleHooks, PreparedCommit } from "@yielded/auth/Hooks";
+import { SqlError } from "effect/sql/SqlError";
+//#region src/internal/sql-commit.d.ts
+type SqlCommitError = PersistenceMappingError | Schema.SchemaError | SqlError;
+declare const SqlCommitOwnerError_base: Schema.Class<SqlCommitOwnerError, Schema.TaggedStruct<"SqlCommitOwnerError", {
+  readonly reason: Schema.Literals<readonly ["closed", "different-client", "poisoned", "in-flight", "invalid-receipt", "invalid-mode", "postcondition-requires-transaction", "batch-required", "empty-batch"]>;
+}>, Cause.YieldableError>;
+export declare class SqlCommitOwnerError extends SqlCommitOwnerError_base {}
+declare const SqlBatchCommit_base: Context.ServiceClass<SqlBatchCommit, "@yielded/auth-persistence/SqlBatchCommit", {
+  readonly client: SqlClient.SqlClient;
+  readonly execute: (statements: ReadonlyArray<Statement<unknown>>) => Effect.Effect<void, SqlError>;
+} | undefined>;
+/** Composition selects a D1 batch owner or explicitly supplies no batch owner. */
+export declare class SqlBatchCommit extends SqlBatchCommit_base {}
+declare const SqlNativeCommit_base: Context.ServiceClass<SqlNativeCommit, "@yielded/auth-persistence/SqlNativeCommit", {
+  readonly client: SqlClient.SqlClient;
+  readonly withTransaction: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | SqlCommitError, R>;
+}>;
+/** Platform ownership for databases requiring a transaction isolation policy. */
+export declare class SqlNativeCommit extends SqlNativeCommit_base {}
+type SqlCommitMode = "transaction" | "statement" | "batch";
+interface SqlPostcondition {
+  readonly name: string;
+  readonly check: Effect.Effect<void, SqlCommitError, SqlClient.SqlClient>;
+}
+export interface SqlCommitScope {
+  readonly client: SqlClient.SqlClient;
+  readonly mode: SqlCommitMode;
+  readonly origin: "operation" | "application";
+  readonly postconditions: Array<SqlPostcondition | {
+    readonly name: string;
+    readonly statement: Statement<unknown>;
+  }>;
+  readonly receipts: Array<Effect.Effect<void, CommitPending | CommitDiscarded>>;
+  readonly statements: Array<Statement<unknown>>;
+  active: boolean;
+  poisoned: boolean;
+  inFlight: number;
+}
+declare const CurrentSqlCommit_base: Context.ServiceClass<CurrentSqlCommit, "@yielded/auth-persistence/CurrentSqlCommit", SqlCommitScope>;
+export declare class CurrentSqlCommit extends CurrentSqlCommit_base {}
+type OwnedRequirements<R> = Exclude<Exclude<Exclude<Exclude<R, CurrentSqlCommit>, CurrentCommitJournal>, SqlClient.SqlClient>, LifecycleHooks>;
+export interface SqlCommitExecutor<Failure> {
+  readonly read: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, Failure, Exclude<Exclude<R, SqlClient.SqlClient>, LifecycleHooks>>;
+  /** Session verification only: runs on the caller's transaction connection when
+   * one is ambient. Other reads reject ambient transactions before any result. */
+  readonly verify: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, Failure, Exclude<Exclude<R, SqlClient.SqlClient>, LifecycleHooks>>;
+  /** Preserve expected operation failures without admitting application suffix work. */
+  readonly operation: <A, E, R>(effect: Effect.Effect<A, E, R>, mode?: "transaction" | "statement") => Effect.Effect<A, E | Failure, OwnedRequirements<R>>;
+  readonly operationBatch: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | Failure, OwnedRequirements<R> | SqlBatchCommit>;
+  readonly coordinate: <A, E, R>(effect: Effect.Effect<A, E, R>, mode?: "transaction" | "statement") => Effect.Effect<A, E | Failure, OwnedRequirements<R>>;
+  readonly coordinateBatch: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | Failure, OwnedRequirements<R> | SqlBatchCommit>;
+  readonly run: <A, E, R>(effect: Effect.Effect<A, E, R>, mode?: "transaction" | "statement") => Effect.Effect<A, Failure, OwnedRequirements<R>>;
+  readonly batch: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, Failure, OwnedRequirements<R> | SqlBatchCommit>;
+}
+/** Capture an executor where its service is constructed. Bound services cannot
+ * escape their owner, join another client, or silently start a second commit.
+ * Reads are advisory and never coordinate a commit. Statement mode is reserved
+ * for one atomic SQL mutation; authority mutations use transaction or batch mode.
+ */
+export declare const makeSqlCommitExecutor: <Failure>(unavailable: () => Failure) => Effect.Effect<SqlCommitExecutor<Failure>, never, LifecycleHooks | SqlClient.SqlClient>;
+/** Application statements join the same fixed batch and cannot escape it. */
+export interface SqlBatchCollector {
+  readonly append: (statement: Statement<unknown>) => Effect.Effect<void, SqlCommitOwnerError>;
+}
+export declare const captureSqlBatchStatements: Effect.Effect<SqlBatchCollector, never, CurrentSqlCommit>;
+//#endregion
+//# sourceMappingURL=sql-commit.d.mts.map

package/dist/internal/sql-commit.mjs

@@ -0,0 +1,176 @@
+import { requireStandalone } from "./standalone.mjs";
+import { Cause, Context, Data, Effect, Option, Predicate, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { CurrentCommitJournal, LifecycleHooks, coordinateCommit, hasCommitScope } from "@yielded/auth/Hooks";
+import { reportPersistenceFailure } from "@yielded/auth/Persistence";
+//#region src/internal/sql-commit.ts
+var SqlCommitOwnerError = class extends Schema.TaggedError()("SqlCommitOwnerError", { reason: Schema.Literals([
+	"closed",
+	"different-client",
+	"poisoned",
+	"in-flight",
+	"invalid-receipt",
+	"invalid-mode",
+	"postcondition-requires-transaction",
+	"batch-required",
+	"empty-batch"
+]) }) {};
+/** Composition selects a D1 batch owner or explicitly supplies no batch owner. */
+var SqlBatchCommit = class extends Context.Service()("@yielded/auth-persistence/SqlBatchCommit") {};
+/** Platform ownership for databases requiring a transaction isolation policy. */
+var SqlNativeCommit = class extends Context.Service()("@yielded/auth-persistence/SqlNativeCommit") {};
+var CurrentSqlCommit = class extends Context.Service()("@yielded/auth-persistence/CurrentSqlCommit") {};
+const closed = () => SqlCommitOwnerError.make({ reason: "closed" });
+/** Explicit final checks run in the physical owner after application work.
+* They resolve SqlClient there, rather than retaining a released savepoint.
+*/
+const registerSqlPostcondition = (condition) => Effect.flatMap(CurrentSqlCommit, (scope) => {
+	if (!scope.active) return Effect.fail(closed());
+	if (scope.mode !== "transaction") return Effect.fail(SqlCommitOwnerError.make({ reason: "postcondition-requires-transaction" }));
+	return Effect.sync(() => {
+		scope.postconditions.push(condition);
+	});
+});
+/** D1 checks final semantic predicates after all application batch statements. */
+const registerSqlBatchPostcondition = (condition) => Effect.flatMap(CurrentSqlCommit, (scope) => {
+	if (!scope.active) return Effect.fail(closed());
+	if (scope.mode !== "batch") return Effect.fail(SqlCommitOwnerError.make({ reason: "batch-required" }));
+	return Effect.sync(() => {
+		scope.postconditions.push(condition);
+	});
+});
+/** A caught rollback cannot leave a discarded receipt in a successful owner. A D1
+* batch needs one physical statement even when the decision writes nothing. */
+const registerSqlCommitReceipt = (receipt) => Effect.flatMap(CurrentSqlCommit, (scope) => {
+	if (!scope.active) return Effect.fail(closed());
+	return Effect.sync(() => {
+		if (scope.mode === "batch" && scope.statements.length === 0) scope.statements.push(scope.client`select 1`);
+		scope.receipts.push(receipt.read.pipe(Effect.asVoid));
+	});
+});
+const appendSqlBatchStatement = (statement) => Effect.flatMap(CurrentSqlCommit, (scope) => {
+	if (!scope.active) return Effect.fail(closed());
+	if (scope.mode !== "batch") return Effect.fail(SqlCommitOwnerError.make({ reason: "batch-required" }));
+	return Effect.sync(() => {
+		scope.statements.push(statement);
+	});
+});
+/** Capture an executor where its service is constructed. Bound services cannot
+* escape their owner, join another client, or silently start a second commit.
+* Reads are advisory and never coordinate a commit. Statement mode is reserved
+* for one atomic SQL mutation; authority mutations use transaction or batch mode.
+*/
+const makeSqlCommitExecutor = Effect.fnUntraced(function* (unavailable) {
+	const sql = yield* SqlClient.SqlClient;
+	const hooks = yield* LifecycleHooks;
+	const captured = yield* Effect.serviceOption(CurrentSqlCommit);
+	const native = yield* Effect.serviceOption(SqlNativeCommit);
+	const failure = unavailable();
+	const report = (effect) => reportPersistenceFailure(effect, (error) => Object.is(error, failure) || Schema.is(SqlCommitOwnerError)(error) || Predicate.hasProperty(failure, "_tag") && typeof failure._tag === "string" && Predicate.hasProperty(error, "_tag") && error._tag === failure._tag).pipe(Effect.mapError(() => failure), Effect.catchCause((cause) => Cause.hasInterrupts(cause) ? Effect.failCause(cause) : Effect.fail(failure)));
+	const admit = Effect.gen(function* () {
+		if (Option.isSome(captured)) {
+			const scope = captured.value;
+			const current = yield* Effect.serviceOption(CurrentSqlCommit);
+			if (!scope.active || Option.isNone(current) || current.value !== scope) return yield* closed();
+			if (scope.client.transactionService !== sql.transactionService) return yield* SqlCommitOwnerError.make({ reason: "different-client" });
+		} else {
+			if (yield* hasCommitScope) return yield* Effect.fail(failure);
+			yield* requireStandalone(() => failure, sql.transactionService);
+		}
+	});
+	const provide = (effect) => effect.pipe(Effect.provideService(SqlClient.SqlClient, sql), Effect.provideService(LifecycleHooks, hooks));
+	const bound = (scope, effect) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+		yield* admit;
+		const journal = yield* Effect.serviceOption(CurrentCommitJournal);
+		if (Option.isNone(journal)) return yield* closed();
+		scope.inFlight++;
+		return yield* restore(effect.pipe(Effect.provideService(CurrentSqlCommit, scope), Effect.provideService(CurrentCommitJournal, journal.value))).pipe(Effect.flatMap((value) => admit.pipe(Effect.as(value))), Effect.onExit((exit) => Effect.sync(() => {
+			scope.inFlight--;
+			if (exit._tag === "Failure") scope.poisoned = true;
+		})));
+	}));
+	const finish = Effect.fnUntraced(function* (scope) {
+		if (scope.poisoned) return yield* SqlCommitOwnerError.make({ reason: "poisoned" });
+		if (scope.inFlight !== 0) return yield* SqlCommitOwnerError.make({ reason: "in-flight" });
+		for (const condition of scope.postconditions) if ("statement" in condition) scope.statements.push(condition.statement);
+		else yield* condition.check;
+		for (const receipt of scope.receipts) {
+			const status = yield* Effect.result(receipt);
+			if (status._tag !== "Failure" || status.failure._tag !== "CommitPending") return yield* SqlCommitOwnerError.make({ reason: "invalid-receipt" });
+		}
+	});
+	const owned = (effect, mode, origin, batch) => {
+		if (Option.isSome(captured)) {
+			const scope = captured.value;
+			if (mode !== scope.mode && !(mode === "statement" && scope.mode === "transaction")) return Effect.fail(SqlCommitOwnerError.make({ reason: "invalid-mode" }));
+			return provide(bound(scope, effect));
+		}
+		const work = Effect.gen(function* () {
+			yield* admit;
+			return (yield* coordinateCommit(() => {
+				const scope = {
+					client: sql,
+					mode,
+					origin,
+					active: true,
+					poisoned: false,
+					inFlight: 0,
+					postconditions: [],
+					receipts: [],
+					statements: []
+				};
+				const owner = Effect.gen(function* () {
+					const value = yield* effect.pipe(Effect.provideService(CurrentSqlCommit, scope), Effect.ensuring(Effect.sync(() => {
+						scope.active = false;
+					})));
+					yield* finish(scope);
+					if (mode === "batch") {
+						if (batch === void 0) return yield* SqlCommitOwnerError.make({ reason: "batch-required" });
+						if (batch.client.transactionService !== sql.transactionService) return yield* SqlCommitOwnerError.make({ reason: "different-client" });
+						if (scope.statements.length === 0) return yield* SqlCommitOwnerError.make({ reason: "empty-batch" });
+						yield* batch.execute(scope.statements);
+					}
+					return value;
+				});
+				if (mode !== "transaction") return owner;
+				if (Option.isNone(native)) return sql.withTransaction(owner);
+				if (native.value.client.transactionService !== sql.transactionService) return Effect.fail(SqlCommitOwnerError.make({ reason: "different-client" }));
+				return native.value.withTransaction(owner);
+			})).value;
+		});
+		return provide(work);
+	};
+	const read = (effect) => {
+		if (Option.isSome(captured)) return provide(report(bound(captured.value, effect)));
+		return provide(report(admit.pipe(Effect.andThen(effect))));
+	};
+	const verify = (effect) => Option.isSome(captured) ? read(effect) : provide(report(effect));
+	const coordinate = (effect, mode, origin, batch) => {
+		class ApplicationFailure extends Data.TaggedError("SqlCommitApplicationFailure") {}
+		const wrapped = effect.pipe(Effect.mapError((error) => new ApplicationFailure({ error })));
+		return reportPersistenceFailure(owned(wrapped, mode, origin, batch), (error) => error instanceof ApplicationFailure || Schema.is(SqlCommitOwnerError)(error)).pipe(Effect.catchCause((cause) => Effect.failCause(Cause.fromReasons(cause.reasons.map((reason) => {
+			if (Cause.isInterruptReason(reason)) return reason;
+			if (Cause.isFailReason(reason) && reason.error instanceof ApplicationFailure) return Cause.makeFailReason(reason.error.error);
+			return Cause.makeFailReason(failure);
+		})))));
+	};
+	return {
+		read,
+		verify,
+		operation: (effect, mode = "transaction") => coordinate(effect, mode, "operation"),
+		operationBatch: (effect) => Effect.flatMap(SqlBatchCommit, (batch) => coordinate(effect, "batch", "operation", batch)),
+		coordinate: (effect, mode = "transaction") => coordinate(effect, mode, "application"),
+		coordinateBatch: (effect) => Effect.flatMap(SqlBatchCommit, (batch) => coordinate(effect, "batch", "application", batch)),
+		run: (effect, mode = "transaction") => report(owned(effect, mode, "operation")),
+		batch: (effect) => Effect.flatMap(SqlBatchCommit, (batch) => report(owned(effect, "batch", "operation", batch)))
+	};
+});
+const captureSqlBatchStatements = Effect.map(CurrentSqlCommit, (scope) => ({ append: (statement) => Effect.gen(function* () {
+	const current = yield* Effect.serviceOption(CurrentSqlCommit);
+	if (!scope.active || scope.mode !== "batch" || Option.isNone(current) || current.value !== scope) return yield* closed();
+	scope.statements.push(statement);
+}) }));
+//#endregion
+export { CurrentSqlCommit, SqlBatchCommit, SqlCommitOwnerError, SqlNativeCommit, appendSqlBatchStatement, captureSqlBatchStatements, makeSqlCommitExecutor, registerSqlBatchPostcondition, registerSqlCommitReceipt, registerSqlPostcondition };
+
+//# sourceMappingURL=sql-commit.mjs.map

package/dist/internal/sql-commit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-commit.mjs","names":[],"sources":["../../src/internal/sql-commit.ts"],"sourcesContent":["import {\n  type CommitDiscarded,\n  type CommitPending,\n  type PreparedCommit,\n  CurrentCommitJournal,\n  LifecycleHooks,\n  coordinateCommit,\n  hasCommitScope,\n} from \"@yielded/auth/Hooks\";\nimport { reportPersistenceFailure } from \"@yielded/auth/Persistence\";\nimport { Cause, Context, Data, Effect, Option, Predicate, Schema } from \"effect\";\nimport { SqlClient } from \"effect/sql\";\nimport type { SqlError } from \"effect/sql/SqlError\";\nimport type { Statement } from \"effect/sql/Statement\";\n\nimport type { PersistenceMappingError } from \"./mapping-error\";\nimport { requireStandalone } from \"./standalone\";\n\ntype SqlCommitError = PersistenceMappingError | Schema.SchemaError | SqlError;\n\nexport class SqlCommitOwnerError extends Schema.TaggedError<SqlCommitOwnerError>()(\n  \"SqlCommitOwnerError\",\n  {\n    reason: Schema.Literals([\n      \"closed\",\n      \"different-client\",\n      \"poisoned\",\n      \"in-flight\",\n      \"invalid-receipt\",\n      \"invalid-mode\",\n      \"postcondition-requires-transaction\",\n      \"batch-required\",\n      \"empty-batch\",\n    ]),\n  },\n) {}\n\n/** Composition selects a D1 batch owner or explicitly supplies no batch owner. */\nexport class SqlBatchCommit extends Context.Service<\n  SqlBatchCommit,\n  | undefined\n  | {\n      readonly client: SqlClient.SqlClient;\n      readonly execute: (\n        statements: ReadonlyArray<Statement<unknown>>,\n      ) => Effect.Effect<void, SqlError>;\n    }\n>()(\"@yielded/auth-persistence/SqlBatchCommit\") {}\n\n/** Platform ownership for databases requiring a transaction isolation policy. */\nexport class SqlNativeCommit extends Context.Service<\n  SqlNativeCommit,\n  {\n    readonly client: SqlClient.SqlClient;\n    readonly withTransaction: <A, E, R>(\n      effect: Effect.Effect<A, E, R>,\n    ) => Effect.Effect<A, E | SqlCommitError, R>;\n  }\n>()(\"@yielded/auth-persistence/SqlNativeCommit\") {}\n\ntype SqlCommitMode = \"transaction\" | \"statement\" | \"batch\";\n\ninterface SqlPostcondition {\n  readonly name: string;\n  readonly check: Effect.Effect<void, SqlCommitError, SqlClient.SqlClient>;\n}\n\nexport interface SqlCommitScope {\n  readonly client: SqlClient.SqlClient;\n  readonly mode: SqlCommitMode;\n  readonly origin: \"operation\" | \"application\";\n  readonly postconditions: Array<\n    SqlPostcondition | { readonly name: string; readonly statement: Statement<unknown> }\n  >;\n  readonly receipts: Array<Effect.Effect<void, CommitPending | CommitDiscarded>>;\n  readonly statements: Array<Statement<unknown>>;\n  active: boolean;\n  poisoned: boolean;\n  inFlight: number;\n}\n\nexport class CurrentSqlCommit extends Context.Service<CurrentSqlCommit, SqlCommitScope>()(\n  \"@yielded/auth-persistence/CurrentSqlCommit\",\n) {}\n\nconst closed = (): SqlCommitOwnerError => SqlCommitOwnerError.make({ reason: \"closed\" });\n\n/** Explicit final checks run in the physical owner after application work.\n * They resolve SqlClient there, rather than retaining a released savepoint.\n */\nexport const registerSqlPostcondition = (\n  condition: SqlPostcondition,\n): Effect.Effect<void, SqlCommitOwnerError, CurrentSqlCommit> =>\n  Effect.flatMap(CurrentSqlCommit, (scope) => {\n    if (!scope.active) return Effect.fail(closed());\n    if (scope.mode !== \"transaction\")\n      return Effect.fail(\n        SqlCommitOwnerError.make({ reason: \"postcondition-requires-transaction\" }),\n      );\n\n    return Effect.sync(() => {\n      scope.postconditions.push(condition);\n    });\n  });\n\n/** D1 checks final semantic predicates after all application batch statements. */\nexport const registerSqlBatchPostcondition = (condition: {\n  readonly name: string;\n  readonly statement: Statement<unknown>;\n}): Effect.Effect<void, SqlCommitOwnerError, CurrentSqlCommit> =>\n  Effect.flatMap(CurrentSqlCommit, (scope) => {\n    if (!scope.active) return Effect.fail(closed());\n    if (scope.mode !== \"batch\")\n      return Effect.fail(SqlCommitOwnerError.make({ reason: \"batch-required\" }));\n\n    return Effect.sync(() => {\n      scope.postconditions.push(condition);\n    });\n  });\n\n/** A caught rollback cannot leave a discarded receipt in a successful owner. A D1\n * batch needs one physical statement even when the decision writes nothing. */\nexport const registerSqlCommitReceipt = <A>(\n  receipt: PreparedCommit<A>,\n): Effect.Effect<void, SqlCommitOwnerError, CurrentSqlCommit> =>\n  Effect.flatMap(CurrentSqlCommit, (scope) => {\n    if (!scope.active) return Effect.fail(closed());\n\n    return Effect.sync(() => {\n      if (scope.mode === \"batch\" && scope.statements.length === 0)\n        scope.statements.push(scope.client`select 1`);\n      scope.receipts.push(receipt.read.pipe(Effect.asVoid));\n    });\n  });\n\nexport const appendSqlBatchStatement = (\n  statement: Statement<unknown>,\n): Effect.Effect<void, SqlCommitOwnerError, CurrentSqlCommit> =>\n  Effect.flatMap(CurrentSqlCommit, (scope) => {\n    if (!scope.active) return Effect.fail(closed());\n    if (scope.mode !== \"batch\")\n      return Effect.fail(SqlCommitOwnerError.make({ reason: \"batch-required\" }));\n\n    return Effect.sync(() => {\n      scope.statements.push(statement);\n    });\n  });\n\ntype OwnedRequirements<R> = Exclude<\n  Exclude<Exclude<Exclude<R, CurrentSqlCommit>, CurrentCommitJournal>, SqlClient.SqlClient>,\n  LifecycleHooks\n>;\n\nexport interface SqlCommitExecutor<Failure> {\n  readonly read: <A, E, R>(\n    effect: Effect.Effect<A, E, R>,\n  ) => Effect.Effect<A, Failure, Exclude<Exclude<R, SqlClient.SqlClient>, LifecycleHooks>>;\n  /** Session verification only: runs on the caller's transaction connection when\n   * one is ambient. Other reads reject ambient transactions before any result. */\n  readonly verify: <A, E, R>(\n    effect: Effect.Effect<A, E, R>,\n  ) => Effect.Effect<A, Failure, Exclude<Exclude<R, SqlClient.SqlClient>, LifecycleHooks>>;\n  /** Preserve expected operation failures without admitting application suffix work. */\n  readonly operation: <A, E, R>(\n    effect: Effect.Effect<A, E, R>,\n    mode?: \"transaction\" | \"statement\",\n  ) => Effect.Effect<A, E | Failure, OwnedRequirements<R>>;\n  readonly operationBatch: <A, E, R>(\n    effect: Effect.Effect<A, E, R>,\n  ) => Effect.Effect<A, E | Failure, OwnedRequirements<R> | SqlBatchCommit>;\n  readonly coordinate: <A, E, R>(\n    effect: Effect.Effect<A, E, R>,\n    mode?: \"transaction\" | \"statement\",\n  ) => Effect.Effect<A, E | Failure, OwnedRequirements<R>>;\n  readonly coordinateBatch: <A, E, R>(\n    effect: Effect.Effect<A, E, R>,\n  ) => Effect.Effect<A, E | Failure, OwnedRequirements<R> | SqlBatchCommit>;\n  readonly run: <A, E, R>(\n    effect: Effect.Effect<A, E, R>,\n    mode?: \"transaction\" | \"statement\",\n  ) => Effect.Effect<A, Failure, OwnedRequirements<R>>;\n  readonly batch: <A, E, R>(\n    effect: Effect.Effect<A, E, R>,\n  ) => Effect.Effect<A, Failure, OwnedRequirements<R> | SqlBatchCommit>;\n}\n\n/** Capture an executor where its service is constructed. Bound services cannot\n * escape their owner, join another client, or silently start a second commit.\n * Reads are advisory and never coordinate a commit. Statement mode is reserved\n * for one atomic SQL mutation; authority mutations use transaction or batch mode.\n */\nexport const makeSqlCommitExecutor = Effect.fnUntraced(function* <Failure>(\n  unavailable: () => Failure,\n): Effect.fn.Return<SqlCommitExecutor<Failure>, never, SqlClient.SqlClient | LifecycleHooks> {\n  const sql = yield* SqlClient.SqlClient;\n  const hooks = yield* LifecycleHooks;\n  const captured = yield* Effect.serviceOption(CurrentSqlCommit);\n  const native = yield* Effect.serviceOption(SqlNativeCommit);\n  const failure = unavailable();\n\n  const report = <A, E, R>(effect: Effect.Effect<A, E, R>) =>\n    reportPersistenceFailure(\n      effect,\n      (error) =>\n        Object.is(error, failure) ||\n        Schema.is(SqlCommitOwnerError)(error) ||\n        (Predicate.hasProperty(failure, \"_tag\") &&\n          typeof failure._tag === \"string\" &&\n          Predicate.hasProperty(error, \"_tag\") &&\n          error._tag === failure._tag),\n    ).pipe(\n      Effect.mapError(() => failure),\n      Effect.catchCause((cause) =>\n        Cause.hasInterrupts(cause) ? Effect.failCause(cause) : Effect.fail(failure),\n      ),\n    );\n\n  const admit = Effect.gen(function* () {\n    if (Option.isSome(captured)) {\n      const scope = captured.value;\n      const current = yield* Effect.serviceOption(CurrentSqlCommit);\n\n      if (!scope.active || Option.isNone(current) || current.value !== scope)\n        return yield* closed();\n      if (scope.client.transactionService !== sql.transactionService)\n        return yield* SqlCommitOwnerError.make({ reason: \"different-client\" });\n    } else {\n      if (yield* hasCommitScope) return yield* Effect.fail(failure);\n      yield* requireStandalone(() => failure, sql.transactionService);\n    }\n  });\n\n  const provide = <A, E, R>(effect: Effect.Effect<A, E, R>) =>\n    effect.pipe(\n      Effect.provideService(SqlClient.SqlClient, sql),\n      Effect.provideService(LifecycleHooks, hooks),\n    );\n\n  const bound = <A, E, R>(scope: SqlCommitScope, effect: Effect.Effect<A, E, R>) =>\n    Effect.uninterruptibleMask((restore) =>\n      Effect.gen(function* () {\n        yield* admit;\n        const journal = yield* Effect.serviceOption(CurrentCommitJournal);\n\n        if (Option.isNone(journal)) return yield* closed();\n        scope.inFlight++;\n\n        return yield* restore(\n          effect.pipe(\n            Effect.provideService(CurrentSqlCommit, scope),\n            Effect.provideService(CurrentCommitJournal, journal.value),\n          ),\n        ).pipe(\n          Effect.flatMap((value) => admit.pipe(Effect.as(value))),\n          Effect.onExit((exit) =>\n            Effect.sync(() => {\n              scope.inFlight--;\n              if (exit._tag === \"Failure\") scope.poisoned = true;\n            }),\n          ),\n        );\n      }),\n    );\n\n  const finish = Effect.fnUntraced(function* (scope: SqlCommitScope) {\n    if (scope.poisoned) return yield* SqlCommitOwnerError.make({ reason: \"poisoned\" });\n    if (scope.inFlight !== 0) return yield* SqlCommitOwnerError.make({ reason: \"in-flight\" });\n\n    for (const condition of scope.postconditions) {\n      if (\"statement\" in condition) scope.statements.push(condition.statement);\n      else yield* condition.check;\n    }\n    for (const receipt of scope.receipts) {\n      const status = yield* Effect.result(receipt);\n\n      if (status._tag !== \"Failure\" || status.failure._tag !== \"CommitPending\")\n        return yield* SqlCommitOwnerError.make({ reason: \"invalid-receipt\" });\n    }\n  });\n\n  const owned = <A, E, R>(\n    effect: Effect.Effect<A, E, R>,\n    mode: SqlCommitMode,\n    origin: SqlCommitScope[\"origin\"],\n    batch?: SqlBatchCommit[\"Service\"],\n  ) => {\n    if (Option.isSome(captured)) {\n      const scope = captured.value;\n\n      if (mode !== scope.mode && !(mode === \"statement\" && scope.mode === \"transaction\"))\n        return Effect.fail(SqlCommitOwnerError.make({ reason: \"invalid-mode\" }));\n\n      return provide(bound(scope, effect));\n    }\n\n    const work = Effect.gen(function* () {\n      yield* admit;\n\n      const result = yield* coordinateCommit(() => {\n        const scope: SqlCommitScope = {\n          client: sql,\n          mode,\n          origin,\n          active: true,\n          poisoned: false,\n          inFlight: 0,\n          postconditions: [],\n          receipts: [],\n          statements: [],\n        };\n\n        const owner = Effect.gen(function* () {\n          const value = yield* effect.pipe(\n            Effect.provideService(CurrentSqlCommit, scope),\n            Effect.ensuring(\n              Effect.sync(() => {\n                scope.active = false;\n              }),\n            ),\n          );\n\n          yield* finish(scope);\n          if (mode === \"batch\") {\n            if (batch === undefined)\n              return yield* SqlCommitOwnerError.make({ reason: \"batch-required\" });\n            if (batch.client.transactionService !== sql.transactionService)\n              return yield* SqlCommitOwnerError.make({ reason: \"different-client\" });\n            if (scope.statements.length === 0)\n              return yield* SqlCommitOwnerError.make({ reason: \"empty-batch\" });\n\n            yield* batch.execute(scope.statements);\n          }\n\n          return value;\n        });\n\n        if (mode !== \"transaction\") return owner;\n        if (Option.isNone(native)) return sql.withTransaction(owner);\n        if (native.value.client.transactionService !== sql.transactionService)\n          return Effect.fail(SqlCommitOwnerError.make({ reason: \"different-client\" }));\n\n        return native.value.withTransaction(owner);\n      });\n\n      return result.value;\n    });\n\n    return provide(work);\n  };\n\n  const read = <A, E, R>(effect: Effect.Effect<A, E, R>) => {\n    if (Option.isSome(captured)) return provide(report(bound(captured.value, effect)));\n\n    return provide(report(admit.pipe(Effect.andThen(effect))));\n  };\n\n  const verify = <A, E, R>(effect: Effect.Effect<A, E, R>) =>\n    Option.isSome(captured) ? read(effect) : provide(report(effect));\n\n  const coordinate = <A, E, R>(\n    effect: Effect.Effect<A, E, R>,\n    mode: SqlCommitMode,\n    origin: SqlCommitScope[\"origin\"],\n    batch?: SqlBatchCommit[\"Service\"],\n  ) => {\n    class ApplicationFailure extends Data.TaggedError(\"SqlCommitApplicationFailure\")<{\n      readonly error: E;\n    }> {}\n    const wrapped = effect.pipe(Effect.mapError((error) => new ApplicationFailure({ error })));\n\n    return reportPersistenceFailure(\n      owned(wrapped, mode, origin, batch),\n      (error) => error instanceof ApplicationFailure || Schema.is(SqlCommitOwnerError)(error),\n    ).pipe(\n      Effect.catchCause((cause) =>\n        Effect.failCause(\n          Cause.fromReasons(\n            cause.reasons.map((reason): Cause.Reason<E | Failure> => {\n              if (Cause.isInterruptReason(reason)) return reason;\n              if (Cause.isFailReason(reason) && reason.error instanceof ApplicationFailure)\n                return Cause.makeFailReason(reason.error.error);\n\n              return Cause.makeFailReason(failure);\n            }),\n          ),\n        ),\n      ),\n    );\n  };\n\n  return {\n    read,\n    verify,\n    operation: <A, E, R>(\n      effect: Effect.Effect<A, E, R>,\n      mode: \"transaction\" | \"statement\" = \"transaction\",\n    ) => coordinate(effect, mode, \"operation\"),\n    operationBatch: <A, E, R>(effect: Effect.Effect<A, E, R>) =>\n      Effect.flatMap(SqlBatchCommit, (batch) => coordinate(effect, \"batch\", \"operation\", batch)),\n    coordinate: <A, E, R>(\n      effect: Effect.Effect<A, E, R>,\n      mode: \"transaction\" | \"statement\" = \"transaction\",\n    ) => coordinate(effect, mode, \"application\"),\n    coordinateBatch: <A, E, R>(effect: Effect.Effect<A, E, R>) =>\n      Effect.flatMap(SqlBatchCommit, (batch) => coordinate(effect, \"batch\", \"application\", batch)),\n    run: <A, E, R>(\n      effect: Effect.Effect<A, E, R>,\n      mode: \"transaction\" | \"statement\" = \"transaction\",\n    ): Effect.Effect<A, Failure, OwnedRequirements<R>> => report(owned(effect, mode, \"operation\")),\n    batch: <A, E, R>(effect: Effect.Effect<A, E, R>) =>\n      Effect.flatMap(SqlBatchCommit, (batch) => report(owned(effect, \"batch\", \"operation\", batch))),\n  };\n});\n\n/** Application statements join the same fixed batch and cannot escape it. */\nexport interface SqlBatchCollector {\n  readonly append: (statement: Statement<unknown>) => Effect.Effect<void, SqlCommitOwnerError>;\n}\n\nexport const captureSqlBatchStatements: Effect.Effect<SqlBatchCollector, never, CurrentSqlCommit> =\n  Effect.map(CurrentSqlCommit, (scope) => ({\n    append: (statement: Statement<unknown>) =>\n      Effect.gen(function* () {\n        const current = yield* Effect.serviceOption(CurrentSqlCommit);\n\n        if (\n          !scope.active ||\n          scope.mode !== \"batch\" ||\n          Option.isNone(current) ||\n          current.value !== scope\n        )\n          return yield* closed();\n        scope.statements.push(statement);\n      }),\n  }));\n"],"mappings":"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"}

package/dist/internal/sql-expression.d.mts

@@ -0,0 +1,17 @@
+import * as Statement$1 from "effect/sql/Statement";
+import { SqlClient } from "effect/sql/SqlClient";
+//#region src/internal/sql-expression.d.ts
+/** Pure mapped SQL. Compilation binds values through the executing client's
+ * dialect; expressions neither acquire a client nor execute a query. */
+export declare class SqlExpression {
+  readonly compile: (client: SqlClient) => Statement$1.Fragment;
+  constructor(compile: (client: SqlClient) => Statement$1.Fragment);
+}
+declare const template: (parts: TemplateStringsArray, ...values: ReadonlyArray<unknown>) => SqlExpression;
+export declare const sql: typeof template & {
+  join: (values: ReadonlyArray<unknown>, separator?: SqlExpression) => SqlExpression;
+};
+export declare const eq: (left: unknown, right: unknown) => SqlExpression;
+export declare const and: (...expressions: ReadonlyArray<SqlExpression | undefined>) => SqlExpression | undefined;
+//#endregion
+//# sourceMappingURL=sql-expression.d.mts.map

package/dist/internal/sql-expression.mjs

@@ -0,0 +1,49 @@
+import { PersistenceMappingError } from "./mapping-error.mjs";
+import { Column, Table, identifier } from "./sql-table.mjs";
+import * as Statement$1 from "effect/sql/Statement";
+//#region src/internal/sql-expression.ts
+/** Pure mapped SQL. Compilation binds values through the executing client's
+* dialect; expressions neither acquire a client nor execute a query. */
+var SqlExpression = class {
+	compile;
+	constructor(compile) {
+		this.compile = compile;
+	}
+};
+const quoted = (client, name) => {
+	if (name.includes("\0")) throw PersistenceMappingError.make({
+		operation: "mapping",
+		cause: "NUL in SQL identifier"
+	});
+	return client.literal(identifier(name));
+};
+const tableName = (client, name, schema) => schema === void 0 ? quoted(client, name) : client`${quoted(client, schema)}.${quoted(client, name)}`;
+const value = (client, input) => {
+	if (Statement$1.isFragment(input)) return input;
+	if (input instanceof SqlExpression) return input.compile(client);
+	if (input instanceof Table) return tableName(client, input.name, input.schema);
+	if (input instanceof Column) return client`${tableName(client, input.tableName, input.schema)}.${quoted(client, input.options.name)}`;
+	return Statement$1.fragment([Statement$1.parameter(typeof input === "boolean" ? client.onDialectOrElse({
+		sqlite: () => Number(input),
+		orElse: () => input
+	}) : input)]);
+};
+/** Reject foreign expression handles at the metadata boundary. */
+const compileSqlExpression = (client, expression) => {
+	if (!Statement$1.isFragment(expression) && !(expression instanceof SqlExpression) && !(expression instanceof Table) && !(expression instanceof Column)) throw PersistenceMappingError.make({
+		operation: "mapping",
+		cause: "Expected a SQL expression"
+	});
+	return value(client, expression);
+};
+const template = (parts, ...values) => new SqlExpression((client) => client.join("", false)(parts.flatMap((part, index) => index === 0 ? [client.literal(part)] : [value(client, values[index - 1]), client.literal(part)])));
+const sql = Object.assign(template, { join: (values, separator = template``) => new SqlExpression((client) => client.join("", false)(values.flatMap((input, index) => index === 0 ? [value(client, input)] : [separator.compile(client), value(client, input)]))) });
+const eq = (left, right) => sql`${left} = ${right}`;
+const and = (...expressions) => {
+	const present = expressions.filter((expression) => expression !== void 0);
+	return present.length === 0 ? void 0 : sql`(${sql.join(present, sql` AND `)})`;
+};
+//#endregion
+export { SqlExpression, and, compileSqlExpression, eq, sql };
+
+//# sourceMappingURL=sql-expression.mjs.map

package/dist/internal/sql-expression.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-expression.mjs","names":["Statement"],"sources":["../../src/internal/sql-expression.ts"],"sourcesContent":["import type { SqlClient } from \"effect/sql/SqlClient\";\nimport * as Statement from \"effect/sql/Statement\";\n\nimport { PersistenceMappingError } from \"./mapping-error\";\nimport { Column, identifier, Table } from \"./sql-table\";\n\n/** Pure mapped SQL. Compilation binds values through the executing client's\n * dialect; expressions neither acquire a client nor execute a query. */\nexport class SqlExpression {\n  constructor(readonly compile: (client: SqlClient) => Statement.Fragment) {}\n}\n\nconst quoted = (client: SqlClient, name: string) => {\n  if (name.includes(\"\\0\"))\n    throw PersistenceMappingError.make({ operation: \"mapping\", cause: \"NUL in SQL identifier\" });\n\n  return client.literal(identifier(name));\n};\n\nconst tableName = (client: SqlClient, name: string, schema?: string) =>\n  schema === undefined\n    ? quoted(client, name)\n    : client`${quoted(client, schema)}.${quoted(client, name)}`;\n\nconst value = (client: SqlClient, input: unknown): Statement.Fragment => {\n  if (Statement.isFragment(input)) return input;\n  if (input instanceof SqlExpression) return input.compile(client);\n  if (input instanceof Table) return tableName(client, input.name, input.schema);\n  if (input instanceof Column)\n    return client`${tableName(client, input.tableName, input.schema)}.${quoted(client, input.options.name)}`;\n\n  return Statement.fragment([\n    Statement.parameter(\n      typeof input === \"boolean\"\n        ? client.onDialectOrElse({ sqlite: () => Number(input), orElse: () => input })\n        : input,\n    ),\n  ]);\n};\n\n/** Reject foreign expression handles at the metadata boundary. */\nexport const compileSqlExpression = (\n  client: SqlClient,\n  expression: unknown,\n): Statement.Fragment => {\n  if (\n    !Statement.isFragment(expression) &&\n    !(expression instanceof SqlExpression) &&\n    !(expression instanceof Table) &&\n    !(expression instanceof Column)\n  )\n    throw PersistenceMappingError.make({\n      operation: \"mapping\",\n      cause: \"Expected a SQL expression\",\n    });\n\n  return value(client, expression);\n};\n\nconst template = (parts: TemplateStringsArray, ...values: ReadonlyArray<unknown>) =>\n  new SqlExpression((client) =>\n    client.join(\n      \"\",\n      false,\n    )(\n      parts.flatMap((part, index) =>\n        index === 0\n          ? [client.literal(part)]\n          : [value(client, values[index - 1]), client.literal(part)],\n      ),\n    ),\n  );\n\nexport const sql = Object.assign(template, {\n  join: (values: ReadonlyArray<unknown>, separator: SqlExpression = template``) =>\n    new SqlExpression((client) =>\n      client.join(\n        \"\",\n        false,\n      )(\n        values.flatMap((input, index) =>\n          index === 0 ? [value(client, input)] : [separator.compile(client), value(client, input)],\n        ),\n      ),\n    ),\n});\n\nexport const eq = (left: unknown, right: unknown): SqlExpression => sql`${left} = ${right}`;\n\nexport const and = (...expressions: ReadonlyArray<SqlExpression | undefined>) => {\n  const present = expressions.filter((expression) => expression !== undefined);\n\n  return present.length === 0 ? undefined : sql`(${sql.join(present, sql` AND `)})`;\n};\n"],"mappings":";;;;;;AAQA,IAAa,gBAAb,MAA2B;CACJ;CAArB,YAAY,SAA6D;EAApD,KAAA,UAAA;CAAqD;AAC5E;AAEA,MAAM,UAAU,QAAmB,SAAiB;CAClD,IAAI,KAAK,SAAS,IAAI,GACpB,MAAM,wBAAwB,KAAK;EAAE,WAAW;EAAW,OAAO;CAAwB,CAAC;CAE7F,OAAO,OAAO,QAAQ,WAAW,IAAI,CAAC;AACxC;AAEA,MAAM,aAAa,QAAmB,MAAc,WAClD,WAAW,KAAA,IACP,OAAO,QAAQ,IAAI,IACnB,MAAM,GAAG,OAAO,QAAQ,MAAM,EAAE,GAAG,OAAO,QAAQ,IAAI;AAE5D,MAAM,SAAS,QAAmB,UAAuC;CACvE,IAAIA,YAAU,WAAW,KAAK,GAAG,OAAO;CACxC,IAAI,iBAAiB,eAAe,OAAO,MAAM,QAAQ,MAAM;CAC/D,IAAI,iBAAiB,OAAO,OAAO,UAAU,QAAQ,MAAM,MAAM,MAAM,MAAM;CAC7E,IAAI,iBAAiB,QACnB,OAAO,MAAM,GAAG,UAAU,QAAQ,MAAM,WAAW,MAAM,MAAM,EAAE,GAAG,OAAO,QAAQ,MAAM,QAAQ,IAAI;CAEvG,OAAOA,YAAU,SAAS,CACxBA,YAAU,UACR,OAAO,UAAU,YACb,OAAO,gBAAgB;EAAE,cAAc,OAAO,KAAK;EAAG,cAAc;CAAM,CAAC,IAC3E,KACN,CACF,CAAC;AACH;;AAGA,MAAa,wBACX,QACA,eACuB;CACvB,IACE,CAACA,YAAU,WAAW,UAAU,KAChC,EAAE,sBAAsB,kBACxB,EAAE,sBAAsB,UACxB,EAAE,sBAAsB,SAExB,MAAM,wBAAwB,KAAK;EACjC,WAAW;EACX,OAAO;CACT,CAAC;CAEH,OAAO,MAAM,QAAQ,UAAU;AACjC;AAEA,MAAM,YAAY,OAA6B,GAAG,WAChD,IAAI,eAAe,WACjB,OAAO,KACL,IACA,KACF,CAAC,CACC,MAAM,SAAS,MAAM,UACnB,UAAU,IACN,CAAC,OAAO,QAAQ,IAAI,CAAC,IACrB,CAAC,MAAM,QAAQ,OAAO,QAAQ,EAAE,GAAG,OAAO,QAAQ,IAAI,CAAC,CAC7D,CACF,CACF;AAEF,MAAa,MAAM,OAAO,OAAO,UAAU,EACzC,OAAO,QAAgC,YAA2B,QAAQ,OACxE,IAAI,eAAe,WACjB,OAAO,KACL,IACA,KACF,CAAC,CACC,OAAO,SAAS,OAAO,UACrB,UAAU,IAAI,CAAC,MAAM,QAAQ,KAAK,CAAC,IAAI,CAAC,UAAU,QAAQ,MAAM,GAAG,MAAM,QAAQ,KAAK,CAAC,CACzF,CACF,CACF,EACJ,CAAC;AAED,MAAa,MAAM,MAAe,UAAkC,GAAG,GAAG,KAAK,KAAK;AAEpF,MAAa,OAAO,GAAG,gBAA0D;CAC/E,MAAM,UAAU,YAAY,QAAQ,eAAe,eAAe,KAAA,CAAS;CAE3E,OAAO,QAAQ,WAAW,IAAI,KAAA,IAAY,GAAG,IAAI,IAAI,KAAK,SAAS,GAAG,OAAO,EAAE;AACjF"}

package/dist/internal/sql-oauth-connected-model.d.mts

@@ -1,29 +1,13 @@
-import { OAuthConnectedAction, OAuthConnectedAdmissionTable as OAuthConnectedAdmissionTable$1, OAuthConnectedAuthorityMapping as OAuthConnectedAuthorityMapping$1, OAuthConnectedClientRegistrationTable as OAuthConnectedClientRegistrationTable$1, OAuthConnectedCohortTable as OAuthConnectedCohortTable$1, OAuthConnectedCommandTable as OAuthConnectedCommandTable$1, OAuthConnectedFlowTable as OAuthConnectedFlowTable$1, OAuthConnectedGrantTable as OAuthConnectedGrantTable$1, OAuthConnectedMapping as OAuthConnectedMapping$1, OAuthConnectedOrderCodec, OAuthConnectedOwnershipRead as OAuthConnectedOwnershipRead$1, OAuthConnectedPolicyGuard as OAuthConnectedPolicyGuard$1, OAuthConnectedPolicyGuardTable as OAuthConnectedPolicyGuardTable$1, OAuthConnectedPolicyInput, OAuthConnectedRevocationJobTable as OAuthConnectedRevocationJobTable$1, OAuthConnectedRevocationMapping as OAuthConnectedRevocationMapping$1, OAuthConnectedSqlPolicy as OAuthConnectedSqlPolicy$1, OAuthConnectedSubjectTable as OAuthConnectedSubjectTable$1, oauth_connected_model_d_exports, requiredOAuthConnectedConstraints, requiredOAuthConnectedRevocationConstraints } from "./models/oauth-connected-model.mjs";
-import { Fragment, Table } from "./sql-table.mjs";
+import { SqlExpression } from "./sql-expression.mjs";
+import { OAuthConnectedAction, OAuthConnectedGrantTable as OAuthConnectedGrantTable$1, OAuthConnectedMapping as OAuthConnectedMapping$1, OAuthConnectedPolicyInput, OAuthConnectedRevocationJobTable as OAuthConnectedRevocationJobTable$1, OAuthConnectedRevocationMapping as OAuthConnectedRevocationMapping$1, OAuthConnectedSqlPolicy as OAuthConnectedSqlPolicy$1, oauth_connected_model_d_exports, requiredOAuthConnectedConstraints, requiredOAuthConnectedRevocationConstraints } from "./models/oauth-connected-model.mjs";
+import { Table } from "./sql-table.mjs";
 import { SqlTableModel } from "./sql-oauth-model.mjs";
 //#region src/internal/sql-oauth-connected-model.d.ts
-export type OAuthConnectedSubjectTable<S extends Table> = OAuthConnectedSubjectTable$1<SqlTableModel<S>, Fragment>;
-export type OAuthConnectedFlowTable<F extends Table, N> = OAuthConnectedFlowTable$1<SqlTableModel<F>, N>;
 export type OAuthConnectedGrantTable<G extends Table, N> = OAuthConnectedGrantTable$1<SqlTableModel<G>, N>;
-/** Also stores a permanent provider/issuer scope anchor. clientKey must fit 52
- * ASCII characters. Empty clientRegistrationId is reserved for that anchor;
- * actual profile registrations are nonempty. Scope counter stays zero. */
-export type OAuthConnectedClientRegistrationTable<C extends Table> = OAuthConnectedClientRegistrationTable$1<SqlTableModel<C>>;
-/** Remote authority: no local-subject column or subject-scoped key. Retain this
- * anchor/cutoff when a legitimately released tuple gains a different local owner. */
-export type OAuthConnectedCohortTable<C extends Table> = OAuthConnectedCohortTable$1<SqlTableModel<C>>;
-export type OAuthConnectedAdmissionTable<A extends Table, N> = OAuthConnectedAdmissionTable$1<SqlTableModel<A>, N>;
-export type OAuthConnectedCommandTable<C extends Table, N> = OAuthConnectedCommandTable$1<SqlTableModel<C>, N>;
 export type OAuthConnectedRevocationJobTable<J extends Table, N> = OAuthConnectedRevocationJobTable$1<SqlTableModel<J>, N>;
-export type OAuthConnectedPolicyGuardTable<T extends Table, N> = OAuthConnectedPolicyGuardTable$1<SqlTableModel<T>, N, Fragment>;
-export type OAuthConnectedPolicyGuard<N> = OAuthConnectedPolicyGuard$1<N, Fragment, Table>;
-export declare const oauthConnectedPolicyGuard: <T extends Table, N>(input: OAuthConnectedPolicyGuardTable<T, N>) => OAuthConnectedPolicyGuard<N>;
-export type OAuthConnectedSqlPolicy<N> = OAuthConnectedSqlPolicy$1<N, Fragment, Table>;
-/** Existing ownership only; workers never allocate or acquire a tuple. */
-export type OAuthConnectedOwnershipRead<T extends Table, O extends Table, N> = OAuthConnectedOwnershipRead$1<SqlTableModel<T>, SqlTableModel<O>, N, Fragment>;
-export type OAuthConnectedAuthorityMapping<T extends Table, O extends Table, F extends Table, G extends Table, C extends Table, H extends Table, N> = OAuthConnectedAuthorityMapping$1<SqlTableModel<T>, SqlTableModel<O>, SqlTableModel<F>, SqlTableModel<G>, SqlTableModel<C>, SqlTableModel<H>, N, Fragment>;
-export type OAuthConnectedMapping<S extends Table, AC extends Table, T extends Table, O extends Table, F extends Table, G extends Table, C extends Table, H extends Table, A extends Table, D extends Table, N, J extends Table = never> = OAuthConnectedMapping$1<SqlTableModel<S>, SqlTableModel<AC>, SqlTableModel<T>, SqlTableModel<O>, SqlTableModel<F>, SqlTableModel<G>, SqlTableModel<C>, SqlTableModel<H>, SqlTableModel<A>, SqlTableModel<D>, N, SqlTableModel<J>, Fragment, Table, SqlTableModel<Table>>;
-export type OAuthConnectedRevocationMapping<T extends Table, O extends Table, F extends Table, G extends Table, C extends Table, H extends Table, J extends Table, N> = OAuthConnectedRevocationMapping$1<SqlTableModel<T>, SqlTableModel<O>, SqlTableModel<F>, SqlTableModel<G>, SqlTableModel<C>, SqlTableModel<H>, SqlTableModel<J>, N, Fragment>;
+export type OAuthConnectedSqlPolicy<N> = OAuthConnectedSqlPolicy$1<N, SqlExpression>;
+export type OAuthConnectedMapping<S extends Table, AC extends Table, O extends Table, F extends Table, G extends Table, N, J extends Table = Table> = OAuthConnectedMapping$1<SqlTableModel<S>, SqlTableModel<AC>, SqlTableModel<O>, SqlTableModel<F>, SqlTableModel<G>, N, SqlTableModel<J>, SqlExpression, SqlTableModel>;
+export type OAuthConnectedRevocationMapping<O extends Table, G extends Table, J extends Table, N> = OAuthConnectedRevocationMapping$1<SqlTableModel<O>, SqlTableModel<G>, SqlTableModel<J>, N, SqlExpression>;
 //#endregion
-export { type OAuthConnectedAction, type OAuthConnectedOrderCodec, type OAuthConnectedPolicyInput, requiredOAuthConnectedConstraints, requiredOAuthConnectedRevocationConstraints };
+export { type OAuthConnectedAction, type OAuthConnectedPolicyInput, requiredOAuthConnectedConstraints, requiredOAuthConnectedRevocationConstraints };
 //# sourceMappingURL=sql-oauth-connected-model.d.mts.map

package/dist/internal/sql-oauth-model.d.mts

@@ -1,60 +1,35 @@
-import { TableModel } from "./query-operations.mjs";
-import { OAuthAccountsMapping as OAuthAccountsMapping$1, OAuthAction, OAuthAuthorityReadTable as OAuthAuthorityReadTable$1, OAuthAuthorityTable as OAuthAuthorityTable$1, OAuthCleanupDescriptor as OAuthCleanupDescriptor$1, OAuthCleanupTable as OAuthCleanupTable$1, OAuthClock as OAuthClock$1, OAuthCredentialReadTable as OAuthCredentialReadTable$1, OAuthCredentialTable as OAuthCredentialTable$1, OAuthD1Mapping, OAuthEligibilityDescriptor as OAuthEligibilityDescriptor$1, OAuthEligibilityFact, OAuthEligibilityTable as OAuthEligibilityTable$1, OAuthFlowState, OAuthFlowTable as OAuthFlowTable$1, OAuthMetadataPolicy as OAuthMetadataPolicy$1, OAuthOwnershipMutation as OAuthOwnershipMutation$1, OAuthOwnershipReadTable as OAuthOwnershipReadTable$1, OAuthOwnershipTable as OAuthOwnershipTable$1, OAuthReferenceGuardDescriptor as OAuthReferenceGuardDescriptor$1, OAuthReferenceGuardTable as OAuthReferenceGuardTable$1, OAuthRegistrationAuthority, OAuthRegistrationBase as OAuthRegistrationBase$1, OAuthRegistrationCommandTable as OAuthRegistrationCommandTable$1, OAuthRegistrationEligibility as OAuthRegistrationEligibility$1, OAuthRegistrationGuardDescriptor as OAuthRegistrationGuardDescriptor$1, OAuthRegistrationGuardTable as OAuthRegistrationGuardTable$1, OAuthRegistrationIntentMapping as OAuthRegistrationIntentMapping$1, OAuthRegistrationIntentTable as OAuthRegistrationIntentTable$1, OAuthRegistrationMapping as OAuthRegistrationMapping$1, OAuthRegistrationState, OAuthSignInMapping as OAuthSignInMapping$1, OAuthSubjectReadTable as OAuthSubjectReadTable$1, OAuthSubjectTable as OAuthSubjectTable$1, OAuthTupleAuthorityTable as OAuthTupleAuthorityTable$1, OAuthTupleState, OAuthUnlinkCommandTable as OAuthUnlinkCommandTable$1, oauth_model_d_exports, requiredOAuthAccountsConstraints, requiredOAuthRegistrationConstraints, requiredOAuthSignInConstraints, requiredOAuthTupleConstraints } from "./models/oauth-model.mjs";
-import { Fragment, Table } from "./sql-table.mjs";
+import { SqlExpression } from "./sql-expression.mjs";
+import { TableModel } from "./table-model.mjs";
+import { OAuthAccountsMapping as OAuthAccountsMapping$1, OAuthAction, OAuthAuthorityReadTable as OAuthAuthorityReadTable$1, OAuthAuthorityTable as OAuthAuthorityTable$1, OAuthCleanupDescriptor as OAuthCleanupDescriptor$1, OAuthCleanupTable as OAuthCleanupTable$1, OAuthClock as OAuthClock$1, OAuthCredentialReadTable as OAuthCredentialReadTable$1, OAuthCredentialTable as OAuthCredentialTable$1, OAuthD1Mapping, OAuthEligibilityDescriptor as OAuthEligibilityDescriptor$1, OAuthEligibilityFact, OAuthEligibilityTable as OAuthEligibilityTable$1, OAuthFlowTable as OAuthFlowTable$1, OAuthOwnershipReadTable as OAuthOwnershipReadTable$1, OAuthOwnershipTable as OAuthOwnershipTable$1, OAuthRegistrationAuthority, OAuthRegistrationGuardDescriptor as OAuthRegistrationGuardDescriptor$1, OAuthRegistrationGuardTable as OAuthRegistrationGuardTable$1, OAuthRegistrationIntentMapping as OAuthRegistrationIntentMapping$1, OAuthRegistrationIntentTable as OAuthRegistrationIntentTable$1, OAuthRegistrationMapping as OAuthRegistrationMapping$1, OAuthSignInMapping as OAuthSignInMapping$1, OAuthSubjectReadTable as OAuthSubjectReadTable$1, OAuthSubjectTable as OAuthSubjectTable$1, oauth_model_d_exports, requiredOAuthRegistrationConstraints, requiredOAuthSignInConstraints } from "./models/oauth-model.mjs";
+import { Table } from "./sql-table.mjs";
 //#region src/internal/sql-oauth-model.d.ts
 export interface SqlTableModel<T extends Table = Table> extends TableModel {
   readonly table: T;
 }
-/** The engine writes every critical column explicitly after applying the pure
- * consumer encoder. Native instant values must roundtrip without precision loss. */
-export type OAuthClock = OAuthClock$1<Fragment>;
-export type OAuthSubjectReadTable<S extends Table> = OAuthSubjectReadTable$1<SqlTableModel<S>, Fragment>;
-export type OAuthSubjectTable<S extends Table> = OAuthSubjectTable$1<SqlTableModel<S>, Fragment>;
-export type OAuthOwnershipReadTable<O extends Table, N> = OAuthOwnershipReadTable$1<SqlTableModel<O>, N, Fragment>;
-export type OAuthOwnershipTable<O extends Table, N> = OAuthOwnershipTable$1<SqlTableModel<O>, N, Fragment>;
-export type OAuthCredentialReadTable<C extends Table> = OAuthCredentialReadTable$1<SqlTableModel<C>, Fragment>;
-export type OAuthCredentialTable<C extends Table, N> = OAuthCredentialTable$1<SqlTableModel<C>, N, Fragment>;
-export type OAuthAuthorityReadTable<C extends Table> = OAuthAuthorityReadTable$1<SqlTableModel<C>, Fragment>;
-export type OAuthAuthorityTable<C extends Table, N> = OAuthAuthorityTable$1<SqlTableModel<C>, N, Fragment>;
-/** Both purposes may use the same physical table. Shared tables share module/flow
- * and module/command uniqueness. The snapshot has the exact purpose-specific core
- * codec; terminal writes erase it, while identity, claim and retention columns remain. */
+export type OAuthClock = OAuthClock$1<SqlExpression>;
+export type OAuthSubjectReadTable<S extends Table> = OAuthSubjectReadTable$1<SqlTableModel<S>, SqlExpression>;
+export type OAuthSubjectTable<S extends Table> = OAuthSubjectTable$1<SqlTableModel<S>, SqlExpression>;
+export type OAuthOwnershipReadTable<O extends Table, N> = OAuthOwnershipReadTable$1<SqlTableModel<O>, N>;
+export type OAuthOwnershipTable<O extends Table, N> = OAuthOwnershipTable$1<SqlTableModel<O>, N>;
+export type OAuthCredentialReadTable<C extends Table> = OAuthCredentialReadTable$1<SqlTableModel<C>, SqlExpression>;
+export type OAuthCredentialTable<C extends Table, N> = OAuthCredentialTable$1<SqlTableModel<C>, N, SqlExpression>;
+export type OAuthAuthorityReadTable<C extends Table> = OAuthAuthorityReadTable$1<SqlTableModel<C>, SqlExpression>;
+export type OAuthAuthorityTable<C extends Table, N> = OAuthAuthorityTable$1<SqlTableModel<C>, N, SqlExpression>;
 export type OAuthFlowTable<F extends Table> = OAuthFlowTable$1<SqlTableModel<F>>;
-export type OAuthTupleAuthorityTable<T extends Table, N> = OAuthTupleAuthorityTable$1<SqlTableModel<T>, N>;
 export type OAuthRegistrationIntentTable<I extends Table> = OAuthRegistrationIntentTable$1<SqlTableModel<I>>;
-export type OAuthRegistrationCommandTable<R extends Table, Registration> = OAuthRegistrationCommandTable$1<SqlTableModel<R>, Registration>;
-export type OAuthUnlinkCommandTable<U extends Table> = OAuthUnlinkCommandTable$1<SqlTableModel<U>>;
-/** Each descriptor reads only its own subject-scoped method rows. The native row
- * projector and SQL condition must express the same installed method eligibility.
- * All source/identifier/policy mutations advance subject securityRevision. D1 also
- * guards exact selected IDs/versions and absence/count assumptions, never just a
- * stale boolean. An over-limit graph fails closed rather than truncating. */
-export type OAuthEligibilityTable<T extends Table, N> = OAuthEligibilityTable$1<SqlTableModel<T>, N, Fragment>;
-/** Authenticated command replay uses current subject status and this additional
- * nonconsuming SQL policy. It never consumes a fresh action factor. */
-export type OAuthMetadataPolicy<N> = OAuthMetadataPolicy$1<N, Fragment>;
-export type OAuthCleanupTable<T extends Table, N> = OAuthCleanupTable$1<SqlTableModel<T>, N, Fragment>;
-export type OAuthRegistrationEligibility<N> = OAuthRegistrationEligibility$1<N, Fragment>;
-export type OAuthSignInMapping<S extends Table, O extends Table, C extends Table, AC extends Table, F extends Table, N> = OAuthSignInMapping$1<SqlTableModel<S>, SqlTableModel<O>, SqlTableModel<C>, SqlTableModel<AC>, SqlTableModel<F>, N, Fragment>;
-export type OAuthOwnershipMutation<T extends Table, O extends Table, N> = OAuthOwnershipMutation$1<SqlTableModel<T>, SqlTableModel<O>, N, Fragment>;
-export type OAuthRegistrationIntentMapping<S extends Table, O extends Table, C extends Table, AC extends Table, F extends Table, T extends Table, I extends Table, N> = OAuthRegistrationIntentMapping$1<SqlTableModel<S>, SqlTableModel<O>, SqlTableModel<C>, SqlTableModel<AC>, SqlTableModel<F>, SqlTableModel<T>, SqlTableModel<I>, N, Fragment>;
-export type OAuthRegistrationBase<Registration, T extends Table, O extends Table, I extends Table, R extends Table, N> = OAuthRegistrationBase$1<Registration, SqlTableModel<T>, SqlTableModel<O>, SqlTableModel<I>, SqlTableModel<R>, N, Fragment, Table>;
-export type OAuthRegistrationGuardTable<T extends Table, Registration, N> = OAuthRegistrationGuardTable$1<SqlTableModel<T>, Registration, N, Fragment>;
-export type OAuthRegistrationGuardDescriptor<Registration, N> = OAuthRegistrationGuardDescriptor$1<Registration, N, Fragment, Table>;
-export declare const oauthRegistrationGuardTable: <T extends Table, Registration, N>(input: OAuthRegistrationGuardTable<T, Registration, N>) => OAuthRegistrationGuardDescriptor<Registration, N>;
-export type OAuthRegistrationMapping<Registration, S extends Table, O extends Table, C extends Table, AC extends Table, T extends Table, I extends Table, R extends Table, N> = OAuthRegistrationMapping$1<Registration, SqlTableModel<S>, SqlTableModel<O>, SqlTableModel<C>, SqlTableModel<AC>, SqlTableModel<T>, SqlTableModel<I>, SqlTableModel<R>, N, Fragment, Table>;
-/** Heterogeneous descriptors are made by typed factories and projected privately. */
-export type OAuthEligibilityDescriptor<N> = OAuthEligibilityDescriptor$1<N, Fragment, Table>;
-export declare const oauthEligibilityTable: <T extends Table, N>(input: OAuthEligibilityTable<T, N>) => OAuthEligibilityDescriptor<N>;
-export type OAuthCleanupDescriptor<N> = OAuthCleanupDescriptor$1<N, Fragment, Table>;
-export declare const oauthCleanupTable: <T extends Table, N>(input: OAuthCleanupTable<T, N>) => OAuthCleanupDescriptor<N>;
-/** A stable application/reference lock acquired before an ownership target.
- * Missing rows retain ownership. Conditions use detached native IDs; every
- * writer of the guarded reference follows the same order. */
-export type OAuthReferenceGuardTable<T extends Table, N> = OAuthReferenceGuardTable$1<SqlTableModel<T>, N, Fragment>;
-export type OAuthReferenceGuardDescriptor<N> = OAuthReferenceGuardDescriptor$1<N, Fragment, Table>;
-export declare const oauthReferenceGuardTable: <T extends Table, N>(input: OAuthReferenceGuardTable<T, N>) => OAuthReferenceGuardDescriptor<N>;
-export type OAuthAccountsMapping<S extends Table, O extends Table, C extends Table, AC extends Table, F extends Table, T extends Table, U extends Table, N> = OAuthAccountsMapping$1<SqlTableModel<S>, SqlTableModel<O>, SqlTableModel<C>, SqlTableModel<AC>, SqlTableModel<F>, SqlTableModel<T>, SqlTableModel<U>, N, Fragment, Table>;
+export type OAuthEligibilityTable<T extends Table, N> = OAuthEligibilityTable$1<SqlTableModel<T>, N, SqlExpression>;
+export type OAuthCleanupTable<T extends Table, N> = OAuthCleanupTable$1<SqlTableModel<T>, N, SqlExpression>;
+export type OAuthRegistrationGuardTable<T extends Table, Registration, N> = OAuthRegistrationGuardTable$1<SqlTableModel<T>, Registration, N, SqlExpression>;
+export type OAuthRegistrationGuardDescriptor<Registration, N> = OAuthRegistrationGuardDescriptor$1<Registration, N, SqlExpression, Table>;
+export type OAuthEligibilityDescriptor<N> = OAuthEligibilityDescriptor$1<N, SqlExpression, Table>;
+export type OAuthCleanupDescriptor<N> = OAuthCleanupDescriptor$1<N, SqlExpression, Table>;
+export type OAuthSignInMapping<S extends Table, O extends Table, C extends Table, AC extends Table, F extends Table, N> = OAuthSignInMapping$1<SqlTableModel<S>, SqlTableModel<O>, SqlTableModel<C>, SqlTableModel<AC>, SqlTableModel<F>, N, SqlExpression>;
+export type OAuthAccountsMapping<S extends Table, O extends Table, C extends Table, AC extends Table, F extends Table, N> = OAuthAccountsMapping$1<SqlTableModel<S>, SqlTableModel<O>, SqlTableModel<C>, SqlTableModel<AC>, SqlTableModel<F>, N, SqlExpression, Table>;
+export type OAuthRegistrationIntentMapping<O extends Table, I extends Table, N> = OAuthRegistrationIntentMapping$1<SqlTableModel<O>, SqlTableModel<I>, N, SqlExpression>;
+export type OAuthRegistrationMapping<Registration, S extends Table, O extends Table, C extends Table, AC extends Table, I extends Table, N> = OAuthRegistrationMapping$1<Registration, SqlTableModel<S>, SqlTableModel<O>, SqlTableModel<C>, SqlTableModel<AC>, SqlTableModel<I>, N, SqlExpression, Table>;
+export declare const oauthEligibilityTable: <T extends Table, N>(input: OAuthEligibilityTable<T, N>) => OAuthEligibilityDescriptor$1<N, SqlExpression, T>;
+export declare const oauthCleanupTable: <T extends Table, N>(input: OAuthCleanupTable<T, N>) => OAuthCleanupDescriptor$1<N, SqlExpression, T>;
+export declare const oauthRegistrationGuardTable: <T extends Table, Registration, N>(input: OAuthRegistrationGuardTable<T, Registration, N>) => OAuthRegistrationGuardDescriptor$1<Registration, N, SqlExpression, T>;
 //#endregion
-export { type OAuthAction, type OAuthD1Mapping, type OAuthEligibilityFact, type OAuthFlowState, type OAuthRegistrationAuthority, type OAuthRegistrationState, type OAuthTupleState, requiredOAuthAccountsConstraints, requiredOAuthRegistrationConstraints, requiredOAuthSignInConstraints, requiredOAuthTupleConstraints };
+export { type OAuthAction, type OAuthD1Mapping, type OAuthEligibilityFact, type OAuthRegistrationAuthority, requiredOAuthRegistrationConstraints, requiredOAuthSignInConstraints };
 //# sourceMappingURL=sql-oauth-model.d.mts.map

package/dist/internal/sql-oauth-model.mjs

@@ -1,10 +1,9 @@
-import { oauthCleanupTable as oauthCleanupTable$1, oauthEligibilityTable as oauthEligibilityTable$1, oauthReferenceGuardTable as oauthReferenceGuardTable$1, oauthRegistrationGuardTable as oauthRegistrationGuardTable$1, requiredOAuthAccountsConstraints, requiredOAuthRegistrationConstraints, requiredOAuthSignInConstraints, requiredOAuthTupleConstraints } from "./models/oauth-model.mjs";
+import { oauthCleanupTable as oauthCleanupTable$1, oauthEligibilityTable as oauthEligibilityTable$1, oauthRegistrationGuardTable as oauthRegistrationGuardTable$1, requiredOAuthRegistrationConstraints, requiredOAuthSignInConstraints } from "./models/oauth-model.mjs";
 //#region src/internal/sql-oauth-model.ts
-const oauthRegistrationGuardTable = (input) => oauthRegistrationGuardTable$1(input);
 const oauthEligibilityTable = (input) => oauthEligibilityTable$1(input);
 const oauthCleanupTable = (input) => oauthCleanupTable$1(input);
-const oauthReferenceGuardTable = (input) => oauthReferenceGuardTable$1(input);
+const oauthRegistrationGuardTable = (input) => oauthRegistrationGuardTable$1(input);
 //#endregion
-export { oauthCleanupTable, oauthEligibilityTable, oauthReferenceGuardTable, oauthRegistrationGuardTable, requiredOAuthAccountsConstraints, requiredOAuthRegistrationConstraints, requiredOAuthSignInConstraints, requiredOAuthTupleConstraints };
+export { oauthCleanupTable, oauthEligibilityTable, oauthRegistrationGuardTable, requiredOAuthRegistrationConstraints, requiredOAuthSignInConstraints };
 
 //# sourceMappingURL=sql-oauth-model.mjs.map

package/dist/internal/sql-oauth-model.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"sql-oauth-model.mjs","names":["Shared.oauthRegistrationGuardTable","Shared.oauthEligibilityTable","Shared.oauthCleanupTable","Shared.oauthReferenceGuardTable"],"sources":["../../src/internal/sql-oauth-model.ts"],"sourcesContent":["import * as Shared from \"./models/oauth-model\";\nimport type { TableModel } from \"./query-operations\";\nimport type { Fragment as SQL, Table } from \"./sql-table\";\n\nexport interface SqlTableModel<T extends Table = Table> extends TableModel {\n  readonly table: T;\n}\n\nexport {\n  type OAuthFlowState,\n  type OAuthTupleState,\n  type OAuthRegistrationState,\n  type OAuthAction,\n  type OAuthEligibilityFact,\n  type OAuthD1Mapping,\n  requiredOAuthSignInConstraints,\n  requiredOAuthTupleConstraints,\n  requiredOAuthRegistrationConstraints,\n  requiredOAuthAccountsConstraints,\n  type OAuthRegistrationAuthority,\n} from \"./models/oauth-model\";\n\n/** The engine writes every critical column explicitly after applying the pure\n * consumer encoder. Native instant values must roundtrip without precision loss. */\nexport type OAuthClock = Shared.OAuthClock<SQL>;\n\nexport type OAuthSubjectReadTable<S extends Table> = Shared.OAuthSubjectReadTable<\n  SqlTableModel<S>,\n  SQL\n>;\n\nexport type OAuthSubjectTable<S extends Table> = Shared.OAuthSubjectTable<SqlTableModel<S>, SQL>;\n\nexport type OAuthOwnershipReadTable<O extends Table, N> = Shared.OAuthOwnershipReadTable<\n  SqlTableModel<O>,\n  N,\n  SQL\n>;\n\nexport type OAuthOwnershipTable<O extends Table, N> = Shared.OAuthOwnershipTable<\n  SqlTableModel<O>,\n  N,\n  SQL\n>;\n\nexport type OAuthCredentialReadTable<C extends Table> = Shared.OAuthCredentialReadTable<\n  SqlTableModel<C>,\n  SQL\n>;\n\nexport type OAuthCredentialTable<C extends Table, N> = Shared.OAuthCredentialTable<\n  SqlTableModel<C>,\n  N,\n  SQL\n>;\n\nexport type OAuthAuthorityReadTable<C extends Table> = Shared.OAuthAuthorityReadTable<\n  SqlTableModel<C>,\n  SQL\n>;\n\nexport type OAuthAuthorityTable<C extends Table, N> = Shared.OAuthAuthorityTable<\n  SqlTableModel<C>,\n  N,\n  SQL\n>;\n\n/** Both purposes may use the same physical table. Shared tables share module/flow\n * and module/command uniqueness. The snapshot has the exact purpose-specific core\n * codec; terminal writes erase it, while identity, claim and retention columns remain. */\nexport type OAuthFlowTable<F extends Table> = Shared.OAuthFlowTable<SqlTableModel<F>>;\n\nexport type OAuthTupleAuthorityTable<T extends Table, N> = Shared.OAuthTupleAuthorityTable<\n  SqlTableModel<T>,\n  N\n>;\n\nexport type OAuthRegistrationIntentTable<I extends Table> = Shared.OAuthRegistrationIntentTable<\n  SqlTableModel<I>\n>;\n\nexport type OAuthRegistrationCommandTable<\n  R extends Table,\n  Registration,\n> = Shared.OAuthRegistrationCommandTable<SqlTableModel<R>, Registration>;\n\nexport type OAuthUnlinkCommandTable<U extends Table> = Shared.OAuthUnlinkCommandTable<\n  SqlTableModel<U>\n>;\n\n/** Each descriptor reads only its own subject-scoped method rows. The native row\n * projector and SQL condition must express the same installed method eligibility.\n * All source/identifier/policy mutations advance subject securityRevision. D1 also\n * guards exact selected IDs/versions and absence/count assumptions, never just a\n * stale boolean. An over-limit graph fails closed rather than truncating. */\nexport type OAuthEligibilityTable<T extends Table, N> = Shared.OAuthEligibilityTable<\n  SqlTableModel<T>,\n  N,\n  SQL\n>;\n\n/** Authenticated command replay uses current subject status and this additional\n * nonconsuming SQL policy. It never consumes a fresh action factor. */\nexport type OAuthMetadataPolicy<N> = Shared.OAuthMetadataPolicy<N, SQL>;\n\nexport type OAuthCleanupTable<T extends Table, N> = Shared.OAuthCleanupTable<\n  SqlTableModel<T>,\n  N,\n  SQL\n>;\n\nexport type OAuthRegistrationEligibility<N> = Shared.OAuthRegistrationEligibility<N, SQL>;\n\nexport type OAuthSignInMapping<\n  S extends Table,\n  O extends Table,\n  C extends Table,\n  AC extends Table,\n  F extends Table,\n  N,\n> = Shared.OAuthSignInMapping<\n  SqlTableModel<S>,\n  SqlTableModel<O>,\n  SqlTableModel<C>,\n  SqlTableModel<AC>,\n  SqlTableModel<F>,\n  N,\n  SQL\n>;\n\nexport type OAuthOwnershipMutation<\n  T extends Table,\n  O extends Table,\n  N,\n> = Shared.OAuthOwnershipMutation<SqlTableModel<T>, SqlTableModel<O>, N, SQL>;\n\nexport type OAuthRegistrationIntentMapping<\n  S extends Table,\n  O extends Table,\n  C extends Table,\n  AC extends Table,\n  F extends Table,\n  T extends Table,\n  I extends Table,\n  N,\n> = Shared.OAuthRegistrationIntentMapping<\n  SqlTableModel<S>,\n  SqlTableModel<O>,\n  SqlTableModel<C>,\n  SqlTableModel<AC>,\n  SqlTableModel<F>,\n  SqlTableModel<T>,\n  SqlTableModel<I>,\n  N,\n  SQL\n>;\n\nexport type OAuthRegistrationBase<\n  Registration,\n  T extends Table,\n  O extends Table,\n  I extends Table,\n  R extends Table,\n  N,\n> = Shared.OAuthRegistrationBase<\n  Registration,\n  SqlTableModel<T>,\n  SqlTableModel<O>,\n  SqlTableModel<I>,\n  SqlTableModel<R>,\n  N,\n  SQL,\n  Table\n>;\n\nexport type OAuthRegistrationGuardTable<\n  T extends Table,\n  Registration,\n  N,\n> = Shared.OAuthRegistrationGuardTable<SqlTableModel<T>, Registration, N, SQL>;\n\nexport type OAuthRegistrationGuardDescriptor<Registration, N> =\n  Shared.OAuthRegistrationGuardDescriptor<Registration, N, SQL, Table>;\n\nexport const oauthRegistrationGuardTable = <T extends Table, Registration, N>(\n  input: OAuthRegistrationGuardTable<T, Registration, N>,\n): OAuthRegistrationGuardDescriptor<Registration, N> =>\n  Shared.oauthRegistrationGuardTable<SqlTableModel<T>, Registration, N, SQL>(input);\n\nexport type OAuthRegistrationMapping<\n  Registration,\n  S extends Table,\n  O extends Table,\n  C extends Table,\n  AC extends Table,\n  T extends Table,\n  I extends Table,\n  R extends Table,\n  N,\n> = Shared.OAuthRegistrationMapping<\n  Registration,\n  SqlTableModel<S>,\n  SqlTableModel<O>,\n  SqlTableModel<C>,\n  SqlTableModel<AC>,\n  SqlTableModel<T>,\n  SqlTableModel<I>,\n  SqlTableModel<R>,\n  N,\n  SQL,\n  Table\n>;\n\n/** Heterogeneous descriptors are made by typed factories and projected privately. */\nexport type OAuthEligibilityDescriptor<N> = Shared.OAuthEligibilityDescriptor<N, SQL, Table>;\n\nexport const oauthEligibilityTable = <T extends Table, N>(\n  input: OAuthEligibilityTable<T, N>,\n): OAuthEligibilityDescriptor<N> => Shared.oauthEligibilityTable<SqlTableModel<T>, N, SQL>(input);\n\nexport type OAuthCleanupDescriptor<N> = Shared.OAuthCleanupDescriptor<N, SQL, Table>;\n\nexport const oauthCleanupTable = <T extends Table, N>(\n  input: OAuthCleanupTable<T, N>,\n): OAuthCleanupDescriptor<N> => Shared.oauthCleanupTable<SqlTableModel<T>, N, SQL>(input);\n\n/** A stable application/reference lock acquired before an ownership target.\n * Missing rows retain ownership. Conditions use detached native IDs; every\n * writer of the guarded reference follows the same order. */\nexport type OAuthReferenceGuardTable<T extends Table, N> = Shared.OAuthReferenceGuardTable<\n  SqlTableModel<T>,\n  N,\n  SQL\n>;\n\nexport type OAuthReferenceGuardDescriptor<N> = Shared.OAuthReferenceGuardDescriptor<N, SQL, Table>;\n\nexport const oauthReferenceGuardTable = <T extends Table, N>(\n  input: OAuthReferenceGuardTable<T, N>,\n): OAuthReferenceGuardDescriptor<N> =>\n  Shared.oauthReferenceGuardTable<SqlTableModel<T>, N, SQL>(input);\n\nexport type OAuthAccountsMapping<\n  S extends Table,\n  O extends Table,\n  C extends Table,\n  AC extends Table,\n  F extends Table,\n  T extends Table,\n  U extends Table,\n  N,\n> = Shared.OAuthAccountsMapping<\n  SqlTableModel<S>,\n  SqlTableModel<O>,\n  SqlTableModel<C>,\n  SqlTableModel<AC>,\n  SqlTableModel<F>,\n  SqlTableModel<T>,\n  SqlTableModel<U>,\n  N,\n  SQL,\n  Table\n>;\n"],"mappings":";;AAwLA,MAAa,+BACX,UAEAA,8BAA2E,KAAK;AA6BlF,MAAa,yBACX,UACkCC,wBAAuD,KAAK;AAIhG,MAAa,qBACX,UAC8BC,oBAAmD,KAAK;AAaxF,MAAa,4BACX,UAEAC,2BAA0D,KAAK"}
+{"version":3,"file":"sql-oauth-model.mjs","names":["Shared.oauthEligibilityTable","Shared.oauthCleanupTable","Shared.oauthRegistrationGuardTable"],"sources":["../../src/internal/sql-oauth-model.ts"],"sourcesContent":["import * as Shared from \"./models/oauth-model\";\nimport type { SqlExpression as SQL } from \"./sql-expression\";\nimport type { Table } from \"./sql-table\";\nimport type { TableModel } from \"./table-model\";\n\nexport interface SqlTableModel<T extends Table = Table> extends TableModel {\n  readonly table: T;\n}\n\nexport {\n  type OAuthAction,\n  type OAuthEligibilityFact,\n  type OAuthD1Mapping,\n  type OAuthRegistrationAuthority,\n  requiredOAuthSignInConstraints,\n  requiredOAuthRegistrationConstraints,\n} from \"./models/oauth-model\";\n\nexport type OAuthClock = Shared.OAuthClock<SQL>;\n\nexport type OAuthSubjectReadTable<S extends Table> = Shared.OAuthSubjectReadTable<\n  SqlTableModel<S>,\n  SQL\n>;\n\nexport type OAuthSubjectTable<S extends Table> = Shared.OAuthSubjectTable<SqlTableModel<S>, SQL>;\n\nexport type OAuthOwnershipReadTable<O extends Table, N> = Shared.OAuthOwnershipReadTable<\n  SqlTableModel<O>,\n  N\n>;\n\nexport type OAuthOwnershipTable<O extends Table, N> = Shared.OAuthOwnershipTable<\n  SqlTableModel<O>,\n  N\n>;\n\nexport type OAuthCredentialReadTable<C extends Table> = Shared.OAuthCredentialReadTable<\n  SqlTableModel<C>,\n  SQL\n>;\n\nexport type OAuthCredentialTable<C extends Table, N> = Shared.OAuthCredentialTable<\n  SqlTableModel<C>,\n  N,\n  SQL\n>;\n\nexport type OAuthAuthorityReadTable<C extends Table> = Shared.OAuthAuthorityReadTable<\n  SqlTableModel<C>,\n  SQL\n>;\n\nexport type OAuthAuthorityTable<C extends Table, N> = Shared.OAuthAuthorityTable<\n  SqlTableModel<C>,\n  N,\n  SQL\n>;\n\nexport type OAuthFlowTable<F extends Table> = Shared.OAuthFlowTable<SqlTableModel<F>>;\n\nexport type OAuthRegistrationIntentTable<I extends Table> = Shared.OAuthRegistrationIntentTable<\n  SqlTableModel<I>\n>;\n\nexport type OAuthEligibilityTable<T extends Table, N> = Shared.OAuthEligibilityTable<\n  SqlTableModel<T>,\n  N,\n  SQL\n>;\n\nexport type OAuthCleanupTable<T extends Table, N> = Shared.OAuthCleanupTable<\n  SqlTableModel<T>,\n  N,\n  SQL\n>;\n\nexport type OAuthRegistrationGuardTable<\n  T extends Table,\n  Registration,\n  N,\n> = Shared.OAuthRegistrationGuardTable<SqlTableModel<T>, Registration, N, SQL>;\n\nexport type OAuthRegistrationGuardDescriptor<Registration, N> =\n  Shared.OAuthRegistrationGuardDescriptor<Registration, N, SQL, Table>;\n\nexport type OAuthEligibilityDescriptor<N> = Shared.OAuthEligibilityDescriptor<N, SQL, Table>;\n\nexport type OAuthCleanupDescriptor<N> = Shared.OAuthCleanupDescriptor<N, SQL, Table>;\n\nexport type OAuthSignInMapping<\n  S extends Table,\n  O extends Table,\n  C extends Table,\n  AC extends Table,\n  F extends Table,\n  N,\n> = Shared.OAuthSignInMapping<\n  SqlTableModel<S>,\n  SqlTableModel<O>,\n  SqlTableModel<C>,\n  SqlTableModel<AC>,\n  SqlTableModel<F>,\n  N,\n  SQL\n>;\n\nexport type OAuthAccountsMapping<\n  S extends Table,\n  O extends Table,\n  C extends Table,\n  AC extends Table,\n  F extends Table,\n  N,\n> = Shared.OAuthAccountsMapping<\n  SqlTableModel<S>,\n  SqlTableModel<O>,\n  SqlTableModel<C>,\n  SqlTableModel<AC>,\n  SqlTableModel<F>,\n  N,\n  SQL,\n  Table\n>;\n\nexport type OAuthRegistrationIntentMapping<\n  O extends Table,\n  I extends Table,\n  N,\n> = Shared.OAuthRegistrationIntentMapping<SqlTableModel<O>, SqlTableModel<I>, N, SQL>;\n\nexport type OAuthRegistrationMapping<\n  Registration,\n  S extends Table,\n  O extends Table,\n  C extends Table,\n  AC extends Table,\n  I extends Table,\n  N,\n> = Shared.OAuthRegistrationMapping<\n  Registration,\n  SqlTableModel<S>,\n  SqlTableModel<O>,\n  SqlTableModel<C>,\n  SqlTableModel<AC>,\n  SqlTableModel<I>,\n  N,\n  SQL,\n  Table\n>;\n\nexport const oauthEligibilityTable = <T extends Table, N>(input: OAuthEligibilityTable<T, N>) =>\n  Shared.oauthEligibilityTable<SqlTableModel<T>, N, SQL>(input);\n\nexport const oauthCleanupTable = <T extends Table, N>(input: OAuthCleanupTable<T, N>) =>\n  Shared.oauthCleanupTable<SqlTableModel<T>, N, SQL>(input);\n\nexport const oauthRegistrationGuardTable = <T extends Table, Registration, N>(\n  input: OAuthRegistrationGuardTable<T, Registration, N>,\n) => Shared.oauthRegistrationGuardTable<SqlTableModel<T>, Registration, N, SQL>(input);\n"],"mappings":";;AAuJA,MAAa,yBAA6C,UACxDA,wBAAuD,KAAK;AAE9D,MAAa,qBAAyC,UACpDC,oBAAmD,KAAK;AAE1D,MAAa,+BACX,UACGC,8BAA2E,KAAK"}