@yielded/auth 0.1.0-beta.1

package/dist/hooks/commit.mjs

@@ -0,0 +1,136 @@
+import { HookConfigurationError, lifecycleEvent } from "./models.mjs";
+import { LifecycleHooks } from "./LifecycleHooks.mjs";
+import { validateContributions } from "./transactions.mjs";
+import { Cause, Context, Effect, Option, Schema } from "effect";
+//#region src/hooks/commit.ts
+var CommitPending = class extends Schema.TaggedError()("CommitPending", {}) {};
+var CommitDiscarded = class extends Schema.TaggedError()("CommitDiscarded", {}) {};
+/** Current journal for internal transaction operations. Public commit-owner
+* continuations still receive the journal explicitly at the native boundary. */
+var CurrentCommitJournal = class extends Context.Service()("effect-auth/hooks/CurrentCommitJournal") {};
+var CurrentCommit = class extends Context.Service()("effect-auth/hooks/CurrentCommit") {};
+/** Public operations may reject unsupported ambient execution before any mutation. */
+const hasCommitScope = Effect.serviceOption(CurrentCommit).pipe(Effect.map(Option.isSome));
+/**
+* `owner` must resolve only after its real transaction or batch commits. Nested
+* calls inherit the outer journal; their events are discarded on failure and
+* cannot dispatch until the outermost owner succeeds. Wrap a caught savepoint
+* rollback in its own coordinateCommit call so its events are discarded too.
+* Direct delivery is best effort: a process crash loses staged memory and no
+* retry is automatic. Once the owner returns, interruption is masked during
+* dispatch; that makes reporting coherent, not durable. An outbox owner stages
+* its writes before calling journal.defer and owns worker retries/deduplication.
+*/
+const coordinateCommit = (owner, options) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+	yield* Effect.try({
+		try: () => validateContributions(options.mode, options.contributions ?? []),
+		catch: (error) => Schema.is(HookConfigurationError)(error) ? error : HookConfigurationError.make({
+			reason: "incompatible-transaction",
+			contribution: "transaction"
+		})
+	});
+	const parent = yield* Effect.serviceOption(CurrentCommit);
+	const hooks = yield* LifecycleHooks;
+	const events = [];
+	const participants = [];
+	const reservations = Option.isSome(parent) ? parent.value.reservations : /* @__PURE__ */ new Set();
+	const ownedReservations = /* @__PURE__ */ new Set();
+	const discard = Effect.sync(() => {
+		for (const participant of participants) participant.discard();
+		for (const id of ownedReservations) reservations.delete(id);
+		ownedReservations.clear();
+	});
+	let open = true;
+	const assertOpen = () => {
+		if (!open) throw HookConfigurationError.make({
+			reason: "closed-journal",
+			contribution: "transaction"
+		});
+		if (Option.isSome(parent)) parent.value.assertOpen();
+	};
+	const append = (incoming, incomingParticipants = []) => {
+		assertOpen();
+		const next = new Set(reservations);
+		for (const { event } of incoming) {
+			if (next.has(event.id)) throw HookConfigurationError.make({
+				reason: "duplicate-event",
+				contribution: event.id
+			});
+			next.add(event.id);
+		}
+		for (const item of incoming) {
+			reservations.add(item.event.id);
+			ownedReservations.add(item.event.id);
+			events.push(item);
+		}
+		participants.push(...incomingParticipants);
+	};
+	const promote = (incoming, incomingParticipants, incomingReservations) => {
+		assertOpen();
+		events.push(...incoming);
+		participants.push(...incomingParticipants);
+		for (const id of incomingReservations) ownedReservations.add(id);
+	};
+	const journal = {
+		prepare: (input) => {
+			let status = "pending";
+			let value = Option.some(input);
+			append([], [{
+				commit: () => {
+					status = "committed";
+				},
+				discard: () => {
+					status = "discarded";
+					value = Option.none();
+				}
+			}]);
+			return Object.freeze({
+				_tag: "PreparedCommit",
+				read: Effect.suspend(() => status === "committed" && Option.isSome(value) ? Effect.succeed(value.value) : status === "discarded" ? Effect.fail(CommitDiscarded.make({})) : Effect.fail(CommitPending.make({})))
+			});
+		},
+		stage: (input) => append([{
+			event: lifecycleEvent(input),
+			deferred: false
+		}]),
+		defer: (input) => append([{
+			event: lifecycleEvent(input),
+			deferred: true
+		}])
+	};
+	const value = yield* restore(Effect.suspend(() => owner(journal))).pipe(Effect.provideService(CurrentCommitJournal, journal), Effect.provideService(CurrentCommit, {
+		reservations,
+		assertOpen,
+		promote
+	}), Effect.catchCause((cause) => Effect.failCause(cause.reasons.every((reason) => Cause.isDieReason(reason) && Schema.is(HookConfigurationError)(reason.defect)) ? Cause.fromReasons(cause.reasons.map((reason) => Cause.isDieReason(reason) && Schema.is(HookConfigurationError)(reason.defect) ? Cause.makeFailReason(reason.defect).annotate(Cause.reasonAnnotations(reason)) : reason)) : cause)), Effect.onError(() => discard), Effect.ensuring(Effect.sync(() => {
+		open = false;
+	})));
+	if (Option.isSome(parent)) {
+		yield* Effect.try({
+			try: () => parent.value.promote(events, participants, ownedReservations),
+			catch: (error) => Schema.is(HookConfigurationError)(error) ? error : HookConfigurationError.make({
+				reason: "closed-journal",
+				contribution: "transaction"
+			})
+		}).pipe(Effect.onError(() => discard));
+		return {
+			_tag: "PendingCommit",
+			value
+		};
+	}
+	for (const participant of participants) participant.commit();
+	const delivery = [];
+	const deferred = [];
+	for (const { event, deferred: isDeferred } of events) if (isDeferred) deferred.push(event.id);
+	else delivery.push(...yield* hooks.after(event));
+	return {
+		_tag: "Committed",
+		value,
+		delivery,
+		deferred
+	};
+}));
+//#endregion
+export { CommitDiscarded, CommitPending, CurrentCommitJournal, coordinateCommit, hasCommitScope };
+
+//# sourceMappingURL=commit.mjs.map

