@xandreed/plugin-sessions 0.8.0-next.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Xand Reed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @xandreed/plugin-sessions
+
+Efferent composable agent framework, 0.8.0-next.0. Bun on Linux.
+
+Documentation: https://github.com/xandreeddev/efferent

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { sessionsPlugin, SessionsPluginLive, default } from "./plugin.adapter.js";
+export { SessionsLive } from "./sessions.adapter.js";
+export { processLiveness } from "./process-liveness.adapter.js";
+export { HeldTurn, HolderProcess, Ownership, SessionsConfig, sessionsDefaults, SessionsState, InboxSlot } from "./sessions-state.entity.js";
+export type { ProcessLiveness } from "./sessions-state.entity.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { sessionsPlugin, SessionsPluginLive, default } from "./plugin.adapter.js";
+export { SessionsLive } from "./sessions.adapter.js";
+export { processLiveness } from "./process-liveness.adapter.js";
+export { HeldTurn, HolderProcess, Ownership, SessionsConfig, sessionsDefaults, SessionsState, InboxSlot } from "./sessions-state.entity.js";

package/dist/plugin.adapter.d.ts

@@ -0,0 +1,70 @@
+import { SessionLog, Sessions, TurnAdmission } from "@xandreed/core";
+/**
+ * Sessions over the host's SessionLog: one event log per session, one open
+ * turn at a time, leases by lease or by process, the inbox and forks. The
+ * host admits every turn (TurnAdmissionOpen admits all).
+ */
+export declare const sessionsPlugin: import("@xandreed/core").TypedPlugin<{
+    readonly ownership: {
+        readonly mode: "lease";
+        readonly ttlMs: number;
+        readonly renew: "none" | "on-commit" | {
+            readonly everyMs: number;
+        };
+    } | {
+        readonly mode: "process";
+    };
+    readonly titleChars: number;
+    readonly inbox: {
+        readonly maxPending: number;
+        readonly attempts: number;
+    };
+    readonly writer: {
+        readonly capacity: number;
+        readonly batch: number;
+    };
+    readonly retries: number;
+}, {
+    readonly ownership: {
+        readonly mode: "lease";
+        readonly ttlMs: number;
+        readonly renew: "none" | "on-commit" | {
+            readonly everyMs: number;
+        };
+    } | {
+        readonly mode: "process";
+    };
+    readonly titleChars: number;
+    readonly inbox: {
+        readonly maxPending: number;
+        readonly attempts: number;
+    };
+    readonly writer: {
+        readonly capacity: number;
+        readonly batch: number;
+    };
+    readonly retries: number;
+}, Sessions, never, SessionLog | TurnAdmission>;
+/** Sessions as a typed layer: provides Sessions; requires SessionLog and TurnAdmission. */
+export declare const SessionsPluginLive: (options?: Partial<{
+    readonly ownership: {
+        readonly mode: "lease";
+        readonly ttlMs: number;
+        readonly renew: "none" | "on-commit" | {
+            readonly everyMs: number;
+        };
+    } | {
+        readonly mode: "process";
+    };
+    readonly titleChars: number;
+    readonly inbox: {
+        readonly maxPending: number;
+        readonly attempts: number;
+    };
+    readonly writer: {
+        readonly capacity: number;
+        readonly batch: number;
+    };
+    readonly retries: number;
+}> | undefined) => import("effect/Layer").Layer<Sessions, import("@xandreed/core").HarnessError, SessionLog | TurnAdmission>;
+export default sessionsPlugin;

package/dist/plugin.adapter.js

@@ -0,0 +1,14 @@
+import { definePlugin, SessionLog, Sessions, TurnAdmission } from "@xandreed/core";
+import { SessionsConfig, sessionsDefaults } from "./sessions-state.entity.js";
+import { SessionsLive } from "./sessions.adapter.js";
+export const sessionsPlugin = definePlugin({
+  id: "@xandreed/plugin-sessions",
+  version: "0.8.0-next.0",
+  scope: "runtime",
+  config: SessionsConfig,
+  defaults: sessionsDefaults,
+  requires: [SessionLog, TurnAdmission],
+  provides: [Sessions],
+  layer: SessionsLive
+}), SessionsPluginLive = sessionsPlugin.live;
+export default sessionsPlugin;

package/dist/process-liveness.adapter.d.ts

@@ -0,0 +1,7 @@
+import type { ProcessLiveness } from "./sessions-state.entity.js";
+/**
+ * Process ownership's default liveness: this process by its host, pid and
+ * start time, and a pid of this host runs while `kill(pid, 0)` finds it.
+ * Without a process (another runtime), turns name none and nothing is asked.
+ */
+export declare const processLiveness: ProcessLiveness;

package/dist/process-liveness.adapter.js

@@ -0,0 +1,16 @@
+import { Effect, Option } from "effect";
+const running = Effect.sync(() => Option.fromNullishOr(typeof globalThis.process === "object" ? globalThis.process : void 0)), hostOf = (current) => {
+  const os = typeof current.getBuiltinModule === "function" ? Option.fromNullishOr(current.getBuiltinModule("node:os")) : Option.none();
+  return Option.flatMap(os, (module) => Option.fromNullishOr(module.hostname())).pipe(Option.orElse(() => Option.fromNullishOr(current.env.HOSTNAME)), Option.filter((host) => host.length > 0));
+}, signalled = (error) => !(typeof error === "object" && error !== null && ("code" in error) && error.code === "ESRCH");
+export const processLiveness = {
+  current: running.pipe(Effect.map(Option.flatMap((current) => Option.map(hostOf(current), (host) => ({
+    host,
+    pid: current.pid,
+    startedAt: Math.round(performance.timeOrigin)
+  }))))),
+  alive: (pid) => running.pipe(Effect.flatMap(Option.match({
+    onNone: () => Effect.succeed(!0),
+    onSome: (current) => pid <= 0 ? Effect.succeed(!1) : Effect.try({ try: () => current.kill(pid, 0), catch: signalled }).pipe(Effect.as(!0), Effect.catch((alive) => Effect.succeed(alive)))
+  })))
+};

package/dist/sessions-state.entity.d.ts

