@spexcode/session-application 0.6.8

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import type { Message, MessageInput, SessionProtocol } from '@spexcode/session-protocol';
+import type { SessionTopology, TopologyEdge } from '@spexcode/session-topology';
+export interface NotificationResult {
+    edge: TopologyEdge | null;
+    recipients: string[];
+    messages: Message[];
+}
+export interface SessionApplication {
+    notifyRecipients(subjectSessionId: string, message: MessageInput): NotificationResult;
+    attachAndNotify(fromSessionId: string, subjectSessionId: string, relationType: string, message: MessageInput): NotificationResult;
+}
+export declare function openSessionApplication(protocol: SessionProtocol, topology: SessionTopology): SessionApplication;
+export { openProjectSessionApplication } from './production.js';
+export { jsonMigrationFencePath, legacyResidueExists, migrateJsonSessionRecords, MIGRATED_MESSAGE_EVENT, MIGRATED_STATE_EVENT } from './migration.js';
+export type { CommittedSessionChange, ConversationMessageInput, CreateSessionInput, LocalityPrecondition, NativeRuntimeIdentity, ProductionSessionApplication, ProjectSessionApplicationOptions, SessionState, SessionStateChange, TransitionSessionInput, } from './production.js';
+export type { SessionEvent } from '@spexcode/session-events';
+export type { JsonMigrationRecord, JsonResidueMigrationReport, JsonSessionMigrationOptions, JsonSessionMigrationReport, } from './migration.js';

package/dist/index.js

@@ -0,0 +1,35 @@
+function enqueueForRecipients(tx, topology, subjectSessionId, message) {
+    const recipients = topology.recipients(subjectSessionId, tx);
+    const messages = recipients.map(recipient => tx.enqueue(recipient, {
+        ...message,
+        senderSessionId: message.senderSessionId === undefined
+            ? subjectSessionId
+            : message.senderSessionId,
+    }));
+    return { edge: null, recipients, messages };
+}
+export function openSessionApplication(protocol, topology) {
+    if (!protocol || typeof protocol.withTransaction !== 'function') {
+        throw new TypeError('session application requires a live protocol handle');
+    }
+    if (!topology || typeof topology.recipients !== 'function' || typeof topology.attach !== 'function') {
+        throw new TypeError('session application requires a live topology handle');
+    }
+    const run = (subjectSessionId, message, edge, tx) => {
+        const result = enqueueForRecipients(tx, topology, subjectSessionId, message);
+        return { ...result, edge };
+    };
+    return {
+        notifyRecipients(subjectSessionId, message) {
+            return protocol.withTransaction(tx => run(subjectSessionId, message, null, tx));
+        },
+        attachAndNotify(fromSessionId, subjectSessionId, relationType, message) {
+            return protocol.withTransaction(tx => {
+                const edge = topology.attach(tx, fromSessionId, subjectSessionId, relationType);
+                return run(subjectSessionId, message, edge, tx);
+            });
+        },
+    };
+}
+export { openProjectSessionApplication } from './production.js';
+export { jsonMigrationFencePath, legacyResidueExists, migrateJsonSessionRecords, MIGRATED_MESSAGE_EVENT, MIGRATED_STATE_EVENT } from './migration.js';

package/dist/migration.d.ts

@@ -0,0 +1,51 @@
+import { type LocalityPrecondition, type ProductionSessionApplication } from './production.js';
+/** Migrated legacy history keeps the live payload shapes under its own ignorable types: a timeline projection
+ * shows it beside live events, while state replay (which knows only the live types) skips it as history. */
+export declare const MIGRATED_STATE_EVENT = "session.state.migrated.v1";
+export declare const MIGRATED_MESSAGE_EVENT = "session.message.migrated.v1";
+export interface JsonMigrationRecord {
+    session_id: string;
+    status: string;
+    parent?: string | null;
+    createdAt?: number;
+    [key: string]: unknown;
+}
+export interface JsonSessionMigrationOptions {
+    databasePath: string;
+    recordsRoot: string;
+    locality: LocalityPrecondition;
+    backupRoot?: string;
+    now?: () => number;
+    orphanParentPolicy?: 'fail' | 'tombstone';
+    /** A caller that already owns the open canonical application lends it for residue import; otherwise the
+     * importer opens and closes its own handle. */
+    application?: ProductionSessionApplication;
+}
+/** The durable fence shared by the one-time importer and legacy JSON writers. */
+export declare function jsonMigrationFencePath(recordsRoot: string): string;
+export interface JsonResidueMigrationReport {
+    sourceDigest: string;
+    records: number;
+    events: number;
+    parentEdges: number;
+    watchEdges: number;
+    pending: number;
+    unclaimed: string[];
+    backupRoot: string;
+}
+export interface JsonSessionMigrationReport {
+    version: number;
+    sourceDigest: string;
+    records: number;
+    parentEdges: number;
+    watchEdges: number;
+    events: number;
+    orphanParents: string[];
+    backupRoot: string;
+    markerPath: string;
+    replayed: boolean;
+    residue?: JsonResidueMigrationReport;
+}
+/** Whether the legacy tree still holds anything the canonical store must absorb before the tree is retired. */
+export declare function legacyResidueExists(recordsRoot: string): boolean;
+export declare function migrateJsonSessionRecords(options: JsonSessionMigrationOptions): JsonSessionMigrationReport;