package/dist/hooks/commit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.mjs","names":[],"sources":["../../src/hooks/commit.ts"],"sourcesContent":["import { Cause, Context, Effect, Option, Schema } from \"effect\";\n\nimport { LifecycleHooks } from \"./LifecycleHooks\";\nimport {\n  HookConfigurationError,\n  type HookDelivery,\n  type LifecycleEvent,\n  type LifecycleEventId,\n  lifecycleEvent,\n} from \"./models\";\nimport { type AtomicContribution, type CommitMode, validateContributions } from \"./transactions\";\n\nexport class CommitPending extends Schema.TaggedError<CommitPending>()(\"CommitPending\", {}) {}\nexport class CommitDiscarded extends Schema.TaggedError<CommitDiscarded>()(\"CommitDiscarded\", {}) {}\n\n/** No value is exposed until the outermost transaction authority has committed. */\nexport interface PreparedCommit<A> {\n  readonly _tag: \"PreparedCommit\";\n  readonly read: Effect.Effect<A, CommitPending | CommitDiscarded>;\n}\n\ninterface CommitParticipant {\n  readonly commit: () => void;\n  readonly discard: () => void;\n}\n\nexport interface CommitJournal {\n  readonly prepare: <A>(value: A) => PreparedCommit<A>;\n  /** Stage only work belonging to this transaction/savepoint, before its commit returns. */\n  readonly stage: (event: LifecycleEvent) => void;\n  /** Call only after staging this event's outbox write in the same transaction/batch. */\n  readonly defer: (event: LifecycleEvent) => void;\n}\n\n/** Current journal for internal transaction operations. Public commit-owner\n * continuations still receive the journal explicitly at the native boundary. */\nexport class CurrentCommitJournal extends Context.Service<CurrentCommitJournal, CommitJournal>()(\n  \"effect-auth/hooks/CurrentCommitJournal\",\n) {}\n\ninterface StagedEvent {\n  readonly event: LifecycleEvent;\n  readonly deferred: boolean;\n}\n\nclass CurrentCommit extends Context.Service<\n  CurrentCommit,\n  {\n    readonly reservations: Set<string>;\n    readonly assertOpen: () => void;\n    readonly promote: (\n      events: ReadonlyArray<StagedEvent>,\n      participants: ReadonlyArray<CommitParticipant>,\n      reservations: ReadonlySet<string>,\n    ) => void;\n  }\n>()(\"effect-auth/hooks/CurrentCommit\") {}\n\n/** Public operations may reject unsupported ambient execution before any mutation. */\nexport const hasCommitScope = Effect.serviceOption(CurrentCommit).pipe(Effect.map(Option.isSome));\n\nexport type CommitResult<A> =\n  | { readonly _tag: \"PendingCommit\"; readonly value: A }\n  | {\n      readonly _tag: \"Committed\";\n      readonly value: A;\n      readonly delivery: ReadonlyArray<HookDelivery>;\n      readonly deferred: ReadonlyArray<LifecycleEventId>;\n    };\n\n/**\n * `owner` must resolve only after its real transaction or batch commits. Nested\n * calls inherit the outer journal; their events are discarded on failure and\n * cannot dispatch until the outermost owner succeeds. Wrap a caught savepoint\n * rollback in its own coordinateCommit call so its events are discarded too.\n * Direct delivery is best effort: a process crash loses staged memory and no\n * retry is automatic. Once the owner returns, interruption is masked during\n * dispatch; that makes reporting coherent, not durable. An outbox owner stages\n * its writes before calling journal.defer and owns worker retries/deduplication.\n */\nexport const coordinateCommit = <A, E, R>(\n  owner: (journal: CommitJournal) => Effect.Effect<A, E, R>,\n  options: {\n    readonly mode: CommitMode;\n    readonly contributions?: ReadonlyArray<AtomicContribution>;\n  },\n): Effect.Effect<\n  CommitResult<A>,\n  E | HookConfigurationError,\n  Exclude<R, CurrentCommitJournal> | LifecycleHooks\n> =>\n  Effect.uninterruptibleMask((restore) =>\n    Effect.gen(function* () {\n      yield* Effect.try({\n        try: () => validateContributions(options.mode, options.contributions ?? []),\n        catch: (error) =>\n          Schema.is(HookConfigurationError)(error)\n            ? error\n            : HookConfigurationError.make({\n                reason: \"incompatible-transaction\",\n                contribution: \"transaction\",\n              }),\n      });\n      const parent = yield* Effect.serviceOption(CurrentCommit);\n      const hooks = yield* LifecycleHooks;\n      const events: StagedEvent[] = [];\n      const participants: CommitParticipant[] = [];\n      const reservations = Option.isSome(parent) ? parent.value.reservations : new Set<string>();\n      const ownedReservations = new Set<string>();\n\n      const discard = Effect.sync(() => {\n        for (const participant of participants) participant.discard();\n        for (const id of ownedReservations) reservations.delete(id);\n        ownedReservations.clear();\n      });\n\n      let open = true;\n\n      const assertOpen = (): void => {\n        if (!open)\n          throw HookConfigurationError.make({\n            reason: \"closed-journal\",\n            contribution: \"transaction\",\n          });\n        if (Option.isSome(parent)) parent.value.assertOpen();\n      };\n\n      const append = (\n        incoming: ReadonlyArray<StagedEvent>,\n        incomingParticipants: ReadonlyArray<CommitParticipant> = [],\n      ): void => {\n        assertOpen();\n        const next = new Set(reservations);\n\n        for (const { event } of incoming) {\n          if (next.has(event.id))\n            throw HookConfigurationError.make({\n              reason: \"duplicate-event\",\n              contribution: event.id,\n            });\n          next.add(event.id);\n        }\n        // Reserve while the native owner can still roll back. Successful child\n        // owners transfer these reservations without another duplicate check.\n        for (const item of incoming) {\n          reservations.add(item.event.id);\n          ownedReservations.add(item.event.id);\n          events.push(item);\n        }\n        participants.push(...incomingParticipants);\n      };\n\n      const promote = (\n        incoming: ReadonlyArray<StagedEvent>,\n        incomingParticipants: ReadonlyArray<CommitParticipant>,\n        incomingReservations: ReadonlySet<string>,\n      ): void => {\n        assertOpen();\n        events.push(...incoming);\n        participants.push(...incomingParticipants);\n        for (const id of incomingReservations) ownedReservations.add(id);\n      };\n\n      const journal: CommitJournal = {\n        prepare: <A>(input: A): PreparedCommit<A> => {\n          let status: \"pending\" | \"committed\" | \"discarded\" = \"pending\";\n          let value: Option.Option<A> = Option.some(input);\n\n          append(\n            [],\n            [\n              {\n                commit: () => {\n                  status = \"committed\";\n                },\n                discard: () => {\n                  status = \"discarded\";\n                  value = Option.none();\n                },\n              },\n            ],\n          );\n\n          return Object.freeze({\n            _tag: \"PreparedCommit\",\n            read: Effect.suspend((): Effect.Effect<A, CommitPending | CommitDiscarded> =>\n              status === \"committed\" && Option.isSome(value)\n                ? Effect.succeed(value.value)\n                : status === \"discarded\"\n                  ? Effect.fail(CommitDiscarded.make({}))\n                  : Effect.fail(CommitPending.make({})),\n            ),\n          });\n        },\n        stage: (input) => append([{ event: lifecycleEvent(input), deferred: false }]),\n        defer: (input) => append([{ event: lifecycleEvent(input), deferred: true }]),\n      };\n\n      const value = yield* restore(Effect.suspend(() => owner(journal))).pipe(\n        Effect.provideService(CurrentCommitJournal, journal),\n        Effect.provideService(CurrentCommit, { reservations, assertOpen, promote }),\n        // Synchronous journal methods can throw inside an Effect callback. The\n        // owner's failed transaction has rolled back before we normalize them.\n        // Mixed causes stay intact so typed recovery cannot swallow a defect or interruption.\n        Effect.catchCause((cause) =>\n          Effect.failCause(\n            cause.reasons.every(\n              (reason) =>\n                Cause.isDieReason(reason) && Schema.is(HookConfigurationError)(reason.defect),\n            )\n              ? Cause.fromReasons<E | HookConfigurationError>(\n                  cause.reasons.map((reason) =>\n                    Cause.isDieReason(reason) && Schema.is(HookConfigurationError)(reason.defect)\n                      ? Cause.makeFailReason(reason.defect).annotate(\n                          Cause.reasonAnnotations(reason),\n                        )\n                      : reason,\n                  ),\n                )\n              : cause,\n          ),\n        ),\n        Effect.onError(() => discard),\n        Effect.ensuring(\n          Effect.sync(() => {\n            open = false;\n          }),\n        ),\n      );\n\n      if (Option.isSome(parent)) {\n        yield* Effect.try({\n          try: () => parent.value.promote(events, participants, ownedReservations),\n          catch: (error) =>\n            Schema.is(HookConfigurationError)(error)\n              ? error\n              : HookConfigurationError.make({\n                  reason: \"closed-journal\",\n                  contribution: \"transaction\",\n                }),\n        }).pipe(Effect.onError(() => discard));\n\n        return { _tag: \"PendingCommit\", value } as const;\n      }\n      for (const participant of participants) participant.commit();\n      const delivery: HookDelivery[] = [];\n      const deferred: LifecycleEventId[] = [];\n\n      for (const { event, deferred: isDeferred } of events) {\n        if (isDeferred) deferred.push(event.id);\n        else delivery.push(...(yield* hooks.after(event)));\n      }\n\n      return { _tag: \"Committed\", value, delivery, deferred } as const;\n    }),\n  );\n\n/**\n * An outbox implementation stages this immutable event in the same authority's\n * transaction/batch. A delivery worker later calls LifecycleHooks.after(event),\n * retaining the same ID on every attempt and deduplicating each contribution.\n * Delivery is at least once when the consumer provides persistence and retries;\n * this interface alone supplies no persistence or exactly-once guarantee.\n */\nexport interface EventOutbox<E = never, R = never> {\n  readonly stage: (event: LifecycleEvent) => Effect.Effect<void, E, R>;\n}\n\nexport interface BatchEventOutbox<Statement> {\n  readonly statements: (event: LifecycleEvent) => ReadonlyArray<Statement>;\n}\n"],"mappings":"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"}

