@takboo/dsh-session-bin 0.0.0-stage → 0.1.0

package/dist/host/native-retirement-sdk.d.ts

@@ -0,0 +1,80 @@
+/** Locked public npm implementation files actually inspected and tested. */
+export declare const nativeRetirementSdkSources: {
+    readonly cordis: {
+        readonly version: "4.0.4";
+        readonly files: {
+            readonly 'lib/index.js': "6a9394c0877ff45218818c6e815edd038f8057e1a1deb390a8d43ec81c57691e";
+        };
+    };
+    readonly 'dsh-session': {
+        readonly version: "0.2.0-rc.2";
+        readonly files: {
+            readonly 'lib/index.js': "87ea85e2fb5318bf1f826db9a1c88c1b26d3ea328027a7f32b211880c4d62b9d";
+            readonly 'lib/types/index.js': "71b3a3578b85704f026b590462e7d5e8bceb6dededd4e8782a83696138ec7da7";
+        };
+    };
+    readonly 'dsh-session-persistence': {
+        readonly version: "0.2.0-rc.2";
+        readonly files: {
+            readonly 'lib/index.js': "cc0b6d3a224133af611b428d5a49020e300f86c3b4ba28037aeb219029bde3eb";
+        };
+    };
+    readonly 'dsh-session-persistence-jsonl': {
+        readonly version: "0.2.0-rc.2";
+        readonly files: {
+            readonly 'lib/index.js': "0845707017acc2b4a8a75eab2244fa3fd88587b8094ab32014321dce7ca1e31b";
+        };
+    };
+    readonly 'dsh-session-format-catalog': {
+        readonly version: "0.2.0-rc.2";
+        readonly files: {
+            readonly 'lib/index.js': "836bbb772ab505c299f1a4a246164c50c7c08b67ab0d17f1251d7ea2cd8c1818";
+            readonly 'lib/types/index.js': "c7d797760bf2b9bc654751f2f8cb0b8a6b98998c8d9c1e41323c71a4d5f316f2";
+        };
+    };
+    readonly 'dsh-storage-domain': {
+        readonly version: "0.2.0-rc.2";
+        readonly files: {
+            readonly 'lib/index.js': "e536ba09b7ccc0f10bb54818dfe44454374e5cbf7aeba140b216ba1ca2e87517";
+        };
+    };
+    readonly 'dsh-storage-json': {
+        readonly version: "0.2.0-rc.2";
+        readonly files: {
+            readonly 'lib/index.js': "0a6b75d5569db3379edd93e863570170e1f4121b6c9fabd856f5b476cffe8df4";
+        };
+    };
+    readonly 'dsh-workspace': {
+        readonly version: "0.2.0-rc.2";
+        readonly files: {
+            readonly 'lib/index.js': "a33af459cfc7af29dd17412443a63655fd5037dd348b0dec20a413ce60c6c8bc";
+            readonly 'lib/types/index.js': "dbc8cc80e2b33c6bce07c73bd4e43be08af02051077ea9e032c2db2b9a154104";
+        };
+    };
+    readonly 'dsh-session-query': {
+        readonly version: "0.2.0-rc.2";
+        readonly files: {
+            readonly 'lib/index.js': "dd8056fad008063c7e85169d4306720abe8efa6b32eac98f1b3053c6f89894aa";
+        };
+    };
+    readonly 'dsh-session-query-sqlite': {
+        readonly version: "0.2.0-rc.2";
+        readonly files: {
+            readonly 'lib/index.js': "dbecf83320e10d93d735b3d01384ab817a0b90102ccecb0a22c013c71dfe70a0";
+        };
+    };
+    readonly 'dsh-session-projection-cache': {
+        readonly version: "0.2.0-rc.2";
+        readonly files: {
+            readonly 'lib/index.js': "797282e86a23ece3a6a6246765277ec00360813bc0bac0450caff8c56278db0b";
+        };
+    };
+    readonly 'dsh-api-session-controller': {
+        readonly version: "0.2.0-rc.2";
+        readonly files: {
+            readonly 'lib/index.js': "fb0f7b96130f595db20809eeb77a195b05f4a039f931d1e67692f1f74a4dd269";
+            readonly 'lib/types/index.js': "764de9dca8a029a3c874f8fe15b864de59b222666853319f0e5f16fe29909e9f";
+        };
+    };
+};
+export declare function nativeRetirementSdkFingerprint(): Promise<string | null>;

