@astrosheep/square 0.3.106 → 0.4.1

package/dist/session-lifecycle.js

@@ -1,47 +1,45 @@
-import { Square } from './square-api.js';
-import { harnessOwner } from './owner.js';
-import { projectSessionCandidates, projectSessionSeats } from './inbox.js';
-function ownerFor(provider, sessionId) {
-    return harnessOwner({ channel: provider === 'claude' ? 'claude-code' : provider, session: sessionId });
+import { DeliveryLedger, deliveryLedgerLocation } from './delivery-ledger.js';
+function openLedger(env) {
+    return DeliveryLedger.open({ location: deliveryLedgerLocation(env) });
 }
-/** Host shutdown suspends execution, not membership. Discovery never grants custody. */
-export async function detachSessionSeats(provider, sessionId, env = process.env) {
-    const owner = ownerFor(provider, sessionId);
-    for (const { location, seat } of await projectSessionSeats({ owner, env })) {
-        let square;
-        try {
-            square = await Square.at({ path: location, env });
-            await square.detach(seat.participant, { owner, generation: seat.generation });
-        }
-        catch { /* One unavailable or replaced seat must not block cleanup of the others. */ }
-        finally {
-            await square?.close();
-        }
-    }
+/** Rotate the captured session generation; omitted routes retain its registrations. */
+export async function attachDeliverySession(owner, env = process.env, routes, signal) {
+    return attach(owner, env, routes, false, signal);
+}
+/** Replace the supplied route kinds while preserving every other registered route. */
+export async function attachDeliverySessionRoutes(owner, env = process.env, routes, signal) {
+    return attach(owner, env, routes, true, signal);
 }
-/** Restore only detached, standing seats of this exact owner before starting a receiver. */
-export async function restoreSessionSeats(owner, env = process.env, wakeAddress, signal) {
-    const locations = new Set((await projectSessionCandidates({ owner, env })).map(candidate => candidate.location));
-    for (const location of locations) {
+async function attach(owner, env, routes, merge, signal) {
+    if (signal?.aborted)
+        return false;
+    const ledger = await openLedger(env);
+    try {
+        const previous = await ledger.session(owner);
         if (signal?.aborted)
-            return;
-        let square;
-        try {
-            square = await Square.at({ path: location, env }, { signal });
-            for (const seat of await square.seatsOf(owner)) {
-                if (signal?.aborted)
-                    return;
-                if (seat.attachment !== 'detached')
-                    continue;
-                try {
-                    await square.reattach(seat.name, { owner, wakeAddress }, { signal });
-                }
-                catch { /* A replacement or one failed seat does not block its peers. */ }
-            }
-        }
-        catch { /* An indexed location is only a candidate, not a promise of availability. */ }
-        finally {
-            await square?.close();
-        }
+            return false;
+        const selected = merge && routes ? [...(previous?.routes ?? []).filter(old => !routes.some(route => route.kind === old.kind)), ...routes] : routes ?? previous?.routes ?? [];
+        return await ledger.attach({ owner, expectedGeneration: previous?.generation ?? null, routes: selected });
+    }
+    finally {
+        await ledger.close();
+    }
+}
+export async function detachDeliverySession(owner, generation, env = process.env) {
+    const ledger = await openLedger(env);
+    try {
+        return await ledger.detach({ owner, generation });
+    }
+    finally {
+        await ledger.close();
+    }
+}
+export async function markDeliverySessionDeleted(owner, generation, env = process.env) {
+    const ledger = await openLedger(env);
+    try {
+        return await ledger.markDeleted({ owner, generation });
+    }
+    finally {
+        await ledger.close();
     }
 }

package/dist/sqlite-framing.d.ts

@@ -0,0 +1,8 @@
+import type { DatabaseSync } from 'node:sqlite';
+/** The only schema owned by the shared physical store. */
+export declare const STORAGE_META_SQL = "CREATE TABLE storage_meta (\n  id INTEGER PRIMARY KEY CHECK (id = 1),\n  revision INTEGER NOT NULL CHECK (revision BETWEEN 0 AND 9007199254740991),\n  delivery_revision INTEGER NOT NULL CHECK (delivery_revision BETWEEN 0 AND 9007199254740991)\n);";
+export declare function initializeStorageMeta(db: DatabaseSync, revision?: number): void;
+export declare function resetStorageMeta(db: DatabaseSync): void;
+export declare function readStorageRevision(db: DatabaseSync, delivery?: boolean): number;
+/** Compare an owner's complete current schema and journal mode without modifying the database. */
+export declare function validateSchema(db: DatabaseSync, expectedSql: string, location?: string): void;

package/dist/sqlite-framing.js

@@ -0,0 +1,31 @@
+import { integer, requireFact, string } from './sqlite-values.js';
+/** The only schema owned by the shared physical store. */
+export const STORAGE_META_SQL = `CREATE TABLE storage_meta (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  revision INTEGER NOT NULL CHECK (revision BETWEEN 0 AND 9007199254740991),
+  delivery_revision INTEGER NOT NULL CHECK (delivery_revision BETWEEN 0 AND 9007199254740991)
+);`;
+export function initializeStorageMeta(db, revision = 0) {
+    integer(revision);
+    db.exec(STORAGE_META_SQL);
+    db.prepare('INSERT INTO storage_meta(id,revision,delivery_revision) VALUES(1,?,0)').run(revision);
+}
+export function resetStorageMeta(db) {
+    db.exec('DROP TABLE storage_meta');
+}
+export function readStorageRevision(db, delivery = false) {
+    const rows = db.prepare(`SELECT id, ${delivery ? 'delivery_revision' : 'revision'} AS revision FROM storage_meta`).all();
+    requireFact(rows.length === 1 && rows[0].id === 1, 'revision header is malformed.');
+    return integer(rows[0].revision);
+}
+function normalizedSql(sql) {
+    return sql.trim().replace(/;$/, '').replace(/\s+/g, ' ').replace(/\s*([(),=])\s*/g, '$1');
+}
+/** Compare an owner's complete current schema and journal mode without modifying the database. */
+export function validateSchema(db, expectedSql, location = '') {
+    const expected = expectedSql.split(';').map(s => s.trim()).filter(Boolean).map(normalizedSql).sort();
+    const actual = db.prepare("SELECT sql FROM sqlite_schema WHERE name NOT GLOB 'sqlite_*' AND sql IS NOT NULL").all()
+        .map(row => normalizedSql(string(row.sql))).sort();
+    requireFact(actual.length === expected.length && actual.every((sql, index) => sql === expected[index]), 'unsupported row schema.');
+    requireFact(db.prepare('PRAGMA journal_mode').get().journal_mode === (location === ':memory:' ? 'memory' : 'delete'), 'unsupported journal mode.');
+}

package/dist/sqlite-square.d.ts

@@ -1,42 +1,46 @@
 import { type Owner } from './model.js';
-import type { HistoryQuery, HistoryResult, JoinOptions, JoinResult, LifecycleResult, ObservationOptions, OperationControl, Participant, SquareAtInput, SquareBuildInput, SquareLocation, StatusOptions, StatusResult, ParticipantsResult, RecoveryResult, DiscoveryOptions, InboxOptions, InboxResult, StreamOptions, StreamRecord, Activity, PerceivedActivity, ChannelSendInput, ChannelSendResult } from './square-facade.js';
+import type { HistoryQuery, HistoryResult, JoinOptions, JoinResult, ObservationOptions, OperationControl, Participant, SquareAtInput, SquareBuildInput, SquareLocation, StatusOptions, StatusResult, ParticipantsResult, RecoveryResult, DiscoveryOptions, InboxOptions, InboxResult, StreamOptions, StreamRecord, Activity, PerceivedActivity, SendInput, SendResult } from './square-facade.js';
 export type * from './square-facade.js';
 export { createSquareResourceOwner } from './artifact.js';
+export { squareClock } from './operation-control.js';
 export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
 export { CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT } from './catch-decisions.js';
 export { HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT } from './views.js';
 export { DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT } from './list.js';
-export declare function squareClock(env: NodeJS.ProcessEnv, clock?: () => number): () => number;
 /** One concrete local resource, including its entry-resolved dependencies and lifetime. */
 export declare class SqliteSquare {
     readonly location: string;
     private readonly artifact;
     private readonly clock;
-    private readonly wakeTransport?;
-    private readonly indexPath?;
+    private readonly env;
     private readonly closesArtifact;
     private readonly deliveryLocation;
     private constructor();
+    private reconcile;
+    private flush;
     static at(input: SquareAtInput, control?: OperationControl): Promise<SqliteSquare>;
     static build(input: SquareBuildInput, control?: OperationControl): Promise<SqliteSquare>;
     static inMemory(input: Omit<SquareBuildInput, 'path' | 'resources'>): SqliteSquare;
-    /** Discovery is best effort and never grants write authority. */
-    private publishSeat;
+    /** Join establishes membership and local producer custody in one transaction. */
+    private joinSeat;
+    private requiredSeat;
     private observation;
     private contextObservation;
+    /** Host liveness is a read-only, non-atomic overlay; it never changes membership. */
+    private withHostPresence;
     private handle;
     private static readonly ParticipantHandle;
-    /** Direct messages use explicit recipients, not participant expression admission or body attention. */
-    send(input: ChannelSendInput, control?: OperationControl): Promise<ChannelSendResult>;
-    participant(name: string, { owner }: {
+    send(input: SendInput, control?: OperationControl): Promise<SendResult>;
+    participant(name: string, options: {
         readonly owner: Owner;
     }): Promise<Participant>;
     join(requested: string, options: JoinOptions, control?: OperationControl): Promise<JoinResult>;
-    /** Restore only a standing seat; a concurrent departure or takeover cannot be revived. */
-    reattach(name: string, { owner, wakeAddress }: Pick<JoinOptions, 'owner' | 'wakeAddress'>, control?: OperationControl): Promise<Participant | null>;
     history(query?: HistoryQuery, control?: OperationControl): Promise<HistoryResult>;
     status(options?: StatusOptions, control?: OperationControl): Promise<StatusResult>;
-    participants(options?: ObservationOptions, control?: OperationControl): Promise<ParticipantsResult>;
+    /** Local mode reads only World-known facts; it does not verify host attachment. */
+    participants(options?: ObservationOptions & {
+        readonly local?: boolean;
+    }, control?: OperationControl): Promise<ParticipantsResult>;
     recovery(requested?: string, control?: OperationControl): Promise<RecoveryResult>;
     stream(options: StreamOptions & {
         readonly recipient: string;
@@ -47,21 +51,7 @@ export declare class SqliteSquare {
     stream(options: StreamOptions, control?: OperationControl): AsyncIterable<StreamRecord>;
     seatsOf(owner: Owner): Promise<readonly import('./square-facade.js').HeldSeat[]>;
     close(): Promise<void>;
-    private heldSeat;
-    cancelDeliveries(name: string, identity: {
-        readonly owner: Owner;
-        readonly generation: import('./square-core.js').ActivityId;
-    }): Promise<boolean>;
-    detach(name: string, identity: {
-        readonly owner: Owner;
-        readonly generation: import('./square-core.js').ActivityId;
-    }): Promise<true | null>;
-    endHeld(name: string, identity: {
-        readonly owner: Owner;
-        readonly generation: import('./square-core.js').ActivityId;
-    }): Promise<LifecycleResult | null>;
 }
 export declare function diagnoseSquare(input: SquareLocation, control?: OperationControl): Promise<import("./artifact.js").DiagnoseResult>;
-export declare function migrateSquare(input: SquareLocation, control?: OperationControl): Promise<import("./square-migration.js").MigrationOutcome>;
 export declare function discover(input: SquareAtInput, options?: DiscoveryOptions, control?: OperationControl): Promise<import("./square-facade.js").DiscoveryResult>;
 export declare function inbox(input: SquareAtInput, owner: Owner, options?: InboxOptions, control?: OperationControl): Promise<InboxResult>;