package/dist/hooks/models.d.mts

@@ -0,0 +1,51 @@
+import { LoginIdentifier } from "../identity/models.mjs";
+import { Schema } from "effect";
+//#region src/hooks/models.d.ts
+declare const LifecycleAction: Schema.Literals<readonly ["registration", "sign-in", "session-creation", "credential-change", "factor-change", "identifier-change", "linking", "sign-out", "proof-request", "proof-verification", "proof-completion"]>;
+type LifecycleAction = typeof LifecycleAction.Type;
+/** Deliberately excludes credentials, proofs, tokens, claims, and verification authority. */
+declare const LifecycleSnapshot: Schema.Struct<{
+  readonly action: Schema.Literals<readonly ["registration", "sign-in", "session-creation", "credential-change", "factor-change", "identifier-change", "linking", "sign-out", "proof-request", "proof-verification", "proof-completion"]>;
+  readonly operation: Schema.NonEmptyString;
+  readonly subjectId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "effect-auth/SubjectId">>;
+  readonly method: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly identifiers: Schema.$Array<typeof LoginIdentifier>;
+}>;
+type LifecycleSnapshot = typeof LifecycleSnapshot.Type;
+declare const LifecycleEventId: Schema.brand<Schema.NonEmptyString, "effect-auth/LifecycleEventId">;
+type LifecycleEventId = typeof LifecycleEventId.Type;
+/** The owner supplies a stable, nonsecret identifier; delivery retries reuse this exact event. */
+declare const LifecycleEvent: Schema.Struct<{
+  readonly id: Schema.brand<Schema.NonEmptyString, "effect-auth/LifecycleEventId">;
+  readonly occurredAtMillis: Schema.Int;
+  readonly snapshot: Schema.Struct<{
+    readonly action: Schema.Literals<readonly ["registration", "sign-in", "session-creation", "credential-change", "factor-change", "identifier-change", "linking", "sign-out", "proof-request", "proof-verification", "proof-completion"]>;
+    readonly operation: Schema.NonEmptyString;
+    readonly subjectId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "effect-auth/SubjectId">>;
+    readonly method: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly identifiers: Schema.$Array<typeof LoginIdentifier>;
+  }>;
+}>;
+type LifecycleEvent = typeof LifecycleEvent.Type;
+declare const HookDenied_base: Schema.Class<HookDenied, Schema.TaggedStruct<"HookDenied", {
+  readonly reason: Schema.Literals<readonly ["policy", "unavailable"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class HookDenied extends HookDenied_base {}
+declare const HookDeliveryFailed_base: Schema.Class<HookDeliveryFailed, Schema.TaggedStruct<"HookDeliveryFailed", {}>, import("effect/Cause").YieldableError>;
+declare class HookDeliveryFailed extends HookDeliveryFailed_base {}
+declare const HookConfigurationError_base: Schema.Class<HookConfigurationError, Schema.TaggedStruct<"HookConfigurationError", {
+  readonly reason: Schema.Literals<readonly ["duplicate-contribution", "duplicate-event", "duplicate-route", "incompatible-transaction", "closed-journal", "invalid-snapshot"]>;
+  readonly contribution: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class HookConfigurationError extends HookConfigurationError_base {}
+interface HookDelivery {
+  readonly eventId: LifecycleEventId;
+  readonly contribution: string;
+  readonly status: "delivered" | "failed";
+}
+/** Projection also strips undeclared own properties of identifier Schema.Class instances. */
+declare const lifecycleSnapshot: (input: LifecycleSnapshot) => LifecycleSnapshot;
+declare const lifecycleEvent: (input: LifecycleEvent) => LifecycleEvent;
+//#endregion
+export { HookConfigurationError, HookDelivery, HookDeliveryFailed, HookDenied, LifecycleAction, LifecycleEvent, LifecycleEventId, LifecycleSnapshot, lifecycleEvent, lifecycleSnapshot };
+//# sourceMappingURL=models.d.mts.map

package/dist/hooks/models.mjs

@@ -0,0 +1,87 @@
+import { SubjectId } from "../Schema.mjs";
+import { LoginIdentifier } from "../identity/models.mjs";
+import { Schema } from "effect";
+//#region src/hooks/models.ts
+const LifecycleAction = Schema.Literals([
+	"registration",
+	"sign-in",
+	"session-creation",
+	"credential-change",
+	"factor-change",
+	"identifier-change",
+	"linking",
+	"sign-out",
+	"proof-request",
+	"proof-verification",
+	"proof-completion"
+]);
+/** Deliberately excludes credentials, proofs, tokens, claims, and verification authority. */
+const LifecycleSnapshot = Schema.Struct({
+	action: LifecycleAction,
+	operation: Schema.NonEmptyString,
+	subjectId: Schema.optionalKey(SubjectId),
+	method: Schema.optionalKey(Schema.NonEmptyString),
+	identifiers: Schema.Array(LoginIdentifier)
+});
+const LifecycleEventId = Schema.NonEmptyString.pipe(Schema.brand("effect-auth/LifecycleEventId"));
+/** The owner supplies a stable, nonsecret identifier; delivery retries reuse this exact event. */
+const LifecycleEvent = Schema.Struct({
+	id: LifecycleEventId,
+	occurredAtMillis: Schema.Int.check(Schema.isBetween({
+		minimum: -864e13,
+		maximum: 864e13
+	})),
+	snapshot: LifecycleSnapshot
+});
+var HookDenied = class extends Schema.TaggedError()("HookDenied", { reason: Schema.Literals(["policy", "unavailable"]) }) {};
+var HookDeliveryFailed = class extends Schema.TaggedError()("HookDeliveryFailed", {}) {};
+var HookConfigurationError = class extends Schema.TaggedError()("HookConfigurationError", {
+	reason: Schema.Literals([
+		"duplicate-contribution",
+		"duplicate-event",
+		"duplicate-route",
+		"incompatible-transaction",
+		"closed-journal",
+		"invalid-snapshot"
+	]),
+	contribution: Schema.String
+}) {};
+const snapshotCodec = Schema.toCodecIso(LifecycleSnapshot);
+const encodeSnapshot = Schema.encodeSync(snapshotCodec);
+const decodeSnapshot = Schema.decodeSync(snapshotCodec);
+const eventCodec = Schema.toCodecIso(LifecycleEvent);
+const encodeEvent = Schema.encodeSync(eventCodec);
+const decodeEvent = Schema.decodeSync(eventCodec);
+/** Projection also strips undeclared own properties of identifier Schema.Class instances. */
+const lifecycleSnapshot = (input) => {
+	try {
+		const snapshot = decodeSnapshot(encodeSnapshot(input));
+		return Object.freeze({
+			...snapshot,
+			identifiers: Object.freeze(snapshot.identifiers.map((identifier) => Object.freeze(identifier)))
+		});
+	} catch {
+		throw HookConfigurationError.make({
+			reason: "invalid-snapshot",
+			contribution: "snapshot"
+		});
+	}
+};
+const lifecycleEvent = (input) => {
+	try {
+		const event = decodeEvent(encodeEvent(input));
+		return Object.freeze({
+			...event,
+			snapshot: lifecycleSnapshot(event.snapshot)
+		});
+	} catch {
+		throw HookConfigurationError.make({
+			reason: "invalid-snapshot",
+			contribution: "event"
+		});
+	}
+};
+//#endregion
+export { HookConfigurationError, HookDeliveryFailed, HookDenied, LifecycleAction, LifecycleEvent, LifecycleEventId, LifecycleSnapshot, lifecycleEvent, lifecycleSnapshot };
+
+//# sourceMappingURL=models.mjs.map

package/dist/hooks/models.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.mjs","names":[],"sources":["../../src/hooks/models.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { LoginIdentifier } from \"../identity/models\";\nimport { SubjectId } from \"../Schema\";\n\nexport const LifecycleAction = Schema.Literals([\n  \"registration\",\n  \"sign-in\",\n  \"session-creation\",\n  \"credential-change\",\n  \"factor-change\",\n  \"identifier-change\",\n  \"linking\",\n  \"sign-out\",\n  \"proof-request\",\n  \"proof-verification\",\n  \"proof-completion\",\n]);\n\nexport type LifecycleAction = typeof LifecycleAction.Type;\n\n/** Deliberately excludes credentials, proofs, tokens, claims, and verification authority. */\nexport const LifecycleSnapshot = Schema.Struct({\n  action: LifecycleAction,\n  operation: Schema.NonEmptyString,\n  subjectId: Schema.optionalKey(SubjectId),\n  method: Schema.optionalKey(Schema.NonEmptyString),\n  identifiers: Schema.Array(LoginIdentifier),\n});\n\nexport type LifecycleSnapshot = typeof LifecycleSnapshot.Type;\n\nexport const LifecycleEventId = Schema.NonEmptyString.pipe(\n  Schema.brand(\"effect-auth/LifecycleEventId\"),\n);\n\nexport type LifecycleEventId = typeof LifecycleEventId.Type;\n\n/** The owner supplies a stable, nonsecret identifier; delivery retries reuse this exact event. */\nexport const LifecycleEvent = Schema.Struct({\n  id: LifecycleEventId,\n  occurredAtMillis: Schema.Int.check(\n    Schema.isBetween({ minimum: -8640000000000000, maximum: 8640000000000000 }),\n  ),\n  snapshot: LifecycleSnapshot,\n});\n\nexport type LifecycleEvent = typeof LifecycleEvent.Type;\n\nexport class HookDenied extends Schema.TaggedError<HookDenied>()(\"HookDenied\", {\n  reason: Schema.Literals([\"policy\", \"unavailable\"]),\n}) {}\n\nexport class HookDeliveryFailed extends Schema.TaggedError<HookDeliveryFailed>()(\n  \"HookDeliveryFailed\",\n  {},\n) {}\n\nexport class HookConfigurationError extends Schema.TaggedError<HookConfigurationError>()(\n  \"HookConfigurationError\",\n  {\n    reason: Schema.Literals([\n      \"duplicate-contribution\",\n      \"duplicate-event\",\n      \"duplicate-route\",\n      \"incompatible-transaction\",\n      \"closed-journal\",\n      \"invalid-snapshot\",\n    ]),\n    contribution: Schema.String,\n  },\n) {}\n\nexport interface HookDelivery {\n  readonly eventId: LifecycleEventId;\n  readonly contribution: string;\n  readonly status: \"delivered\" | \"failed\";\n}\n\nconst snapshotCodec = Schema.toCodecIso(LifecycleSnapshot);\nconst encodeSnapshot = Schema.encodeSync(snapshotCodec);\nconst decodeSnapshot = Schema.decodeSync(snapshotCodec);\nconst eventCodec = Schema.toCodecIso(LifecycleEvent);\nconst encodeEvent = Schema.encodeSync(eventCodec);\nconst decodeEvent = Schema.decodeSync(eventCodec);\n\n/** Projection also strips undeclared own properties of identifier Schema.Class instances. */\nexport const lifecycleSnapshot = (input: LifecycleSnapshot): LifecycleSnapshot => {\n  try {\n    const snapshot = decodeSnapshot(encodeSnapshot(input));\n\n    return Object.freeze({\n      ...snapshot,\n      identifiers: Object.freeze(\n        snapshot.identifiers.map((identifier) => Object.freeze(identifier)),\n      ),\n    });\n  } catch {\n    throw HookConfigurationError.make({ reason: \"invalid-snapshot\", contribution: \"snapshot\" });\n  }\n};\n\nexport const lifecycleEvent = (input: LifecycleEvent): LifecycleEvent => {\n  try {\n    const event = decodeEvent(encodeEvent(input));\n\n    return Object.freeze({ ...event, snapshot: lifecycleSnapshot(event.snapshot) });\n  } catch {\n    throw HookConfigurationError.make({ reason: \"invalid-snapshot\", contribution: \"event\" });\n  }\n};\n"],"mappings":";;;;AAKA,MAAa,kBAAkB,OAAO,SAAS;CAC7C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;AAKD,MAAa,oBAAoB,OAAO,OAAO;CAC7C,QAAQ;CACR,WAAW,OAAO;CAClB,WAAW,OAAO,YAAY,SAAS;CACvC,QAAQ,OAAO,YAAY,OAAO,cAAc;CAChD,aAAa,OAAO,MAAM,eAAe;AAC3C,CAAC;AAID,MAAa,mBAAmB,OAAO,eAAe,KACpD,OAAO,MAAM,8BAA8B,CAC7C;;AAKA,MAAa,iBAAiB,OAAO,OAAO;CAC1C,IAAI;CACJ,kBAAkB,OAAO,IAAI,MAC3B,OAAO,UAAU;EAAE,SAAS;EAAmB,SAAS;CAAiB,CAAC,CAC5E;CACA,UAAU;AACZ,CAAC;AAID,IAAa,aAAb,cAAgC,OAAO,YAAwB,CAAC,CAAC,cAAc,EAC7E,QAAQ,OAAO,SAAS,CAAC,UAAU,aAAa,CAAC,EACnD,CAAC,CAAC,CAAC,CAAC;AAEJ,IAAa,qBAAb,cAAwC,OAAO,YAAgC,CAAC,CAC9E,sBACA,CAAC,CACH,CAAC,CAAC,CAAC;AAEH,IAAa,yBAAb,cAA4C,OAAO,YAAoC,CAAC,CACtF,0BACA;CACE,QAAQ,OAAO,SAAS;EACtB;EACA;EACA;EACA;EACA;EACA;CACF,CAAC;CACD,cAAc,OAAO;AACvB,CACF,CAAC,CAAC,CAAC;AAQH,MAAM,gBAAgB,OAAO,WAAW,iBAAiB;AACzD,MAAM,iBAAiB,OAAO,WAAW,aAAa;AACtD,MAAM,iBAAiB,OAAO,WAAW,aAAa;AACtD,MAAM,aAAa,OAAO,WAAW,cAAc;AACnD,MAAM,cAAc,OAAO,WAAW,UAAU;AAChD,MAAM,cAAc,OAAO,WAAW,UAAU;;AAGhD,MAAa,qBAAqB,UAAgD;CAChF,IAAI;EACF,MAAM,WAAW,eAAe,eAAe,KAAK,CAAC;EAErD,OAAO,OAAO,OAAO;GACnB,GAAG;GACH,aAAa,OAAO,OAClB,SAAS,YAAY,KAAK,eAAe,OAAO,OAAO,UAAU,CAAC,CACpE;EACF,CAAC;CACH,QAAQ;EACN,MAAM,uBAAuB,KAAK;GAAE,QAAQ;GAAoB,cAAc;EAAW,CAAC;CAC5F;AACF;AAEA,MAAa,kBAAkB,UAA0C;CACvE,IAAI;EACF,MAAM,QAAQ,YAAY,YAAY,KAAK,CAAC;EAE5C,OAAO,OAAO,OAAO;GAAE,GAAG;GAAO,UAAU,kBAAkB,MAAM,QAAQ;EAAE,CAAC;CAChF,QAAQ;EACN,MAAM,uBAAuB,KAAK;GAAE,QAAQ;GAAoB,cAAc;EAAQ,CAAC;CACzF;AACF"}

package/dist/hooks/plugins.d.mts

@@ -0,0 +1,36 @@
+import { AnyOperation } from "../operations/operation.mjs";
+import { HookConfigurationError } from "./models.mjs";
+import { AnyHookContribution, HookContributionId, LifecycleHooks } from "./LifecycleHooks.mjs";
+import { RpcGroup } from "effect/unstable/rpc";
+//#region src/hooks/plugins.d.ts
+/** Host-owned route implementation; metadata only reserves the method/path pair. */
+interface RouteContribution {
+  readonly id: string;
+  readonly method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD";
+  readonly path: string;
+}
+interface PluginContributions {
+  readonly id: string;
+  readonly operations: ReadonlyArray<AnyOperation>;
+  readonly hooks: ReadonlyArray<AnyHookContribution>;
+  readonly routes: ReadonlyArray<RouteContribution>;
+}
+/** Optional aggregation metadata alongside ordinary exported implementation Layers. */
+declare const pluginContributions: <const Contributions extends PluginContributions>(contributions: Contributions) => Readonly<{
+  id: string;
+  operations: Contributions["operations"];
+  hooks: Contributions["hooks"];
+  routes: Contributions["routes"];
+}>;
+declare const composePlugins: <const Plugins extends ReadonlyArray<PluginContributions>>(...plugins: Plugins) => Readonly<{
+  operations: RpcGroup.RpcGroup<Plugins[number]["operations"][number]["rpc"]>;
+  hooks: import("effect/Layer").Layer<LifecycleHooks, HookConfigurationError, Exclude<HookContributionId<Plugins[number]["hooks"][number]["id"]>, import("effect/Scope").Scope>>;
+  routes: readonly Readonly<{
+    id: string;
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD";
+    path: string;
+  }>[];
+}>;
+//#endregion
+export { PluginContributions, RouteContribution, composePlugins, pluginContributions };
+//# sourceMappingURL=plugins.d.mts.map

package/dist/hooks/plugins.mjs

@@ -0,0 +1,60 @@
+import { HookConfigurationError } from "./models.mjs";
+import { operationGroup } from "../operations/operation.mjs";
+import { composeHooks } from "./LifecycleHooks.mjs";
+//#region src/hooks/plugins.ts
+/** Optional aggregation metadata alongside ordinary exported implementation Layers. */
+const pluginContributions = (contributions) => Object.freeze({
+	id: contributions.id,
+	operations: Object.freeze([...contributions.operations]),
+	hooks: Object.freeze([...contributions.hooks]),
+	routes: Object.freeze(contributions.routes.map((route) => Object.freeze({ ...route })))
+});
+const composePlugins = (...plugins) => {
+	const snapshots = plugins.map((plugin) => ({
+		id: plugin.id,
+		operations: [...plugin.operations],
+		hooks: plugin.hooks.map(({ id, resolve }) => Object.freeze({
+			id,
+			resolve
+		})),
+		routes: plugin.routes.map((route) => Object.freeze({ ...route }))
+	}));
+	const ids = /* @__PURE__ */ new Set();
+	const hookIds = /* @__PURE__ */ new Set();
+	const routeIds = /* @__PURE__ */ new Set();
+	const routeKeys = /* @__PURE__ */ new Set();
+	for (const plugin of snapshots) {
+		if (ids.has(plugin.id)) throw HookConfigurationError.make({
+			reason: "duplicate-contribution",
+			contribution: plugin.id
+		});
+		ids.add(plugin.id);
+		for (const hook of plugin.hooks) {
+			if (hookIds.has(hook.id)) throw HookConfigurationError.make({
+				reason: "duplicate-contribution",
+				contribution: hook.id
+			});
+			hookIds.add(hook.id);
+		}
+		for (const route of plugin.routes) {
+			const key = `${route.method} ${route.path}`;
+			if (routeIds.has(route.id) || routeKeys.has(key)) throw HookConfigurationError.make({
+				reason: "duplicate-route",
+				contribution: route.id
+			});
+			routeIds.add(route.id);
+			routeKeys.add(key);
+		}
+	}
+	const operations = snapshots.flatMap((plugin) => plugin.operations);
+	const hooks = snapshots.flatMap((plugin) => plugin.hooks);
+	return Object.freeze({
+		operations: operationGroup(...operations),
+		hooks: composeHooks(...hooks),
+		routes: Object.freeze(snapshots.flatMap((plugin) => plugin.routes))
+	});
+};
+//#endregion
+export { composePlugins, pluginContributions };
+
+//# sourceMappingURL=plugins.mjs.map

package/dist/hooks/plugins.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.mjs","names":[],"sources":["../../src/hooks/plugins.ts"],"sourcesContent":["import type { RpcGroup } from \"effect/unstable/rpc\";\n\nimport { type AnyOperation, operationGroup } from \"../operations/operation\";\nimport { type AnyHookContribution, composeHooks } from \"./LifecycleHooks\";\nimport { HookConfigurationError } from \"./models\";\n\n/** Host-owned route implementation; metadata only reserves the method/path pair. */\nexport interface RouteContribution {\n  readonly id: string;\n  readonly method: \"GET\" | \"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\" | \"OPTIONS\" | \"HEAD\";\n  readonly path: string;\n}\n\nexport interface PluginContributions {\n  readonly id: string;\n  readonly operations: ReadonlyArray<AnyOperation>;\n  readonly hooks: ReadonlyArray<AnyHookContribution>;\n  readonly routes: ReadonlyArray<RouteContribution>;\n}\n\n/** Optional aggregation metadata alongside ordinary exported implementation Layers. */\nexport const pluginContributions = <const Contributions extends PluginContributions>(\n  contributions: Contributions,\n) =>\n  Object.freeze({\n    id: contributions.id,\n    operations: Object.freeze([...contributions.operations]) as Contributions[\"operations\"],\n    hooks: Object.freeze([...contributions.hooks]) as Contributions[\"hooks\"],\n    routes: Object.freeze(\n      contributions.routes.map((route) => Object.freeze({ ...route })),\n    ) as Contributions[\"routes\"],\n  });\n\nexport const composePlugins = <const Plugins extends ReadonlyArray<PluginContributions>>(\n  ...plugins: Plugins\n) => {\n  const snapshots = plugins.map((plugin) => ({\n    id: plugin.id,\n    operations: [...plugin.operations],\n    hooks: plugin.hooks.map(({ id, resolve }) => Object.freeze({ id, resolve })),\n    routes: plugin.routes.map((route) => Object.freeze({ ...route })),\n  }));\n\n  const ids = new Set<string>();\n  const hookIds = new Set<string>();\n  const routeIds = new Set<string>();\n  const routeKeys = new Set<string>();\n\n  for (const plugin of snapshots) {\n    if (ids.has(plugin.id))\n      throw HookConfigurationError.make({\n        reason: \"duplicate-contribution\",\n        contribution: plugin.id,\n      });\n    ids.add(plugin.id);\n    for (const hook of plugin.hooks) {\n      if (hookIds.has(hook.id))\n        throw HookConfigurationError.make({\n          reason: \"duplicate-contribution\",\n          contribution: hook.id,\n        });\n      hookIds.add(hook.id);\n    }\n    for (const route of plugin.routes) {\n      const key = `${route.method} ${route.path}`;\n\n      if (routeIds.has(route.id) || routeKeys.has(key))\n        throw HookConfigurationError.make({ reason: \"duplicate-route\", contribution: route.id });\n      routeIds.add(route.id);\n      routeKeys.add(key);\n    }\n  }\n  const operations = snapshots.flatMap((plugin) => plugin.operations);\n\n  const hooks = snapshots.flatMap((plugin) => plugin.hooks) as Array<\n    Plugins[number][\"hooks\"][number]\n  >;\n\n  return Object.freeze({\n    // Array flattening erases tuple membership; every RPC comes from these validated contributions.\n    operations: operationGroup(...operations) as RpcGroup.RpcGroup<\n      Plugins[number][\"operations\"][number][\"rpc\"]\n    >,\n    hooks: composeHooks<Plugins[number][\"hooks\"][number][\"id\"]>(...hooks),\n    routes: Object.freeze(snapshots.flatMap((plugin) => plugin.routes)),\n  });\n};\n"],"mappings":";;;;;AAqBA,MAAa,uBACX,kBAEA,OAAO,OAAO;CACZ,IAAI,cAAc;CAClB,YAAY,OAAO,OAAO,CAAC,GAAG,cAAc,UAAU,CAAC;CACvD,OAAO,OAAO,OAAO,CAAC,GAAG,cAAc,KAAK,CAAC;CAC7C,QAAQ,OAAO,OACb,cAAc,OAAO,KAAK,UAAU,OAAO,OAAO,EAAE,GAAG,MAAM,CAAC,CAAC,CACjE;AACF,CAAC;AAEH,MAAa,kBACX,GAAG,YACA;CACH,MAAM,YAAY,QAAQ,KAAK,YAAY;EACzC,IAAI,OAAO;EACX,YAAY,CAAC,GAAG,OAAO,UAAU;EACjC,OAAO,OAAO,MAAM,KAAK,EAAE,IAAI,cAAc,OAAO,OAAO;GAAE;GAAI;EAAQ,CAAC,CAAC;EAC3E,QAAQ,OAAO,OAAO,KAAK,UAAU,OAAO,OAAO,EAAE,GAAG,MAAM,CAAC,CAAC;CAClE,EAAE;CAEF,MAAM,sBAAM,IAAI,IAAY;CAC5B,MAAM,0BAAU,IAAI,IAAY;CAChC,MAAM,2BAAW,IAAI,IAAY;CACjC,MAAM,4BAAY,IAAI,IAAY;CAElC,KAAK,MAAM,UAAU,WAAW;EAC9B,IAAI,IAAI,IAAI,OAAO,EAAE,GACnB,MAAM,uBAAuB,KAAK;GAChC,QAAQ;GACR,cAAc,OAAO;EACvB,CAAC;EACH,IAAI,IAAI,OAAO,EAAE;EACjB,KAAK,MAAM,QAAQ,OAAO,OAAO;GAC/B,IAAI,QAAQ,IAAI,KAAK,EAAE,GACrB,MAAM,uBAAuB,KAAK;IAChC,QAAQ;IACR,cAAc,KAAK;GACrB,CAAC;GACH,QAAQ,IAAI,KAAK,EAAE;EACrB;EACA,KAAK,MAAM,SAAS,OAAO,QAAQ;GACjC,MAAM,MAAM,GAAG,MAAM,OAAO,GAAG,MAAM;GAErC,IAAI,SAAS,IAAI,MAAM,EAAE,KAAK,UAAU,IAAI,GAAG,GAC7C,MAAM,uBAAuB,KAAK;IAAE,QAAQ;IAAmB,cAAc,MAAM;GAAG,CAAC;GACzF,SAAS,IAAI,MAAM,EAAE;GACrB,UAAU,IAAI,GAAG;EACnB;CACF;CACA,MAAM,aAAa,UAAU,SAAS,WAAW,OAAO,UAAU;CAElE,MAAM,QAAQ,UAAU,SAAS,WAAW,OAAO,KAAK;CAIxD,OAAO,OAAO,OAAO;EAEnB,YAAY,eAAe,GAAG,UAAU;EAGxC,OAAO,aAAqD,GAAG,KAAK;EACpE,QAAQ,OAAO,OAAO,UAAU,SAAS,WAAW,OAAO,MAAM,CAAC;CACpE,CAAC;AACH"}