@@ -0,0 +1,111 @@
+import { Schema } from "effect";
+import type { Effect, Option } from "effect";
+/** One inbox item that is not done yet: waiting, or taken by an open turn. */
+export declare const InboxSlot: Schema.Struct<{
+    readonly id: Schema.String;
+    /** Turns that took it and did not finish it. */
+    readonly attempts: Schema.Int;
+    readonly claimedBy: Schema.OptionFromNullOr<Schema.Int>;
+}>;
+export type InboxSlot = typeof InboxSlot.Type;
+/** Where a process-owned turn's holder runs: its host, its pid, and when that process started (a pid is reused). */
+export declare const HolderProcess: Schema.Struct<{
+    readonly host: Schema.String;
+    readonly pid: Schema.Int;
+    readonly startedAt: Schema.Number;
+}>;
+export type HolderProcess = typeof HolderProcess.Type;
+/** The open turn as kept: under process ownership, also where its holder runs (none when an older version wrote it). */
+export declare const HeldTurn: Schema.Struct<{
+    readonly process: Schema.OptionFromOptionalKey<Schema.Struct<{
+        readonly host: Schema.String;
+        readonly pid: Schema.Int;
+        readonly startedAt: Schema.Number;
+    }>>;
+    readonly turn: Schema.Int;
+    readonly runId: Schema.String;
+    readonly key: Schema.String;
+    readonly origin: Schema.Literals<readonly ["user", "inbox"]>;
+    readonly holder: Schema.String;
+    readonly expiresAt: Schema.OptionFromNullOr<Schema.Number>;
+}>;
+export type HeldTurn = typeof HeldTurn.Type;
+export declare const SessionsState: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    /** The highest turn number begun (a fork starts from its parent's). */
+    readonly turns: Schema.Int;
+    readonly open: Schema.OptionFromNullOr<Schema.Struct<{
+        readonly process: Schema.OptionFromOptionalKey<Schema.Struct<{
+            readonly host: Schema.String;
+            readonly pid: Schema.Int;
+            readonly startedAt: Schema.Number;
+        }>>;
+        readonly turn: Schema.Int;
+        readonly runId: Schema.String;
+        readonly key: Schema.String;
+        readonly origin: Schema.Literals<readonly ["user", "inbox"]>;
+        readonly holder: Schema.String;
+        readonly expiresAt: Schema.OptionFromNullOr<Schema.Number>;
+    }>>;
+    readonly title: Schema.OptionFromNullOr<Schema.String>;
+    readonly inbox: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        /** Turns that took it and did not finish it. */
+        readonly attempts: Schema.Int;
+        readonly claimedBy: Schema.OptionFromNullOr<Schema.Int>;
+    }>>;
+}>;
+export type SessionsState = typeof SessionsState.Type;
+/** How a session's turns are owned. */
+export declare const Ownership: Schema.Union<readonly [Schema.Struct<{
+    readonly mode: Schema.Literal<"lease">;
+    /** How long an open turn is held without a write (storage time). */
+    readonly ttlMs: Schema.Int;
+    /** `none`: the lease is fixed at begin; `on-commit`: each write extends it; `everyMs`: a keep-alive also extends it. */
+    readonly renew: Schema.Union<readonly [Schema.Literals<readonly ["none", "on-commit"]>, Schema.Struct<{
+        readonly everyMs: Schema.Int;
+    }>]>;
+}>, Schema.Struct<{
+    readonly mode: Schema.Literal<"process">;
+}>]>;
+export type Ownership = typeof Ownership.Type;
+/**
+ * How process ownership tells whether a turn's holder still runs: this
+ * process as its turns record it (none where the runtime has no process to
+ * name: its turns are then reaped by others as before), and whether the
+ * process with a pid runs on this host.
+ */
+export interface ProcessLiveness {
+    readonly current: Effect.Effect<Option.Option<HolderProcess>>;
+    readonly alive: (pid: number) => Effect.Effect<boolean>;
+}
+export declare const SessionsConfig: Schema.Struct<{
+    readonly ownership: Schema.Union<readonly [Schema.Struct<{
+        readonly mode: Schema.Literal<"lease">;
+        /** How long an open turn is held without a write (storage time). */
+        readonly ttlMs: Schema.Int;
+        /** `none`: the lease is fixed at begin; `on-commit`: each write extends it; `everyMs`: a keep-alive also extends it. */
+        readonly renew: Schema.Union<readonly [Schema.Literals<readonly ["none", "on-commit"]>, Schema.Struct<{
+            readonly everyMs: Schema.Int;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly mode: Schema.Literal<"process">;
+    }>]>;
+    /** The title is the first user message, cut to this many characters. */
+    readonly titleChars: Schema.Int;
+    readonly inbox: Schema.Struct<{
+        /** Items that may wait at once. */
+        readonly maxPending: Schema.Int;
+        /** Turns that may take an item and fail before it is dropped. */
+        readonly attempts: Schema.Int;
+    }>;
+    /** The turn's write-behind queue: items before a writer waits, items taken per commit. */
+    readonly writer: Schema.Struct<{
+        readonly capacity: Schema.Int;
+        readonly batch: Schema.Int;
+    }>;
+    /** Compare-and-swap attempts before a write gives up as contended. */
+    readonly retries: Schema.Int;
+}>;
+export type SessionsConfig = typeof SessionsConfig.Type;
+export declare const sessionsDefaults: SessionsConfig;

package/dist/sessions-state.entity.functions.d.ts

@@ -0,0 +1,36 @@
+import { Effect, Option, Schema } from "effect";
+import type { JsonObject, SessionHead, SessionView, TurnEndReason } from "@xandreed/core";
+import type { HeldTurn, HolderProcess, InboxSlot, Ownership, ProcessLiveness, SessionsState as State } from "./sessions-state.entity.js";
+/** A session's state before its first turn: a fork counts from its parent's turns. */
+export declare const initialState: (head: SessionHead) => State;
+/** The plugin's state from a head (the initial state when there is none yet). */
+export declare const stateOf: (head: SessionHead) => Effect.Effect<State, Schema.SchemaError>;
+/** The state as the head stores it. */
+export declare const stateJson: (state: State) => JsonObject;
+/** Who asks whether a turn is held: this Sessions instance, and how it tells whether a process runs. */
+export interface Holder {
+    readonly instance: string;
+    readonly liveness: ProcessLiveness;
+    /** This process, as its turns record it. */
+    readonly process: Option.Option<HolderProcess>;
+}
+/** Whether an open turn is still held: within its lease (storage time), or by a process that runs. */
+export declare const isHeld: (open: HeldTurn, now: number, ownership: Ownership, holder: Holder) => Effect.Effect<boolean>;
+/** The turn a head has open and still held, if any. */
+export declare const heldTurn: (head: SessionHead, state: State, ownership: Ownership, holder: Holder) => Effect.Effect<Option.Option<HeldTurn>>;
+/** Inbox items waiting for a turn. */
+export declare const pendingOf: (state: State) => ReadonlyArray<InboxSlot>;
+/**
+ * Close the open turn. Returns the state after it and the inbox items it
+ * dropped (taken by too many turns that did not finish them). A turn that
+ * did not try its items — interrupted before it wrote anything — returns
+ * them to wait without counting an attempt.
+ */
+export declare const closedState: (state: State, reason: TurnEndReason, maxAttempts: number, tried: boolean) => {
+    readonly state: State;
+    readonly dropped: ReadonlyArray<string>;
+};
+/** One session as a host sees it: an open turn nobody holds any more (its lease ran out, its process stopped) is shown as closed. */
+export declare const viewOf: (head: SessionHead, state: State, ownership: Ownership, holder: Holder) => Effect.Effect<SessionView>;
+/** The title a session takes from its first user message: its first `chars` characters. */
+export declare const titleOf: (text: string, chars: number) => string;

package/dist/sessions-state.entity.functions.js

@@ -0,0 +1,50 @@
+import { Effect, Option, Schema } from "effect";
+import { SessionsState } from "./sessions-state.entity.js";
+const decodeState = Schema.decodeUnknownEffect(SessionsState), encodeState = Schema.encodeSync(SessionsState);
+export const initialState = (head) => ({
+  v: 1,
+  turns: Option.match(head.header.parent, { onNone: () => 0, onSome: (parent) => parent.turnAtFork }),
+  open: Option.none(),
+  title: Option.none(),
+  inbox: []
+}), stateOf = (head) => head.state.sessions === void 0 ? Effect.succeed(initialState(head)) : decodeState(head.state.sessions), stateJson = (state) => ({ sessions: encodeState(state) });
+const processHolds = (open, holder) => open.holder === holder.instance ? Effect.succeed(!0) : Option.match(open.process, {
+  onNone: () => Effect.succeed(!1),
+  onSome: (running) => Option.match(holder.process, {
+    onNone: () => Effect.succeed(!0),
+    onSome: (self) => running.host !== self.host ? Effect.succeed(!0) : running.pid === self.pid ? Effect.succeed(running.startedAt === self.startedAt) : holder.liveness.alive(running.pid)
+  })
+});
+export const isHeld = (open, now, ownership, holder) => ownership.mode === "process" ? processHolds(open, holder) : Effect.succeed(Option.match(open.expiresAt, { onNone: () => !0, onSome: (end) => now <= end })), heldTurn = (head, state, ownership, holder) => Option.match(state.open, {
+  onNone: () => Effect.succeed(Option.none()),
+  onSome: (open) => isHeld(open, head.now, ownership, holder).pipe(Effect.map((held) => held ? Option.some(open) : Option.none()))
+});
+const openTurnOf = (held) => ({
+  turn: held.turn,
+  runId: held.runId,
+  key: held.key,
+  origin: held.origin,
+  holder: held.holder,
+  expiresAt: held.expiresAt
+});
+export const pendingOf = (state) => state.inbox.filter((slot) => Option.isNone(slot.claimedBy));
+const finished = (reason) => reason === "completed" || reason === "partial" || reason === "cancelled";
+export const closedState = (state, reason, maxAttempts, tried) => {
+  const turn = Option.map(state.open, (open) => open.turn), taken = (slot) => Option.isSome(slot.claimedBy) && Option.contains(turn, slot.claimedBy.value), counted = tried || reason !== "interrupted", exhausted = (slot) => counted && slot.attempts + 1 >= maxAttempts;
+  return {
+    state: {
+      ...state,
+      open: Option.none(),
+      inbox: state.inbox.flatMap((slot) => !taken(slot) ? [slot] : finished(reason) || exhausted(slot) ? [] : [{ ...slot, attempts: counted ? slot.attempts + 1 : slot.attempts, claimedBy: Option.none() }])
+    },
+    dropped: finished(reason) ? [] : state.inbox.filter((slot) => taken(slot) && exhausted(slot)).map((slot) => slot.id)
+  };
+}, viewOf = (head, state, ownership, holder) => heldTurn(head, state, ownership, holder).pipe(Effect.map((open) => ({
+  header: head.header,
+  seq: head.seq,
+  updatedAt: head.updatedAt,
+  turns: state.turns,
+  title: state.title,
+  open: Option.map(open, openTurnOf),
+  pending: pendingOf(state).length
+}))), titleOf = (text, chars) => Array.from(text).slice(0, chars).join("");

package/dist/sessions-state.entity.js

@@ -0,0 +1,38 @@
+import { Schema } from "effect";
+import { OpenTurn } from "@xandreed/core";
+export const InboxSlot = Schema.Struct({
+  id: Schema.String,
+  attempts: Schema.Int,
+  claimedBy: Schema.OptionFromNullOr(Schema.Int)
+}), HolderProcess = Schema.Struct({ host: Schema.String, pid: Schema.Int, startedAt: Schema.Number }), HeldTurn = Schema.Struct({ ...OpenTurn.fields, process: Schema.OptionFromOptionalKey(HolderProcess) }), SessionsState = Schema.Struct({
+  v: Schema.Literal(1),
+  turns: Schema.Int,
+  open: Schema.OptionFromNullOr(HeldTurn),
+  title: Schema.OptionFromNullOr(Schema.String),
+  inbox: Schema.Array(InboxSlot)
+}), Ownership = Schema.Union([
+  Schema.Struct({
+    mode: Schema.Literal("lease"),
+    ttlMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1000)),
+    renew: Schema.Union([Schema.Literals(["none", "on-commit"]), Schema.Struct({ everyMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(100)) })])
+  }),
+  Schema.Struct({ mode: Schema.Literal("process") })
+]), SessionsConfig = Schema.Struct({
+  ownership: Ownership,
+  titleChars: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 500 })),
+  inbox: Schema.Struct({
+    maxPending: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1000 })),
+    attempts: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 10 }))
+  }),
+  writer: Schema.Struct({
+    capacity: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1e5 })),
+    batch: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1e4 }))
+  }),
+  retries: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 64 }))
+}), sessionsDefaults = {
+  ownership: { mode: "lease", ttlMs: 60000, renew: "on-commit" },
+  titleChars: 80,
+  inbox: { maxPending: 20, attempts: 2 },
+  writer: { capacity: 1024, batch: 64 },
+  retries: 8
+};