package/dist/host/native.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { NativeBinPort, NativeSessionState } from './module.js';
+/** All native actions stay on public SDK methods; cold inspection claims no writer. */
+export declare class DshBinPort implements NativeBinPort {
+    private readonly ctx;
+    constructor(ctx: Context);
+    archivedSessionIds(): readonly string[];
+    inspect(rawId: string): Promise<NativeSessionState>;
+    activity(rawId: string): Promise<string[]>;
+    archive(rawId: string): Promise<void>;
+    unarchive(rawId: string): Promise<void>;
+}

package/dist/host/platform-files.d.ts

@@ -0,0 +1,19 @@
+import type { FileHandle } from 'node:fs/promises';
+export type NativePlatform = 'darwin' | 'linux' | 'win32';
+export declare function nativePlatformCandidate(platform?: NodeJS.Platform, arch?: NodeJS.Architecture): boolean;
+/** Actual erasure evidence is promoted separately from an implemented Adapter. */
+export declare function nativePlatformVerified(platform?: NodeJS.Platform, arch?: NodeJS.Architecture, node?: string, uv?: string): boolean;
+/** Session namespace matches the audited JSONL writer; plugin ownership is independent. */
+export declare function windowsSemaphoreName(path: string, purpose: 'session' | 'plugin'): string;
+/** Same-volume rename whose metadata acknowledgement is written through. */
+export declare function renameWindowsWriteThrough(source: string, destination: string): Promise<void>;
+/** No lock file, expiry, or stale-PID deletion; the last kernel handle owns its lifetime. */
+export declare function acquireWindowsSemaphore(path: string, purpose: 'session' | 'plugin'): Promise<() => Promise<void>>;
+/** POSIX namespace durability. Windows callers must use their audited owner protocol. */
+export declare function syncDirectory(path: string): Promise<void>;
+export declare class RegularFileRefusal extends Error {
+    readonly code: 'platform/unsafe-file' | 'platform/file-changed' | 'platform/identity-unavailable';
+    constructor(code: 'platform/unsafe-file' | 'platform/file-changed' | 'platform/identity-unavailable', message: string);
+}
+/** Refuse symlinks and compare the opened identity even when O_NOFOLLOW is unavailable. */
+export declare function openRegularFile(path: string, access: 'read' | 'write'): Promise<FileHandle>;

package/dist/host/remote.d.ts