package/dist/hooks/transactions.d.mts

@@ -0,0 +1,31 @@
+import { LifecycleSnapshot } from "./models.mjs";
+import { Effect } from "effect";
+//#region src/hooks/transactions.d.ts
+type CommitMode = "interactive" | "synchronous" | "batch";
+interface AtomicContribution {
+  readonly id: string;
+  readonly mode: CommitMode;
+  /** Static validation, before the transaction owner executes any writes. */
+  readonly validate?: () => void;
+}
+declare const validateContributions: (mode: CommitMode, contributions: ReadonlyArray<AtomicContribution>) => void;
+declare const interactiveContribution: <E, R>(id: string, run: (snapshot: LifecycleSnapshot) => Effect.Effect<void, E, R>) => Readonly<{
+  id: string;
+  mode: "interactive";
+  run: (snapshot: LifecycleSnapshot) => Effect.Effect<void, E, R>;
+}>;
+/** The native owner executes this Effect synchronously and rolls back failures or suspension. */
+declare const synchronousContribution: <E, R>(id: string, run: (snapshot: LifecycleSnapshot) => Effect.Effect<void, E, R>) => Readonly<{
+  id: string;
+  mode: "synchronous";
+  run: (snapshot: LifecycleSnapshot) => Effect.Effect<void, E, R>;
+}>;
+/** Pure statement planning only; the consumer supplies and executes the actual atomic batch. */
+declare const batchContribution: <Statement>(id: string, statements: (snapshot: LifecycleSnapshot) => ReadonlyArray<Statement>) => Readonly<{
+  id: string;
+  mode: "batch";
+  statements: (snapshot: LifecycleSnapshot) => ReadonlyArray<Statement>;
+}>;
+//#endregion
+export { AtomicContribution, CommitMode, batchContribution, interactiveContribution, synchronousContribution, validateContributions };
+//# sourceMappingURL=transactions.d.mts.map