package/dist/sessions.adapter.d.ts

@@ -0,0 +1,15 @@
+import { Layer } from "effect";
+import { SessionLog, Sessions, TurnAdmission } from "@xandreed/core";
+import type { ProcessLiveness, SessionsConfig } from "./sessions-state.entity.js";
+/**
+ * Sessions over a SessionLog. The state (turns, the open turn, the title,
+ * the inbox) is kept in the head and changed only by guarded commits, with
+ * the events that justify it, so every instance over the same log agrees.
+ * Turns are written by their `TurnWriter`; everything else here is one
+ * compare-and-swap loop that plans again after a conflict. Under process
+ * ownership, `liveness` names this process in the turns it holds and tells
+ * whether another's still runs (by default, by host, pid and `kill(pid, 0)`).
+ */
+export declare const SessionsLive: (config: SessionsConfig, options?: {
+    readonly liveness?: ProcessLiveness;
+}) => Layer.Layer<Sessions, never, SessionLog | TurnAdmission>;

package/dist/sessions.adapter.js

@@ -0,0 +1,248 @@
+import { Clock, Effect, Exit, Layer, Option, PubSub, Ref, Scope, Stream } from "effect";
+import {
+  canonicalJson,
+  ConversationId,
+  EntryId,
+  InboxFull,
+  KeyConflict,
+  NothingPending,
+  RESERVED_KINDS,
+  ReservedKind,
+  SessionBusy,
+  SessionLog,
+  SessionLogError,
+  SessionMissing,
+  Sessions,
+  TurnAdmission,
+  TurnDuplicate,
+  turnEndedDraft,
+  turnStartedDraft,
+  turnStartedOf,
+  UserMessage
+} from "@xandreed/core";
+import { processLiveness } from "./process-liveness.adapter.js";
+import { closedState, heldTurn, pendingOf, stateJson, stateOf, titleOf, viewOf } from "./sessions-state.entity.functions.js";
+import { makeTurnWriter } from "./turn-writer.adapter.js";
+const storage = (code) => (error) => new SessionLogError({ code, message: error.message }), standalone = (drafts) => drafts.map((draft) => ({ kind: draft.kind, turn: Option.none(), data: draft.data }));
+export const SessionsLive = (config, options) => Layer.effect(Sessions, Effect.gen(function* () {
+  const log = yield* SessionLog, admission = yield* TurnAdmission, ownership = config.ownership, instance = yield* Effect.sync(() => crypto.randomUUID()), liveness = options?.liveness ?? processLiveness, holder = { instance, liveness, process: ownership.mode === "process" ? yield* liveness.current : Option.none() }, signals = yield* PubSub.unbounded(), writers = yield* Ref.make(new Map), wake = (id) => PubSub.publish(signals, id).pipe(Effect.asVoid), freshId = Effect.sync(() => ConversationId.make(crypto.randomUUID())), stateFrom = (head) => stateOf(head).pipe(Effect.mapError(storage("session.state"))), owned = (address) => log.head(address.id).pipe(Effect.flatMap((head) => head.header.owner === address.owner ? Effect.succeed(head) : Effect.fail(new SessionMissing({ session: address.id })))), viewFrom = (head) => stateFrom(head).pipe(Effect.flatMap((state) => viewOf(head, state, ownership, holder))), guarded = (address, plan, stored = () => Effect.void) => {
+    const attempt = (tries) => Effect.gen(function* () {
+      const head = yield* owned(address), planned = yield* plan(head, yield* stateFrom(head));
+      if (planned.drafts.length === 0 && Option.isNone(planned.next))
+        return { result: planned.result, head, committed: Option.none() };
+      const outcome = yield* Effect.uninterruptible(Effect.result(log.commit(address.id, {
+        expect: head.revision,
+        notAfter: Option.none(),
+        events: planned.drafts,
+        state: Option.map(planned.next, stateJson)
+      })).pipe(Effect.tap((result) => result._tag === "Success" ? stored(planned.result) : Effect.void)));
+      if (outcome._tag === "Success") {
+        yield* wake(address.id);
+        return { result: planned.result, head, committed: Option.some(outcome.success) };
+      }
+      const error = outcome.failure;
+      if (error._tag === "RevisionConflict")
+        return tries + 1 >= config.retries ? yield* Effect.fail(new SessionLogError({ code: "session.contended", message: `${config.retries} conflicting writes to ${address.id}` })) : yield* attempt(tries + 1);
+      return yield* Effect.fail(error._tag === "LeaseExpired" ? new SessionLogError({ code: "session.expired", message: "an unguarded commit expired" }) : error);
+    });
+    return attempt(0);
+  }, reaped = (head, state) => Effect.gen(function* () {
+    if (Option.isNone(state.open) || Option.isSome(yield* heldTurn(head, state, ownership, holder)))
+      return { drafts: [], state };
+    const turn = state.open.value.turn, after = closedState(state, "interrupted", config.inbox.attempts, !0), closing = yield* turnEndedDraft(turn, { reason: "interrupted", failure: Option.some({ code: "turn.lease", message: "the turn's holder stopped writing" }) }).pipe(Effect.mapError(storage("session.encode"))), dropped = after.dropped.map((id) => ({ kind: "inbox.dropped", turn: Option.some(turn), data: { id, reason: "attempts" } }));
+    return { drafts: [closing, ...dropped], state: after.state };
+  }), keyed = (id, key) => log.read(id, { after: 0, limit: Option.none(), kinds: ["turn.started"] }).pipe(Effect.flatMap((events) => Option.match(Option.fromNullishOr(events.find((event) => event.data.key === key)), {
+    onNone: () => Effect.succeed(Option.none()),
+    onSome: (event) => Effect.succeed(Option.some({ turn: Option.getOrElse(event.turn, () => 0), event }))
+  }))), inboxItems = (id, ids) => log.read(id, { after: 0, limit: Option.none(), kinds: ["inbox.queued"] }).pipe(Effect.map((events) => ids.flatMap((wanted) => Option.toArray(Option.fromNullishOr(events.find((event) => event.data.id === wanted))).map((event) => ({
+    id: wanted,
+    source: typeof event.data.source === "object" && event.data.source !== null ? event.data.source : {},
+    content: typeof event.data.content === "string" && event.data.content.length > 0 ? event.data.content : `(inbox item ${wanted})`
+  }))))), unhanded = (address, turn, exit) => guarded(address, (_head, state) => Effect.gen(function* () {
+    if (!Option.exists(state.open, (open) => open.turn === turn && open.holder === instance))
+      return { drafts: [], next: Option.none(), result: void 0 };
+    const reason = Exit.hasInterrupts(exit) ? "interrupted" : "failed", after = closedState(state, reason, config.inbox.attempts, !1), closing = yield* turnEndedDraft(turn, { reason, failure: Option.some({ code: "turn.unended", message: "the turn's scope closed before it ended" }) }).pipe(Effect.mapError(storage("session.encode"))), dropped = after.dropped.map((id) => ({ kind: "inbox.dropped", turn: Option.some(turn), data: { id, reason: "attempts" } }));
+    return { drafts: [closing, ...dropped], next: Option.some(after.state), result: void 0 };
+  })).pipe(Effect.timeout("10 seconds"), Effect.ignore), begin = (address, input) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const scope = yield* Effect.scope, at = yield* Clock.currentTimeMillis, toAdmit = { session: address, origin: input._tag === "User" ? "user" : "inbox", runId: input.runId, key: input._tag === "User" ? input.key : input.runId }, unowned = yield* Ref.make(Option.none());
+    yield* Scope.addFinalizerExit(scope, (exit) => Ref.get(unowned).pipe(Effect.flatMap(Option.match({ onNone: () => Effect.void, onSome: (turn) => unhanded(address, turn, exit) }))));
+    const begun = yield* restore(admission.admit(toAdmit, guarded(address, (head, stored) => Effect.gen(function* () {
+      const reap = yield* reaped(head, stored), state = reap.state;
+      if (input._tag === "User") {
+        const previous = yield* keyed(address.id, input.key);
+        if (Option.isSome(previous)) {
+          const started = yield* turnStartedOf(previous.value.event).pipe(Effect.mapError(storage("session.decode"))), same = started.userMessage.text === input.userMessage.text && canonicalJson(started.command) === canonicalJson(input.command);
+          return yield* Effect.fail(same ? new TurnDuplicate({ session: address.id, turn: previous.value.turn, open: Option.exists(state.open, (open) => open.turn === previous.value.turn) }) : new KeyConflict({ session: address.id, key: input.key, turn: previous.value.turn }));
+        }
+      }
+      if (Option.isSome(state.open))
+        return yield* Effect.fail(new SessionBusy({ session: address.id, turn: state.open.value.turn }));
+      const waiting = input._tag === "Inbox" ? pendingOf(state).map((slot) => slot.id) : [];
+      if (input._tag === "Inbox" && waiting.length === 0)
+        return yield* Effect.fail(new NothingPending({ session: address.id }));
+      const claimed = yield* inboxItems(address.id, waiting), userMessage = input._tag === "User" ? input.userMessage : new UserMessage({ text: claimed.map((item) => item.content).join(`
+
+`) }), turn = state.turns + 1, key = input._tag === "User" ? input.key : input.runId, open = {
+        turn,
+        runId: input.runId,
+        key,
+        origin: input._tag === "User" ? "user" : "inbox",
+        holder: instance,
+        expiresAt: ownership.mode === "lease" ? Option.some(head.now + ownership.ttlMs) : Option.none(),
+        process: holder.process
+      }, next = {
+        ...state,
+        turns: turn,
+        open: Option.some(open),
+        title: Option.orElse(state.title, () => input._tag === "User" ? Option.some(titleOf(input.userMessage.text, config.titleChars)) : Option.none()),
+        inbox: state.inbox.map((slot) => waiting.includes(slot.id) ? { ...slot, claimedBy: Option.some(turn) } : slot)
+      }, starting = yield* turnStartedDraft(turn, {
+        runId: input.runId,
+        key,
+        origin: open.origin,
+        userMessage,
+        command: input._tag === "User" ? input.command : {},
+        claimed: waiting,
+        entry: EntryId.make(`${input.runId}:0`),
+        at
+      }).pipe(Effect.mapError(storage("session.encode"))), admitted = {
+        session: address,
+        turn,
+        runId: input.runId,
+        key,
+        origin: open.origin,
+        userMessage,
+        command: input._tag === "User" ? input.command : {},
+        claimed
+      };
+      return { drafts: [...reap.drafts, starting], next: Option.some(next), result: { admitted, next } };
+    }), (opened) => Ref.set(unowned, Option.some(opened.admitted.turn))))), committed = yield* Option.match(begun.committed, {
+      onNone: () => Effect.fail(new SessionLogError({ code: "session.begin", message: "the turn was not committed" })),
+      onSome: Effect.succeed
+    }), started = yield* Option.match(Option.fromNullishOr(committed.events.at(-1)), {
+      onNone: () => Effect.fail(new SessionLogError({ code: "session.begin", message: "the turn's start was not stored" })),
+      onSome: Effect.succeed
+    });
+    yield* Effect.addFinalizer(() => Ref.update(writers, (all) => new Map([...all].filter(([id, open]) => id !== address.id || open.turn !== begun.result.admitted.turn))));
+    const open = yield* makeTurnWriter({
+      log,
+      config,
+      instance,
+      header: begun.head.header,
+      admitted: begun.result.admitted,
+      started,
+      position: { revision: committed.revision, seq: committed.seq, state: begun.result.next, storageAt: committed.at },
+      wake: wake(address.id)
+    }, scope);
+    yield* Ref.set(unowned, Option.none());
+    yield* Ref.update(writers, (all) => new Map([...all, [address.id, { ...open, turn: begun.result.admitted.turn }]]));
+    return open.writer;
+  })), closeLocal = (id, reason, turn) => Ref.get(writers).pipe(Effect.flatMap((all) => Option.match(Option.fromNullishOr(all.get(id)), {
+    onNone: () => Effect.void,
+    onSome: (open) => Option.match(turn, { onNone: () => !0, onSome: (wanted) => wanted === open.turn }) ? open.close(reason) : Effect.void
+  }))), drain = (address, run, options) => {
+    const maxTurns = options?.maxTurns ?? 3, once = Effect.scoped(Effect.gen(function* () {
+      const writer = yield* begin(address, { _tag: "Inbox", runId: yield* Effect.sync(() => crypto.randomUUID()) }), exit = yield* Effect.exit(run(writer));
+      if (exit._tag === "Failure")
+        yield* Effect.logWarning(`inbox turn ${writer.admitted.turn} of ${address.id} failed`);
+      yield* writer.end({
+        reason: exit._tag === "Success" ? "completed" : "failed",
+        failure: exit._tag === "Success" ? Option.none() : Option.some({ code: "inbox.turn", message: "the inbox turn failed" })
+      }).pipe(Effect.ignore);
+      return !0;
+    })).pipe(Effect.catchTags({
+      NothingPending: () => Effect.succeed(!1),
+      SessionBusy: () => Effect.succeed(!1),
+      TurnDuplicate: () => Effect.succeed(!1),
+      KeyConflict: () => Effect.succeed(!1),
+      TurnRefused: (refused) => Effect.logWarning(`inbox turn of ${address.id} refused: ${refused.message}`).pipe(Effect.as(!1))
+    })), loop = (turns) => turns >= maxTurns ? Effect.succeed({ turns }) : once.pipe(Effect.flatMap((ran) => ran ? loop(turns + 1) : Effect.succeed({ turns })));
+    return loop(0);
+  };
+  return Sessions.of({
+    create: (input) => Effect.gen(function* () {
+      const head = yield* log.create({
+        id: input.id ?? (yield* freshId),
+        owner: input.owner,
+        origin: input.origin ?? "user",
+        createdAt: yield* Clock.currentTimeMillis,
+        meta: input.meta ?? {},
+        parent: Option.none()
+      }).pipe(Effect.catchTag("SessionMissing", (error) => Effect.fail(new SessionLogError({ code: "session.create", message: `no parent ${error.session}` }))));
+      return yield* viewFrom(head);
+    }),
+    fork: (parent, input) => Effect.gen(function* () {
+      yield* owned(parent);
+      const endings = input.inherit ? yield* log.read(parent.id, { after: 0, limit: Option.none(), kinds: ["turn.ended"] }) : [], last = Option.fromNullishOr(endings.at(-1)), head = yield* log.create({
+        id: input.id ?? (yield* freshId),
+        owner: parent.owner,
+        origin: input.origin,
+        createdAt: yield* Clock.currentTimeMillis,
+        meta: input.meta ?? {},
+        parent: Option.some({
+          id: parent.id,
+          through: Option.match(last, { onNone: () => 0, onSome: (event) => event.seq }),
+          turnAtFork: Option.match(last, { onNone: () => 0, onSome: (event) => Option.getOrElse(event.turn, () => 0) })
+        })
+      });
+      return yield* viewFrom(head);
+    }),
+    get: (address) => owned(address).pipe(Effect.flatMap(viewFrom)),
+    list: (query) => Effect.gen(function* () {
+      const limit = query.limit ?? 50, heads = yield* log.list({
+        owner: query.owner,
+        limit,
+        before: Option.fromNullishOr(query.before),
+        parent: Option.fromNullishOr(query.parent)
+      }), sessions = yield* Effect.forEach(heads, viewFrom), last = Option.fromNullishOr(heads.at(-1));
+      return {
+        sessions,
+        next: heads.length < limit ? Option.none() : Option.map(last, (head) => ({ updatedAt: head.updatedAt, id: head.header.id }))
+      };
+    }),
+    remove: (address) => Effect.gen(function* () {
+      yield* owned(address);
+      yield* log.remove(address.id);
+      yield* closeLocal(address.id, "removed", Option.none());
+      yield* wake(address.id);
+    }),
+    read: (address, query) => owned(address).pipe(Effect.flatMap(() => log.read(address.id, {
+      after: query?.after ?? 0,
+      limit: Option.fromNullishOr(query?.limit),
+      kinds: query?.kinds ?? []
+    }))),
+    changes: (address) => Stream.fromPubSub(signals).pipe(Stream.filter((id) => id === address.id), Stream.map(() => {
+      return;
+    })),
+    lookup: (address, key) => owned(address).pipe(Effect.flatMap(() => keyed(address.id, key)), Effect.map(Option.map((found) => found.turn))),
+    transact: (address, decide) => guarded(address, (head, state) => Effect.gen(function* () {
+      const decision = yield* decide(yield* viewOf(head, state, ownership, holder)), reserved = decision.drafts.find((draft) => RESERVED_KINDS.includes(draft.kind));
+      if (reserved !== void 0)
+        return yield* Effect.fail(new ReservedKind({ kind: reserved.kind }));
+      return { drafts: standalone(decision.drafts), next: Option.none(), result: decision.result };
+    })).pipe(Effect.map((done) => ({ result: done.result, events: Option.match(done.committed, { onNone: () => [], onSome: (committed) => committed.events }) }))),
+    cancel: (address, turn) => guarded(address, (_head, state) => Effect.gen(function* () {
+      if (!Option.exists(state.open, (open) => open.turn === turn))
+        return { drafts: [], next: Option.none(), result: { cancelled: !1, pending: pendingOf(state).length } };
+      const after = closedState(state, "cancelled", config.inbox.attempts, !0);
+      return { drafts: [yield* turnEndedDraft(turn, { reason: "cancelled", failure: Option.none() }).pipe(Effect.mapError(storage("session.encode")))], next: Option.some(after.state), result: { cancelled: !0, pending: pendingOf(after.state).length } };
+    })).pipe(Effect.tap((done) => done.result.cancelled ? closeLocal(address.id, "cancelled", Option.some(turn)) : Effect.void), Effect.map((done) => done.result)),
+    begin,
+    deliver: (address, item) => guarded(address, (head, stored) => Effect.gen(function* () {
+      const reap = yield* reaped(head, stored), state = reap.state, reapedOnly = { drafts: reap.drafts, next: reap.drafts.length === 0 ? Option.none() : Option.some(state) };
+      if (state.inbox.some((slot) => slot.id === item.id))
+        return { ...reapedOnly, result: { delivered: !1, pending: pendingOf(state).length } };
+      if ((yield* log.read(address.id, { after: 0, limit: Option.none(), kinds: ["inbox.queued"] })).some((event) => event.data.id === item.id))
+        return { ...reapedOnly, result: { delivered: !1, pending: pendingOf(state).length } };
+      if (pendingOf(state).length >= config.inbox.maxPending)
+        return yield* Effect.fail(new InboxFull({ session: address.id, pending: pendingOf(state).length }));
+      const next = { ...state, inbox: [...state.inbox, { id: item.id, attempts: 0, claimedBy: Option.none() }] };
+      return {
+        drafts: [...reap.drafts, { kind: "inbox.queued", turn: Option.none(), data: { id: item.id, source: item.source, content: item.content } }],
+        next: Option.some(next),
+        result: { delivered: !0, pending: pendingOf(next).length }
+      };
+    })).pipe(Effect.map((done) => done.result)),
+    drain
+  });
+}));

