@hraness/sponge 0.2.6 → 0.3.1

package/dist/src/store/imports.js

@@ -0,0 +1,57 @@
+import * as jungle from '../importers/jungle-store.js';
+import { hash, text } from './files.js';
+import { transaction } from './context.js';
+import { SpongeError } from '../errors.js';
+/** The receipt an importer left for exactly this source state, if any. */
+export function importReceipt(db, namespace, sourceKey, sourceHash) {
+    text(namespace, 256);
+    text(sourceKey, 8192);
+    hash(sourceHash);
+    const row = db
+        .prepare('SELECT item_id itemId,outcome FROM import_receipts WHERE namespace=? AND source_key=? AND source_hash=?')
+        .get(namespace, sourceKey, sourceHash);
+    return row ? { itemId: String(row.itemId), outcome: String(row.outcome) } : null;
+}
+/** What importers read and write: their realm's items and revisions, their receipts, and Jungle Reading notes. */
+export class Imports {
+    c;
+    constructor(c) {
+        this.c = c;
+    }
+    /** The item an importer realm holds for one source key, with its current revision; deleted items are reported, not hidden. */
+    item(realm, sourceKey) {
+        text(realm, 256);
+        text(sourceKey, 8192);
+        const r = this.c.db
+            .prepare('SELECT i.id,i.deleted_at,i.current_revision FROM source_refs s JOIN items i ON i.id=s.item_id WHERE s.source_key=? AND s.realm_key=?')
+            .get(sourceKey, realm);
+        return r
+            ? {
+                itemId: String(r.id),
+                deleted: r.deleted_at !== null,
+                revisionId: r.current_revision === null ? null : String(r.current_revision),
+            }
+            : null;
+    }
+    revision(itemId, bundleHash) {
+        text(itemId, 256);
+        hash(bundleHash);
+        const r = this.c.db.prepare('SELECT id FROM revisions WHERE item_id=? AND bundle_hash=?').get(itemId, bundleHash);
+        if (!r)
+            throw new SpongeError('unavailable');
+        return String(r.id);
+    }
+    receipt(namespace, sourceKey, sourceHash) {
+        return importReceipt(this.c.db, namespace, sourceKey, sourceHash);
+    }
+    planJungleNote(input) {
+        text(input.itemId, 256);
+        text(input.revisionId, 256);
+        return jungle.planJungleNote(this.c.db, input);
+    }
+    applyJungleNote(input) {
+        text(input.itemId, 256);
+        text(input.revisionId, 256);
+        return transaction(this.c.db, () => jungle.applyJungleNote(this.c.db, input));
+    }
+}

package/dist/src/store/index.d.ts

@@ -1,187 +1,4 @@
-import { DatabaseSync } from 'node:sqlite';
-import * as foundation from './foundation.js';
-import * as jungle from '../importers/jungle-store.js';
-import type { JobCheckpoint } from '../../contracts/index.js';
-import { type AttemptToken, type OwnedAttempt, type BlobReference, type CommitRevision, type OwnerToken, type ReadableItem, type SourceSubmission, type StoreOptions, type Submission } from './types.js';
-import * as indexing from '../indexing/index.js';
-import * as prune from '../indexing/prune.js';
-import { hybridSearch } from '../search/hybrid.js';
+export { LibraryStore } from './library.js';
+export { openLibrary, keptSchemaBackups, libraryVersion } from './open.js';
+export type { RetryOptions, JobKind } from './queue.js';
 export * from './types.js';