package/dist/hooks/transactions.mjs

@@ -0,0 +1,38 @@
+import { HookConfigurationError } from "./models.mjs";
+//#region src/hooks/transactions.ts
+const validateContributions = (mode, contributions) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const contribution of contributions) {
+		if (ids.has(contribution.id)) throw HookConfigurationError.make({
+			reason: "duplicate-contribution",
+			contribution: contribution.id
+		});
+		ids.add(contribution.id);
+		if (mode !== contribution.mode) throw HookConfigurationError.make({
+			reason: "incompatible-transaction",
+			contribution: contribution.id
+		});
+		contribution.validate?.();
+	}
+};
+const interactiveContribution = (id, run) => Object.freeze({
+	id,
+	mode: "interactive",
+	run
+});
+/** The native owner executes this Effect synchronously and rolls back failures or suspension. */
+const synchronousContribution = (id, run) => Object.freeze({
+	id,
+	mode: "synchronous",
+	run
+});
+/** Pure statement planning only; the consumer supplies and executes the actual atomic batch. */
+const batchContribution = (id, statements) => Object.freeze({
+	id,
+	mode: "batch",
+	statements
+});
+//#endregion
+export { batchContribution, interactiveContribution, synchronousContribution, validateContributions };
+
+//# sourceMappingURL=transactions.mjs.map