package/dist/sessions.adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/turn-writer.adapter.d.ts

@@ -0,0 +1,41 @@
+import { Effect, Scope } from "effect";
+import { TurnClosed } from "@xandreed/core";
+import type { AdmittedTurn, SessionHeader, SessionLog, SessionLogEvent, TurnWriter } from "@xandreed/core";
+import type { Context } from "effect";
+import type { SessionsConfig, SessionsState } from "./sessions-state.entity.js";
+type Log = Context.Service.Shape<typeof SessionLog>;
+export interface TurnWriterInput {
+    readonly log: Log;
+    readonly config: SessionsConfig;
+    readonly instance: string;
+    readonly header: SessionHeader;
+    readonly admitted: AdmittedTurn;
+    readonly started: SessionLogEvent;
+    /** The begin commit: the head after it. */
+    readonly position: {
+        readonly revision: number;
+        readonly seq: number;
+        readonly state: SessionsState;
+        readonly storageAt: number;
+    };
+    /** Signal followers on this instance after each commit. */
+    readonly wake: Effect.Effect<void>;
+}
+/** The writer, and how the sessions service closes it from outside (a cancel or removal on this instance). */
+export interface OpenWriter {
+    readonly writer: TurnWriter;
+    readonly close: (reason: TurnClosed["reason"]) => Effect.Effect<void>;
+    readonly ended: Effect.Effect<boolean>;
+}
+/**
+ * The open turn's writer. Items are stored strictly in queue order by one
+ * fiber forked in `scope`; consecutive appends share one commit. Every
+ * commit expects the revision the writer last saw and, under a lease, is
+ * refused by the store once the lease has run out. On a revision conflict
+ * the writer reads the head again: while the turn is still its own it takes
+ * the others' events (handing them to later decisions) and retries,
+ * otherwise the turn was closed elsewhere and every later write fails with
+ * `turn.closed`.
+ */
+export declare const makeTurnWriter: (input: TurnWriterInput, scope: Scope.Scope) => Effect.Effect<OpenWriter>;
+export {};