@@ -0,0 +1,32 @@
+import { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { RemoteStream } from '@deepseek-ai/dsh-typert-protocol';
+import type { BinSnapshot } from '../remote/contracts.js';
+import type { ArchiveOperation, ArchivePlan as BinPlan, ArchiveResult as BinResult, ArchivePrepareRequest as PrepareRequest } from '../operations/archive.js';
+import type { BinOperation } from '../operations/schema.js';
+import type { PreparePurgeRequest, PurgePlan, PurgeResult, PurgeOperation } from '../operations/retirement.js';
+/** Public strict Typert adapter; all native mutation stays in the existing Module. */
+export declare class SessionBinRemote extends TypertRemoteService {
+    static inject: string[];
+    private readonly lifetime;
+    private readonly streams;
+    private closed;
+    constructor(ctx: Context);
+    prepare(request: PrepareRequest, signal: AbortSignal): Promise<BinPlan>;
+    execute(plan: BinPlan, signal: AbortSignal): Promise<BinResult>;
+    list(signal: AbortSignal): Promise<{
+        schemaVersion: 2;
+        sessionId: string;
+        entryId: string;
+    }[]>;
+    getOperation(operationId: string, signal: AbortSignal): Promise<ArchiveOperation | BinOperation | null>;
+    preparePurge(request: PreparePurgeRequest, signal: AbortSignal): Promise<PurgePlan>;
+    executePurge(input: PurgePlan, signal: AbortSignal): Promise<PurgeResult>;
+    getPurgeOperation(operationId: string, signal: AbortSignal): Promise<PurgeOperation | null>;
+    purgeOperations(signal: AbortSignal): Promise<PurgeOperation[]>;
+    follow(signal: AbortSignal): RemoteStream<BinSnapshot>;
+    private snapshots;
+    private call;
+}
+/** The parent Host calls this only after its SessionBin Module has initialized. */
+export declare function installSessionBinRemote(ctx: Context): Promise<() => Promise<void>>;

package/dist/host/retirement-owner-store.d.ts

@@ -0,0 +1,124 @@
+import type { Domain } from '@deepseek-ai/dsh-storage-domain';
+import type { RetirementCapabilities } from '../operations/retirement.js';
+import type { RetirementOwnerRecord } from '../operations/retirement-owner.js';
+export declare const retirementOwnerDomainSpec: {
+    readonly name: "session_bin_retirement_owner";
+    readonly version: 1;
+    readonly layout: "single";
+    readonly global: {
+        readonly schema: import("zod").ZodObject<{
+            schemaVersion: import("zod").ZodLiteral<1>;
+            capabilities: import("zod").ZodNullable<import("zod").ZodObject<{
+                protocolVersion: import("zod").ZodLiteral<1>;
+                ownerId: import("zod").ZodString;
+                hostVersion: import("zod").ZodString;
+                providerId: import("zod").ZodString;
+                storeId: import("zod").ZodString;
+                participants: import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    version: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        readonly initial: {
+            readonly schemaVersion: 1;
+            readonly capabilities: null;
+        };
+    };
+    readonly tables: {
+        readonly operations: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            schemaVersion: 1;
+            state: {
+                schemaVersion: 1;
+                request: {
+                    operationId: string;
+                    expected: {
+                        storeId: string;
+                        sessionId: string;
+                        lifecycleId: string;
+                    };
+                    bin: {
+                        entryId: string;
+                        entryVersion: 1;
+                    } | {
+                        kind: "native-archive";
+                        entryId: string;
+                        entryVersion: 2;
+                    };
+                    manifestDigest: string;
+                };
+                manifest: {
+                    schemaVersion: 1;
+                    lifecycle: {
+                        storeId: string;
+                        sessionId: string;
+                        lifecycleId: string;
+                    };
+                    capabilities: {
+                        protocolVersion: 1;
+                        ownerId: string;
+                        hostVersion: string;
+                        providerId: string;
+                        storeId: string;
+                        participants: {
+                            id: string;
+                            version: string;
+                        }[];
+                    };
+                    resources: {
+                        ownerId: string;
+                        resourceId: string;
+                        revision: string;
+                        kind: "transcript" | "workspace" | "index" | "cache" | "attachment" | "spill" | "coordination";
+                        disposition: "erase" | "release-reference" | "retain-shared" | "retain-coordination";
+                        retention: {
+                            reason: "shared-reference" | "coordination-identity";
+                            retainedBy: {
+                                storeId: string;
+                                sessionId: string;
+                                lifecycleId: string;
+                            }[];
+                        } | null;
+                    }[];
+                };
+                authorizationId: string | null;
+                phase: "rejected" | "conflict" | "done" | "fenced" | "quiesced" | "erasing" | "converging";
+                reason: string | null;
+                resources: {
+                    ownerId: string;
+                    resourceId: string;
+                    status: "erased" | "reference-released" | "retained" | "failed";
+                    reason: string | null;
+                }[];
+            };
+            participants: {
+                id: string;
+                version: string;
+                fenced: boolean;
+                quiesced: boolean;
+                converged: boolean;
+            }[];
+            lifecycleQuiesced: boolean;
+            lifecycleFinalized: boolean;
+            blockedReason: string | null;
+        }>;
+    };
+};
+export interface RetirementOwnerStore {
+    bindCapabilities(capabilities: RetirementCapabilities): Promise<void>;
+    operation(operationId: string): RetirementOwnerRecord | undefined;
+    operations(): RetirementOwnerRecord[];
+    putOperation(record: RetirementOwnerRecord): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function sameRetirementCapabilities(a: RetirementCapabilities, b: RetirementCapabilities): boolean;
+/** The caller must hold the composition's lifetime lease before opening this domain. */
+export declare class DomainRetirementOwnerStore implements RetirementOwnerStore {
+    private readonly domain;
+    constructor(domain: Domain<typeof retirementOwnerDomainSpec>);
+    bindCapabilities(input: RetirementCapabilities): Promise<void>;
+    operation(operationId: string): RetirementOwnerRecord | undefined;
+    operations(): RetirementOwnerRecord[];
+    putOperation(input: RetirementOwnerRecord): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/host/retirement-owner.d.ts

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { retirementResourceReceiptSchema, retirementResourceSchema } from '../operations/retirement.js';
+import type { LifecycleKey, RetirementAuthorization, RetirementCapabilities, RetirementManifest, RetirementRequest, RetirementState } from '../operations/retirement.js';
+import type { RetirementOwnerRecord } from '../operations/retirement-owner.js';
+import type { SessionRetirementOwnerV1 } from './retirement.js';
+import type { RetirementOwnerStore } from './retirement-owner-store.js';
+export type RetirementResource = z.infer<typeof retirementResourceSchema>;
+export type RetirementResourceReceipt = z.infer<typeof retirementResourceReceiptSchema>;
+export interface RetirementOwnerGuards {
+    /** Synchronous checks apply to retained handles and late writes as well as new opens. */
+    assertCanUse(lifecycle: LifecycleKey): void;
+    assertCanCreate(sessionId: string): void;
+}
+export interface RetirementLifecycleScope {
+    readonly lifecycle: LifecycleKey;
+    current(): Promise<LifecycleKey | null>;
+    activity(): Promise<string[]>;
+    /** false acknowledges a known pending barrier; throws mean unknown outcome. */
+    quiesce(request: RetirementRequest): Promise<boolean>;
+    finalize(request: RetirementRequest): Promise<boolean>;
+    release(): Promise<void>;
+}
+export interface RetirementLifecyclePort {
+    inspect(sessionId: string): Promise<LifecycleKey | null>;
+    /** Teardown disables these routes/retained references, rather than making them unguarded. */
+    bindGuards(guards: RetirementOwnerGuards): Promise<() => Promise<void>>;
+    /** A saved record grants maintenance access to exactly its retired lifecycle.
+     * Recovery must work after transcript removal/finalization without create/resume.
+     * Every acquire must restore current runtime exclusion/reservations for all
+     * participants; persisted quiescence acknowledgements are not live leases. */
+    acquire(expected: LifecycleKey, maintenance: RetirementOwnerRecord | null): Promise<RetirementLifecycleScope>;
+}
+export interface RetirementResourceParticipant {
+    readonly identity: {
+        id: string;
+        version: string;
+    };
+    bindGuards(guards: RetirementOwnerGuards): Promise<() => Promise<void>>;
+    manifest(expected: LifecycleKey): Promise<RetirementResource[]>;
+    fence(request: RetirementRequest): Promise<boolean>;
+    quiesce(request: RetirementRequest): Promise<boolean>;
+    /** Exact operation/resource/revision actions and all barriers are idempotent. */
+    applyResource(request: RetirementRequest, resource: RetirementResource): Promise<RetirementResourceReceipt>;
+    converge(request: RetirementRequest): Promise<boolean>;
+}
+export interface RetirementOwnerCheckpoint {
+    request: RetirementRequest;
+    manifest: RetirementManifest;
+    record: RetirementOwnerRecord | null;
+    resource: RetirementResource | null;
+}
+export interface RetirementOwnerCoordinatorOptions {
+    capabilities: RetirementCapabilities;
+    store: RetirementOwnerStore;
+    lifecycle: RetirementLifecyclePort;
+    participants: readonly RetirementResourceParticipant[];
+    /** A bounded worker may pause only after a durable acknowledgement; the fence remains. */
+    canAdvance?: (record: RetirementOwnerRecord) => boolean;
+    checkpoint?: (name: string, context: RetirementOwnerCheckpoint) => Promise<void> | void;
+}
+export declare class RetirementOwnerError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string, options?: ErrorOptions);
+}
+/** Provider-neutral owner machinery. Ports must own the actual resources and
+ * admission paths; this class supplies no native deletion or private-file adapter. */
+export declare class RetirementOwnerCoordinator implements SessionRetirementOwnerV1 {
+    private readonly options;
+    private readonly descriptor;
+    private readonly participants;
+    private tail;
+    private failure;
+    private ready;
+    private readonly frames;
+    private readonly activeFrames;
+    private readonly observations;
+    private closing;
+    private initializing;
+    private closePromise;
+    private readonly disposers;
+    private readonly expectedErrors;
+    readonly guards: RetirementOwnerGuards;
+    constructor(options: RetirementOwnerCoordinatorOptions);
+    initialize(): Promise<void>;
+    ownsCurrentMaintenanceFrame(): boolean;
+    isRefusal(error: unknown): boolean;
+    capabilities(): Promise<RetirementCapabilities>;
+    inspect(sessionId: string): Promise<LifecycleKey | null>;
+    prepare(input: LifecycleKey): Promise<RetirementManifest>;
+    getOperation(operationId: string): Promise<RetirementState | null>;
+    getRecord(operationId: string): RetirementOwnerRecord | undefined;
+    retire(input: RetirementRequest, authorize: () => Promise<RetirementAuthorization>, frozenInput?: RetirementManifest): Promise<RetirementState>;
+    recover(operationId: string): Promise<RetirementState>;
+    close(): Promise<void>;
+    private advance;
+    private emptyRecord;
+    private refusal;
+    private pending;
+    private manifest;
+    private validateFrozen;
+    private current;
+    private withScope;
+    private context;
+    private contextFor;
+    private checkpoint;
+    private canAdvance;
+    private barrier;
+    private save;
+    private records;
+    private validateJournal;
+    private verifyParticipants;
+    private capabilitiesSnapshot;
+    private known;
+    private unavailable;
+    private assertMaintenanceUse;
+    private assertUnfenced;
+    private rememberFailure;
+    private requireControlReady;
+    private requireReady;
+    private read;
+    private assertHealthy;
+    private call;
+    private enqueue;
+}