package/dist/hooks/transactions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.mjs","names":[],"sources":["../../src/hooks/transactions.ts"],"sourcesContent":["import type { Effect } from \"effect\";\n\nimport { HookConfigurationError, type LifecycleSnapshot } from \"./models\";\n\nexport type CommitMode = \"interactive\" | \"synchronous\" | \"batch\";\n\nexport interface AtomicContribution {\n  readonly id: string;\n  readonly mode: CommitMode;\n  /** Static validation, before the transaction owner executes any writes. */\n  readonly validate?: () => void;\n}\n\nexport const validateContributions = (\n  mode: CommitMode,\n  contributions: ReadonlyArray<AtomicContribution>,\n): void => {\n  const ids = new Set<string>();\n\n  for (const contribution of contributions) {\n    if (ids.has(contribution.id))\n      throw HookConfigurationError.make({\n        reason: \"duplicate-contribution\",\n        contribution: contribution.id,\n      });\n    ids.add(contribution.id);\n    if (mode !== contribution.mode)\n      throw HookConfigurationError.make({\n        reason: \"incompatible-transaction\",\n        contribution: contribution.id,\n      });\n    contribution.validate?.();\n  }\n};\n\nexport const interactiveContribution = <E, R>(\n  id: string,\n  run: (snapshot: LifecycleSnapshot) => Effect.Effect<void, E, R>,\n) => Object.freeze({ id, mode: \"interactive\" as const, run });\n\n/** The native owner executes this Effect synchronously and rolls back failures or suspension. */\nexport const synchronousContribution = <E, R>(\n  id: string,\n  run: (snapshot: LifecycleSnapshot) => Effect.Effect<void, E, R>,\n) => Object.freeze({ id, mode: \"synchronous\" as const, run });\n\n/** Pure statement planning only; the consumer supplies and executes the actual atomic batch. */\nexport const batchContribution = <Statement>(\n  id: string,\n  statements: (snapshot: LifecycleSnapshot) => ReadonlyArray<Statement>,\n) => Object.freeze({ id, mode: \"batch\" as const, statements });\n"],"mappings":";;AAaA,MAAa,yBACX,MACA,kBACS;CACT,MAAM,sBAAM,IAAI,IAAY;CAE5B,KAAK,MAAM,gBAAgB,eAAe;EACxC,IAAI,IAAI,IAAI,aAAa,EAAE,GACzB,MAAM,uBAAuB,KAAK;GAChC,QAAQ;GACR,cAAc,aAAa;EAC7B,CAAC;EACH,IAAI,IAAI,aAAa,EAAE;EACvB,IAAI,SAAS,aAAa,MACxB,MAAM,uBAAuB,KAAK;GAChC,QAAQ;GACR,cAAc,aAAa;EAC7B,CAAC;EACH,aAAa,WAAW;CAC1B;AACF;AAEA,MAAa,2BACX,IACA,QACG,OAAO,OAAO;CAAE;CAAI,MAAM;CAAwB;AAAI,CAAC;;AAG5D,MAAa,2BACX,IACA,QACG,OAAO,OAAO;CAAE;CAAI,MAAM;CAAwB;AAAI,CAAC;;AAG5D,MAAa,qBACX,IACA,eACG,OAAO,OAAO;CAAE;CAAI,MAAM;CAAkB;AAAW,CAAC"}