package/dist/turn-writer.adapter.js

@@ -0,0 +1,142 @@
+import { Clock, Deferred, Effect, Exit, HashSet, Option, Queue, Ref, Schedule, Scope, Semaphore } from "effect";
+import { HarnessError, turnEndedDraft, TurnClosed } from "@xandreed/core";
+import { closedState, pendingOf, stateJson, stateOf } from "./sessions-state.entity.functions.js";
+const harness = (code, message) => new HarnessError({ code, message }), groupsOf = (items) => items.reduce((groups, item) => {
+  const last = groups.at(-1);
+  return last?._tag === "Append" && item._tag === "Append" ? [...groups.slice(0, -1), { _tag: "Append", drafts: [...last.drafts, ...item.drafts] }] : [...groups, item];
+}, []);
+export const makeTurnWriter = (input, scope) => Effect.gen(function* () {
+  const { log, config, admitted } = input, id = admitted.session.id, ownership = config.ownership, queue = yield* Queue.bounded(config.writer.capacity), failed = yield* Ref.make(Option.none()), ended = yield* Ref.make(!1), sealed = yield* Ref.make(!1), tried = yield* Ref.make(!1), admission = yield* Semaphore.make(1), ending = yield* Ref.make(Option.none()), waiting = yield* Ref.make(HashSet.empty()), closed = yield* Deferred.make(), foreign = yield* Ref.make([]), position = yield* Ref.make({ ...input.position, localAt: yield* Clock.currentTimeMillis }), refuseWaiting = (error) => Ref.get(waiting).pipe(Effect.flatMap((all) => Effect.forEach(all, (refuse) => refuse(error), { discard: !0 }))), close = (reason) => Effect.gen(function* () {
+    if (yield* Ref.get(ended))
+      return;
+    const error = harness("turn.closed", `turn ${admitted.turn} was ${reason}`);
+    yield* Ref.update(failed, Option.orElse(() => Option.some(error)));
+    yield* Deferred.succeed(closed, new TurnClosed({ session: id, turn: admitted.turn, reason }));
+    yield* refuseWaiting(error);
+  }), refuseIfFailed = Ref.get(failed).pipe(Effect.flatMap(Option.match({ onNone: () => Effect.void, onSome: Effect.fail }))), refuseIfSealed = Effect.all([Ref.get(sealed), Ref.get(ended)]).pipe(Effect.flatMap(([closing, done]) => !closing ? Effect.void : Effect.fail(harness("turn.closed", done ? `turn ${admitted.turn} has ended` : `turn ${admitted.turn} is ending`)))), storageNow = Effect.gen(function* () {
+    const at = yield* Ref.get(position);
+    return at.storageAt + ((yield* Clock.currentTimeMillis) - at.localAt);
+  }), renewed = (state, now, always) => ownership.mode === "lease" && (always || ownership.renew !== "none") ? { ...state, open: Option.map(state.open, (open) => ({ ...open, expiresAt: Option.some(now + ownership.ttlMs) })) } : state, stamped = (drafts) => drafts.map((draft) => ({ kind: draft.kind, turn: Option.some(admitted.turn), data: draft.data })), reasonIn = (events) => events.some((event) => event.kind === "turn.ended" && Option.contains(event.turn, admitted.turn) && event.data.reason === "cancelled") ? "cancelled" : "interrupted", rebase = (seen) => Effect.gen(function* () {
+    const removed = () => close("removed").pipe(Effect.andThen(Effect.fail(harness("turn.closed", "the session was removed")))), head = yield* log.head(id).pipe(Effect.catchTag("SessionMissing", removed)), state = yield* stateOf(head).pipe(Effect.mapError((error) => harness("session.state", error.message))), since = log.read(id, { after: seen.seq, limit: Option.none(), kinds: [] }).pipe(Effect.catchTag("SessionMissing", removed), Effect.map((events) => events.filter((event) => event.seq <= head.seq)));
+    if (!Option.exists(state.open, (open) => open.turn === admitted.turn && open.holder === input.instance)) {
+      yield* close(reasonIn(yield* since.pipe(Effect.catchTag("SessionLogError", () => Effect.succeed([])))));
+      return !1;
+    }
+    const events = yield* since;
+    yield* Ref.update(foreign, (all) => [...all, ...events]);
+    yield* Ref.set(position, { revision: head.revision, seq: head.seq, state, storageAt: head.now, localAt: yield* Clock.currentTimeMillis });
+    return !0;
+  }).pipe(Effect.catchTag("SessionLogError", (error) => Effect.fail(harness("session.log", error.message)))), commitPlan = (plan, options) => {
+    const attempt = (tries) => Effect.gen(function* () {
+      yield* refuseIfFailed;
+      const at = yield* Ref.get(position), decided = yield* plan(at, yield* Ref.get(foreign)), now = yield* storageNow, next = options.renew ? renewed(decided.next, now, !1) : decided.next, notAfter = ownership.mode === "lease" ? Option.flatMap(at.state.open, (open) => open.expiresAt) : Option.none(), outcome = yield* Effect.result(log.commit(id, {
+        expect: at.revision,
+        notAfter,
+        events: stamped(decided.drafts),
+        state: next === at.state ? Option.none() : Option.some(stateJson(next))
+      }));
+      if (outcome._tag === "Success") {
+        const committed = outcome.success;
+        yield* Ref.set(position, { revision: committed.revision, seq: committed.seq, state: next, storageAt: committed.at, localAt: yield* Clock.currentTimeMillis });
+        yield* input.wake;
+        return { result: decided.result, events: committed.events };
+      }
+      const error = outcome.failure;
+      if (error._tag === "RevisionConflict") {
+        if (!(yield* rebase(at)))
+          return yield* Effect.fail(harness("turn.closed", `turn ${admitted.turn} was closed elsewhere`));
+        return tries + 1 >= config.retries ? yield* Effect.fail(harness("session.contended", `turn ${admitted.turn}: ${config.retries} conflicting writes`)) : yield* attempt(tries + 1);
+      }
+      if (error._tag === "LeaseExpired") {
+        yield* close("interrupted");
+        return yield* Effect.fail(harness("turn.closed", `turn ${admitted.turn}'s lease ran out`));
+      }
+      if (error._tag === "SessionMissing") {
+        yield* close("removed");
+        return yield* Effect.fail(harness("turn.closed", "the session was removed"));
+      }
+      return yield* Effect.fail(harness("session.log", error.message));
+    });
+    return attempt(0);
+  }, latch = (effect) => effect.pipe(Effect.map(Option.some), Effect.catch((error) => Ref.update(failed, Option.orElse(() => Option.some(error))).pipe(Effect.as(Option.none())))), unchanged = (result, drafts) => (at) => Effect.succeed({ drafts, next: at.state, result }), process = (item) => item._tag === "Tracked" ? process(item.item).pipe(Effect.ensuring(item.settled)) : Ref.get(failed).pipe(Effect.flatMap((failure) => {
+    if (item._tag === "Marker")
+      return Option.match(failure, { onNone: () => Deferred.succeed(item.done, void 0), onSome: (error) => Deferred.fail(item.done, error) }).pipe(Effect.asVoid);
+    if (item._tag === "Run" || item._tag === "Commit")
+      return item._tag === "Run" ? item.run : item.commit;
+    return Option.isSome(failure) ? Effect.void : latch(commitPlan(unchanged(void 0, item.drafts), { renew: !0 })).pipe(Effect.asVoid);
+  }));
+  yield* Effect.forkIn(Queue.takeBetween(queue, 1, config.writer.batch).pipe(Effect.flatMap((chunk) => Effect.forEach(groupsOf(chunk), process, { discard: !0 })), Effect.forever), scope);
+  const offer = (item) => (item._tag === "Append" ? Ref.set(tried, !0) : Effect.void).pipe(Effect.andThen(Queue.offer(queue, item)), Effect.flatMap((accepted) => accepted ? Effect.void : Effect.fail(harness("turn.closed", `turn ${admitted.turn}'s scope closed`)))), enqueue = (result, item) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const refuse = (error) => Deferred.fail(result, error).pipe(Effect.asVoid), settled = Ref.update(waiting, HashSet.remove(refuse));
+    yield* Ref.update(waiting, HashSet.add(refuse));
+    yield* restore(offer({ _tag: "Tracked", item, settled })).pipe(Effect.onInterrupt(() => settled), Effect.tapError((error) => refuse(error).pipe(Effect.andThen(settled))));
+  })), admit = (result, item, tries) => admission.withPermits(1)(refuseIfFailed.pipe(Effect.andThen(refuseIfSealed), Effect.andThen(tries ? Ref.set(tried, !0) : Effect.void), Effect.andThen(enqueue(result, item)))), inOrder = (commit, tries) => Effect.gen(function* () {
+    const result = yield* Deferred.make();
+    yield* admit(result, { _tag: "Commit", commit: Effect.exit(commit).pipe(Effect.flatMap((exit) => Deferred.done(result, exit)), Effect.asVoid) }, tries);
+    return yield* Deferred.await(result);
+  }), flush = Deferred.make().pipe(Effect.flatMap((done) => admission.withPermits(1)(refuseIfFailed.pipe(Effect.andThen(enqueue(done, { _tag: "Marker", done })))).pipe(Effect.andThen(Deferred.await(done))))), endNow = (ending) => Effect.gen(function* () {
+    const done = yield* commitPlan((at) => Effect.gen(function* () {
+      const after = closedState(at.state, ending.reason, config.inbox.attempts, yield* Ref.get(tried)), closing = yield* turnEndedDraft(admitted.turn, ending).pipe(Effect.mapError((error) => harness("session.encode", error.message))), dropped = after.dropped.map((item) => ({ kind: "inbox.dropped", data: { id: item, reason: "attempts" } }));
+      return { drafts: [{ kind: closing.kind, data: closing.data }, ...dropped], next: after.state, result: pendingOf(after.state).length };
+    }), { renew: !1 });
+    yield* Ref.set(ended, !0);
+    return { pending: done.result };
+  }), reopen = Ref.set(ending, Option.none()).pipe(Effect.andThen(Ref.set(sealed, !1))), settleEnd = (done, exit) => (Exit.isSuccess(exit) || Option.exists(Exit.findErrorOption(exit), (error) => error.code === "turn.closed") ? Effect.void : reopen).pipe(Effect.andThen(Deferred.done(done, exit)), Effect.asVoid), end = (value) => Effect.gen(function* () {
+    const result = yield* admission.withPermits(1)(Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const current = yield* Ref.get(ending);
+      if (Option.isSome(current))
+        return current.value;
+      yield* refuseIfFailed;
+      const done = yield* Deferred.make();
+      yield* Ref.set(sealed, !0);
+      yield* Ref.set(ending, Option.some(done));
+      yield* restore(enqueue(done, { _tag: "Commit", commit: Effect.exit(endNow(value)).pipe(Effect.flatMap((exit) => settleEnd(done, exit))) })).pipe(Effect.onInterrupt(() => reopen));
+      return done;
+    })));
+    return yield* Deferred.await(result);
+  });
+  if (ownership.mode === "lease" && typeof ownership.renew === "object") {
+    const renew = inOrder(commitPlan((at) => Effect.gen(function* () {
+      return { drafts: [], next: renewed(at.state, yield* storageNow, !0), result: void 0 };
+    }), { renew: !1 }), !1).pipe(Effect.ignore);
+    yield* Effect.forkIn(renew.pipe(Effect.repeat(Schedule.spaced(`${ownership.renew.everyMs} millis`)), Effect.asVoid), scope);
+  }
+  yield* Scope.addFinalizerExit(scope, (exit) => Ref.get(ended).pipe(Effect.flatMap((done) => done ? Effect.void : end({
+    reason: Exit.hasInterrupts(exit) ? "interrupted" : "failed",
+    failure: Option.some({ code: "turn.unended", message: "the turn's scope closed before it ended" })
+  }).pipe(Effect.timeout("10 seconds"), Effect.ignore)), Effect.ensuring(Effect.gen(function* () {
+    const error = harness("turn.closed", `turn ${admitted.turn}'s scope closed`);
+    yield* Ref.update(failed, Option.orElse(() => Option.some(error)));
+    yield* Queue.shutdown(queue);
+    yield* refuseWaiting(error);
+  }))));
+  return { writer: {
+    admitted,
+    started: input.started,
+    history: (kinds) => historyOf(log, input.header, input.started, kinds),
+    snapshot: (kinds, after) => flush.pipe(Effect.andThen(after === void 0 ? historyOf(log, input.header, input.started, kinds, !0) : log.read(id, { after, limit: Option.none(), kinds }).pipe(Effect.mapError((error) => harness("session.log", error._tag))))),
+    append: (drafts) => admission.withPermits(1)(refuseIfFailed.pipe(Effect.andThen(refuseIfSealed), Effect.andThen(drafts.length === 0 ? Effect.void : offer({ _tag: "Append", drafts })))),
+    write: (op) => Effect.gen(function* () {
+      const result = yield* Deferred.make(), run = Effect.exit(Effect.raceFirst(refuseIfFailed.pipe(Effect.andThen(op)), Deferred.await(closed).pipe(Effect.flatMap((note) => Effect.fail(harness("turn.closed", `turn ${admitted.turn} was ${note.reason}`)))))).pipe(Effect.flatMap((exit) => Deferred.done(result, exit)), Effect.asVoid);
+      yield* admit(result, { _tag: "Run", run }, !0);
+      return yield* Deferred.await(result);
+    }),
+    transact: (decide) => inOrder(commitPlan((at, others) => decide(others).pipe(Effect.map((decision) => ({ drafts: decision.drafts, next: at.state, result: decision.result }))), { renew: !0 }), !0),
+    flush,
+    end,
+    closed: Deferred.await(closed)
+  }, close, ended: Ref.get(ended) };
+});
+const historyOf = (log, header, started, kinds, includeCurrent = !1) => {
+  const ancestors = (lineage) => Option.match(lineage, {
+    onNone: () => Effect.succeed([]),
+    onSome: (parent) => parent.through <= 0 ? Effect.succeed([]) : Effect.gen(function* () {
+      const head = yield* log.head(parent.id).pipe(Effect.mapError((error) => harness("session.log", `the fork's parent: ${error._tag}`))), earlier = yield* ancestors(head.header.parent), events = yield* log.read(parent.id, { after: 0, limit: Option.none(), kinds }).pipe(Effect.mapError((error) => harness("session.log", error._tag)));
+      return [...earlier, ...events.filter((event) => event.seq <= parent.through)];
+    })
+  });
+  return Effect.gen(function* () {
+    const inherited = yield* ancestors(header.parent), own = yield* log.read(header.id, { after: 0, limit: Option.none(), kinds }).pipe(Effect.mapError((error) => harness("session.log", error._tag)));
+    return [...inherited, ...own.filter((event) => includeCurrent || event.seq < started.seq)];
+  });
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@xandreed/plugin-sessions",
+  "version": "0.8.0-next.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@xandreed/core": "0.8.0-next.0",
+    "effect": "4.0.0-rc.118"
+  },
+  "private": false,
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "skills",
+    "profiles",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "license": "MIT"
+}