-export declare const libraryVersion = 7;
-export declare const libraryMigrations: readonly string[];
-type Row = Record<string, any>;
-export declare function openLibrary(path: string, options?: StoreOptions): Promise<LibraryStore>;
-/** Storage CAS authority only. The worker separately establishes OS/process custody. */
-export declare class LibraryStore {
-    readonly root: string;
-    private readonly db;
-    private readonly options;
-    private closed;
-    constructor(root: string, db: DatabaseSync, options: StoreOptions);
-    createIndexGeneration(options: Parameters<typeof indexing.createGeneration>[1]): indexing.GenerationStatus;
-    submitIndexJob(generationId: string): string;
-    indexJob(id: string): Record<string, import("node:sqlite").SQLOutputValue> | undefined;
-    claimIndexJob(owner: OwnerToken, id?: string): AttemptToken | null;
-    checkpointIndexAttempt(token: AttemptToken, stage: string): void;
-    writeIndexAttemptBatch(token: AttemptToken, fingerprint: string, batch: Parameters<typeof indexing.writeBatch>[3]): void;
-    completeIndexAttempt(token: AttemptToken): indexing.GenerationStatus;
-    failIndexAttempt(token: AttemptToken, reason: string): void;
-    settleIndexAttempt(token: AttemptToken): void;
-    private checkIndexStaging;
-    indexStatus(id: string): indexing.GenerationStatus;
-    indexInputs(id: string, limit?: number): indexing.IndexInput[];
-    writeIndexBatch(id: string, fingerprint: string, batch: Parameters<typeof indexing.writeBatch>[3]): void;
-    activateIndex(id: string): indexing.GenerationStatus;
-    cancelIndex(id: string): void;
-    /** Retired-generation pruning; see src/indexing/prune.ts. The plan probes rollback inside a rolled-back savepoint. */
-    pruneIndexPlan(keep: number): {
-        generations: prune.PruneEntry[];
-        stats: prune.PageStats;
-    };
-    pruneIndexStep(owner: OwnerToken, id: string, keep: number): number;
-    /** VACUUM cannot run in a transaction: fences are checked under the owner token immediately before it. */
-    vacuumLibrary(owner: OwnerToken): prune.PageStats;
-    searchHybrid(query: string, options?: Parameters<typeof hybridSearch>[2]): Promise<import("../search/hybrid.js").SearchResult>;
-    /** Export's view: the one annotation reader, without the redundant item id, plus reading state. */
-    readAnnotations(itemId: string): {
-        annotations: {
-            id: string;
-            kind: "note" | "highlight" | "comment";
-            revisionId: string | null;
-            parentId: string | null;
-            anchor: unknown;
-            body: string;
-            createdAt: string;
-            updatedAt: string | null;
-            anchored?: boolean;
-        }[];
-        readingState: {
-            state: unknown;
-            updatedAt: string;
-        } | null;
-    };
-    /** Sync and publishing foundation; see docs/decisions/sync-and-publishing.md. */
-    identity(itemId: string): {
-        uris: import("../identity/uri.js").ItemUri[];
-        visibility: foundation.VisibilityState;
-    };
-    itemsForUri(uri: string): string[];
-    setVisibility(itemId: string, value: foundation.Visibility | null): foundation.VisibilityState;
-    addHighlight(input: Parameters<typeof foundation.addHighlight>[1]): foundation.Annotation;
-    addComment(input: Parameters<typeof foundation.addComment>[1]): foundation.Annotation;
-    updateAnnotation(id: string, body: string): foundation.Annotation;
-    deleteAnnotation(id: string): void;
-    listAnnotations(itemId: string): (foundation.Annotation & {
-        anchored?: boolean;
-    })[];
-    putDigest(input: Parameters<typeof foundation.putDigest>[1]): {
-        id: string;
-        duplicate: boolean;
-    };
-    currentDigest(itemId: string): foundation.Derivation | undefined;
-    readDigest(id: string): foundation.Derivation | undefined;
-    findDigest(revisionId: string, inputHash: string): foundation.Derivation | undefined;
-    reviewDigest(id: string, review: foundation.DigestReview): foundation.Derivation;
-    currentEditorial(itemId: string): foundation.Editorial | undefined;
-    readEditorial(id: string): foundation.Editorial | undefined;
-    reviewEditorial(id: string, status: foundation.ReviewStatus | null): foundation.Editorial;
-    /** The item an importer realm holds for one source key, with its current revision; deleted items are reported, not hidden. */
-    importedItem(realm: string, sourceKey: string): {
-        itemId: string;
-        deleted: boolean;
-        revisionId: string | null;
-    } | null;
-    importedRevision(itemId: string, bundleHash: string): string;
-    revisionMarkdown(revisionId: string): string;
-    planJungleNote(input: jungle.JungleNoteInput): jungle.JunglePlan;
-    applyJungleNote(input: jungle.JungleNoteInput): jungle.JunglePlan;
-    listChanges(after?: number, limit?: number): foundation.LoggedChange[];
-    publicProjection(): {
-        entries: foundation.PublicEntry[];
-        skipped: {
-            itemId: string;
-            reason: string;
-        }[];
-    };
-    lookupImportReceipt(namespace: string, sourceKey: string, sourceHash: string): {
-        itemId: string;
-        outcome: string;
-    } | null;
-    close(): void;
-    private transaction;
-    get revisionEpoch(): number;
-    private bumpEpoch;
-    acquireOwner(ownerIncarnation: string): OwnerToken;
-    releaseOwner(token: OwnerToken): void;
-    ownerSnapshot(): OwnerToken | null;
-    ownerAttempts(token: OwnerToken): OwnedAttempt[];
-    /** Requires external custody proof for EVERY pending attempt, even after its job committed.
-     * IDs are acknowledgements from the custody owner, never evidence inferred from PID/timeouts here. */
-    recoverOwner(expected: OwnerToken, provedAttemptIds: readonly string[]): void;
-    checkpointAttempt(token: AttemptToken, stage: JobCheckpoint['stage']): void;
-    jobCancellationRequested(jobId: string): boolean;
-    retryJob(jobId: string, options?: {
-        notBefore?: string;
-        automatic?: boolean;
-    }): void;
-    private checkOwner;
-    submitSource(input: SourceSubmission): Submission;
-    listJobs(): Row[];
-    sourceForJob(jobId: string): {
-        itemId: string;
-        kind: string;
-        sourceKey: string;
-        locator: string;
-        realm: string;
-    } | null;
-    claimNext(token: OwnerToken): AttemptToken | null;
-    claimJob(token: OwnerToken, jobId: string): AttemptToken;
-    private checkAttempt;
-    requestCancellation(jobId: string): void;
-    failAttempt(token: AttemptToken, reason?: string, options?: {
-        retryable?: boolean;
-        retryAfterMs?: number;
-    }): void;
-    /** Caller must first settle owned external children. This only releases storage staging pins. */
-    settleAttempt(token: AttemptToken): void;
-    putBlob(token: AttemptToken, expectedHash: string, expectedBytes: number, source: AsyncIterable<Uint8Array>): Promise<BlobReference>;
-    commitRevision(input: CommitRevision): {
-        revisionId: string;
-        duplicate: boolean;
-    };
-    list(): {
-        itemId: string;
-        kind: string;
-        title: string;
-        revisionId: string | null;
-    }[];
-    read(itemId: string): ReadableItem | null;
-    readBlob(reference: BlobReference): Uint8Array;
-    search(query: string, count?: number): {
-        itemId: string;
-        title: string;
-        revisionId: string;
-    }[];
-    delete(itemId: string): void;
-    /** Online DB snapshot only; P12 pairs this with blobs while the returned fence remains active. */
-    createBackupSnapshot(): Promise<{
-        id: string;
-        path: string;
-        revisionEpoch: number;
-    }>;
-    finishBackup(id: string): void;
-    /** Hold the SQLite writer fence across synchronous GC inspection and removal. */
-    withGcFence<T>(expectedEpoch: number, callback: (references: readonly BlobReference[]) => T): T;
-    /** Runtime GC pins: recorded model artifacts and embedding helpers of active or building generations. */
-    runtimeReferences(): {
-        modelArtifacts: {
-            id: string;
-            manifest: string;
-        }[];
-        embeddingHelpers: string[];
-        unmappedSpaces: number;
-    };
-    /** GC must honor both durable staging pins and active backup fences. */
-    pendingCleanupCount(): number;
-    hasGcFence(): boolean;
-}