package/dist/http/auth-api.d.mts

@@ -0,0 +1,9 @@
+import { AuthRateLimited, AuthUnavailable, InvalidAuthRequest, InvalidCredentials, InvalidEmailOtp } from "../Errors.mjs";
+import { ExistingSessionResult, PasswordSignInPayload, RegistrationRequiredResult, RequestEmailOtpPayload, SessionStateAnonymous, SessionStateAuthenticated, SessionStateRegistrationRequired, SetPasswordPayload, VerifyEmailOtpPayload } from "./models.mjs";
+import { ChallengeMiddleware, SessionMiddleware } from "./security.mjs";
+import { HttpApiGroup } from "effect/unstable/httpapi";
+//#region src/http/auth-api.d.ts
+declare const AuthApi: HttpApiGroup.HttpApiGroup<"auth", import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getSession", "GET", "/auth/session", never, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Union<readonly [typeof SessionStateAnonymous, typeof SessionStateRegistrationRequired, typeof SessionStateAuthenticated]>>, import("effect/Schema").toCodecJson<typeof AuthUnavailable>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"passwordSignIn", "POST", "/auth/password/sign-in", never, never, import("effect/Schema").toCodecJson<typeof PasswordSignInPayload>, never, import("effect/Schema").toCodecJson<typeof SessionStateAuthenticated>, import("effect/Schema").toCodecJson<typeof InvalidCredentials | typeof InvalidAuthRequest | typeof AuthRateLimited | typeof AuthUnavailable>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"requestEmailOtp", "POST", "/auth/email-otp", never, never, import("effect/Schema").toCodecJson<typeof RequestEmailOtpPayload>, never, import("effect/Schema").toCodecJson<import("effect/Schema").Void>, import("effect/Schema").toCodecJson<typeof InvalidAuthRequest | typeof AuthRateLimited | typeof AuthUnavailable>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"setPassword", "POST", "/auth/password", never, never, import("effect/Schema").toCodecJson<typeof SetPasswordPayload>, never, import("effect/Schema").toCodecJson<import("effect/unstable/httpapi/HttpApiSchema").NoContent>, import("effect/Schema").toCodecJson<typeof InvalidCredentials | typeof InvalidAuthRequest | typeof AuthRateLimited | typeof AuthUnavailable>, SessionMiddleware, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"signOut", "POST", "/auth/sign-out", never, never, never, never, import("effect/Schema").toCodecJson<import("effect/unstable/httpapi/HttpApiSchema").NoContent>, never, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"verifyEmailOtp", "POST", "/auth/email-otp/verify", never, never, import("effect/Schema").toCodecJson<typeof VerifyEmailOtpPayload>, never, import("effect/Schema").toCodecJson<import("effect/Schema").Union<readonly [typeof ExistingSessionResult, typeof RegistrationRequiredResult]>>, import("effect/Schema").toCodecJson<typeof InvalidEmailOtp | typeof InvalidAuthRequest | typeof AuthUnavailable>, ChallengeMiddleware, never>, false>;
+//#endregion
+export { AuthApi };
+//# sourceMappingURL=auth-api.d.mts.map

package/dist/http/auth-api.mjs

@@ -0,0 +1,13 @@
+import { GetSessionEndpoint } from "./endpoints/get-session.mjs";
+import { PasswordSignInEndpoint } from "./endpoints/password-sign-in.mjs";
+import { RequestEmailOtpEndpoint } from "./endpoints/request-email-otp.mjs";
+import { SetPasswordEndpoint } from "./endpoints/set-password.mjs";
+import { SignOutEndpoint } from "./endpoints/sign-out.mjs";
+import { VerifyEmailOtpEndpoint } from "./endpoints/verify-email-otp.mjs";
+import { HttpApiGroup } from "effect/unstable/httpapi";
+//#region src/http/auth-api.ts
+const AuthApi = HttpApiGroup.make("auth").add(RequestEmailOtpEndpoint, VerifyEmailOtpEndpoint, PasswordSignInEndpoint, SetPasswordEndpoint, GetSessionEndpoint, SignOutEndpoint);
+//#endregion
+export { AuthApi };
+
+//# sourceMappingURL=auth-api.mjs.map

package/dist/http/auth-api.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-api.mjs","names":[],"sources":["../../src/http/auth-api.ts"],"sourcesContent":["import { HttpApiGroup } from \"effect/unstable/httpapi\";\n\nimport { GetSessionEndpoint } from \"./endpoints/get-session\";\nimport { PasswordSignInEndpoint } from \"./endpoints/password-sign-in\";\nimport { RequestEmailOtpEndpoint } from \"./endpoints/request-email-otp\";\nimport { SetPasswordEndpoint } from \"./endpoints/set-password\";\nimport { SignOutEndpoint } from \"./endpoints/sign-out\";\nimport { VerifyEmailOtpEndpoint } from \"./endpoints/verify-email-otp\";\n\nexport const AuthApi = HttpApiGroup.make(\"auth\").add(\n  RequestEmailOtpEndpoint,\n  VerifyEmailOtpEndpoint,\n  PasswordSignInEndpoint,\n  SetPasswordEndpoint,\n  GetSessionEndpoint,\n  SignOutEndpoint,\n);\n"],"mappings":";;;;;;;;AASA,MAAa,UAAU,aAAa,KAAK,MAAM,CAAC,CAAC,IAC/C,yBACA,wBACA,wBACA,qBACA,oBACA,eACF"}

package/dist/http/auth-contract.d.mts

@@ -0,0 +1,84 @@
+import { AnyAuthAction, AuthActions } from "../operations/actions.mjs";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+//#region src/http/auth-contract.d.ts
+declare const endpoint: <const Name extends string, A extends AnyAuthAction>(name: Name, action: A) => HttpApiEndpoint.HttpApiEndpoint<Name, "GET", `/${string}`, never, never, never, never, Schema.toCodecJson<Schema.TaggedStruct<"Success", {}> | Schema.TaggedStruct<"Success", {
+  readonly value: Schema.optionalKey<Schema.toEncoded<A["route"]["operation"]["rpc"]["successSchema"]>>;
+}> | Schema.TaggedStruct<"Success", {
+  readonly value: Schema.toEncoded<A["route"]["operation"]["rpc"]["successSchema"]>;
+}> | Schema.TaggedStruct<"Success", {
+  readonly value: Schema.toEncoded<A["route"]["operation"]["rpc"]["successSchema"]>;
+  readonly private: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["totp-enrollment", "recovery-codes"]>;
+    readonly revealId: Schema.NonEmptyString;
+    readonly expiresAtMillis: Schema.Int;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  }>>>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly _tag: Schema.tag<"Failure">;
+  readonly error: Schema.toEncoded<A["route"]["operation"]["rpc"]["errorSchema"]>;
+}> | Schema.Struct<{
+  readonly _tag: Schema.tag<"TransportFailure">;
+  readonly reason: Schema.Literals<readonly ["request", "credentials", "response", "network", "stale-response", "private-output"]>;
+}> | Schema.Struct<{
+  readonly _tag: Schema.tag<"TransportFailure">;
+  readonly reason: Schema.Literals<readonly ["origin", "csrf"]>;
+}> | Schema.Struct<{
+  readonly _tag: Schema.tag<"TransportFailure">;
+  readonly reason: Schema.Literals<readonly ["not-found"]>;
+}> | Schema.Struct<{
+  readonly _tag: Schema.tag<"TransportFailure">;
+  readonly reason: Schema.Literals<readonly ["method"]>;
+}> | Schema.Struct<{
+  readonly _tag: Schema.tag<"TransportFailure">;
+  readonly reason: Schema.Literals<readonly ["too-large"]>;
+}> | Schema.Struct<{
+  readonly _tag: Schema.tag<"TransportFailure">;
+  readonly reason: Schema.Literals<readonly ["unavailable"]>;
+}>>, never, never> | HttpApiEndpoint.HttpApiEndpoint<Name, "POST", `/${string}`, never, never, Schema.toCodecJson<Schema.toEncoded<Schema.Struct<{}>>>, never, Schema.toCodecJson<Schema.toEncoded<Schema.TaggedStruct<"Success", {}> | Schema.TaggedStruct<"Success", {
+  readonly value: Schema.optionalKey<Schema.toEncoded<A["route"]["operation"]["rpc"]["successSchema"]>>;
+}> | Schema.TaggedStruct<"Success", {
+  readonly value: Schema.toEncoded<A["route"]["operation"]["rpc"]["successSchema"]>;
+}> | Schema.TaggedStruct<"Success", {
+  readonly value: Schema.toEncoded<A["route"]["operation"]["rpc"]["successSchema"]>;
+  readonly private: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["totp-enrollment", "recovery-codes"]>;
+    readonly revealId: Schema.NonEmptyString;
+    readonly expiresAtMillis: Schema.Int;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  }>>>;
+}>>>, Schema.toCodecJson<Schema.Struct<{
+  readonly _tag: Schema.tag<"TransportFailure">;
+  readonly reason: Schema.Literals<readonly ["request", "credentials", "response", "network", "stale-response", "private-output"]>;
+}> | Schema.Struct<{
+  readonly _tag: Schema.tag<"TransportFailure">;
+  readonly reason: Schema.Literals<readonly ["origin", "csrf"]>;
+}> | Schema.Struct<{
+  readonly _tag: Schema.tag<"TransportFailure">;
+  readonly reason: Schema.Literals<readonly ["not-found"]>;
+}> | Schema.Struct<{
+  readonly _tag: Schema.tag<"TransportFailure">;
+  readonly reason: Schema.Literals<readonly ["method"]>;
+}> | Schema.Struct<{
+  readonly _tag: Schema.tag<"TransportFailure">;
+  readonly reason: Schema.Literals<readonly ["too-large"]>;
+}> | Schema.Struct<{
+  readonly _tag: Schema.tag<"TransportFailure">;
+  readonly reason: Schema.Literals<readonly ["unavailable"]>;
+}> | Schema.toEncoded<Schema.Struct<{
+  readonly _tag: Schema.tag<"Failure">;
+  readonly error: Schema.toEncoded<A["route"]["operation"]["rpc"]["errorSchema"]>;
+}>>>, never, never>;
+type Endpoints<Actions extends AuthActions> = { readonly [Name in keyof Actions]: ReturnType<typeof endpoint<Extract<Name, string>, Actions[Name]>>; }[keyof Actions];
+/** Native HttpApi projection of the named transport. Public envelopes are exact;
+ * private credentials remain cookies/headers, and private reveals retain their envelope.
+ * Server handlers use the same bounded operation decoder before schema projection.
+ */
+declare const httpGroup: <Actions extends AuthActions, const Name extends string = "auth">(contract: {
+  readonly actions: Actions;
+}, options?: {
+  readonly name?: Name;
+}) => HttpApiGroup.HttpApiGroup<Name, Endpoints<Actions>, false>;
+//#endregion
+export { httpGroup };
+//# sourceMappingURL=auth-contract.d.mts.map