generated from coulomb/repo-seed
tegwick
779ae0d317
Turn the MVP into a self-contained demo. Users now:
1. Land on an empty-state and create a named session.
2. Drag-drop or pick arbitrary PDFs into that session.
3. Annotate, build evidence, link to form fields — all session-scoped.
4. Export the whole session as a single .zip archive (manifest +
per-document PDFs).
5. Import a .zip back — into a new session, or merged into an
existing one (documents deduped by SHA-256 fingerprint;
annotations/evidence/links added additively).
Architecture:
- New shared types: SessionId, Session, SessionArchiveManifest +
parseSessionArchiveManifest with schema-version validation.
- SessionService (engine/services/sessions.ts) handles lifecycle
(create/rename/delete/setActive) + emits 4 new events through its
own bus; SharedContracts.md §4 lists the additions.
- SessionProvider (work/SessionContext.tsx) owns the cross-session
state: service, per-session PdfByteStore registry, per-session
version counter that drives EngineProvider remounts after imports.
- EngineProvider becomes session-aware (sessionId prop drives per-
session localStorage keys). Bumping engineRevision after
restoreFromStorage forces consumers to re-render so restored repos
show up immediately.
- PdfByteStore (source/pdf/byte-store.ts) holds Uint8Array bytes per
document and mints blob URLs; ingestPdfFromFile is the upload
entry-point that wraps the existing ingestPdf pipeline.
- ADR-0008 locks the ZIP layout (manifest.json + documents/<id>.pdf),
the manifest schema (schemaVersion 1), and the merge-on-collision
policy. JSZip is the only new dependency.
- App.tsx restructured: SessionProvider at the root, EngineProvider
keyed by ${sessionId}:${version}, hash routing #/s/<id>[/forms/demo],
SessionMenu top-bar, CreateFirstSession empty state.
- New DocumentRemoved event for per-document delete cleanup in
CollectionList; engine.documents.remove() is the new service method.
Tests:
- Unit: 16 SessionService lifecycle + persistence tests;
per-session snapshot round-trip; PdfByteStore + ingestPdfFromFile;
SessionArchive parser; exportSessionZip + importSessionZip with
create + merge + corrupt-archive paths.
- DOM: UploadDropzone, session-scoped CollectionList delete,
SessionMenu create/switch/rename, routing parser.
- E2E: tests/integration/session-export-reimport.dom.test.tsx walks
the full create → annotate → export → reimport flow and asserts
the additive merge (deduped doc + doubled evidence rows).
- Legacy E2Es updated to use a seed-session helper instead of the
removed fixture-button flow.
Known limitation (documented in ADR-0008): re-importing your own
freshly-exported ZIP creates duplicate annotations. Forward pointer
left for an importBundleId follow-up.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
99 lines
3.4 KiB
TypeScript
99 lines
3.4 KiB
TypeScript
/**
|
|
* Per-session engine snapshot round-trip.
|
|
*
|
|
* The workplan (CE-WP-0005-T01) requires that two sessions persisted
|
|
* under the per-session key scheme can each be restored independently
|
|
* — proving the storage layout actually partitions data by session.
|
|
*/
|
|
|
|
import { describe, expect, it } from "vitest";
|
|
|
|
import type { Document, DocumentRepresentation } from "@shared/document";
|
|
import type { DocumentId, RepresentationId, SessionId } from "@shared/ids";
|
|
|
|
import {
|
|
attachPersister,
|
|
createEngine,
|
|
engineSnapshotKey,
|
|
restoreFromStorage,
|
|
type Engine,
|
|
type EngineSnapshot,
|
|
} from "./index";
|
|
|
|
function memoryStorage(): Pick<Storage, "getItem" | "setItem" | "removeItem"> {
|
|
const map = new Map<string, string>();
|
|
return {
|
|
getItem: (k) => map.get(k) ?? null,
|
|
setItem: (k, v) => void map.set(k, v),
|
|
removeItem: (k) => void map.delete(k),
|
|
};
|
|
}
|
|
|
|
function seedDoc(engine: Engine, label: string): { id: DocumentId } {
|
|
const id = `doc_${label}` as DocumentId;
|
|
const repId = `rep_${label}` as RepresentationId;
|
|
const document: Document = {
|
|
id,
|
|
mediaType: "application/pdf",
|
|
title: `Doc ${label}`,
|
|
createdAt: "2026-05-25T00:00:00.000Z",
|
|
updatedAt: "2026-05-25T00:00:00.000Z",
|
|
};
|
|
const representation: DocumentRepresentation = {
|
|
id: repId,
|
|
documentId: id,
|
|
representationType: "pdf-text",
|
|
contentHash: `hash-${label}`,
|
|
canonicalText: `text for ${label}`,
|
|
pageMap: [{ page: 1, width: 100, height: 100 }],
|
|
offsetMap: [{ page: 1, globalStart: 0, globalEnd: 12, pageLength: 12 }],
|
|
generatedAt: "2026-05-25T00:00:00.000Z",
|
|
};
|
|
engine.documents.register({ document, representation });
|
|
return { id };
|
|
}
|
|
|
|
describe("per-session engine snapshot round-trip", () => {
|
|
it("keeps two sessions' snapshots isolated under per-session storage keys", () => {
|
|
const storage = memoryStorage();
|
|
const sessA = "sess_aaa" as SessionId;
|
|
const sessB = "sess_bbb" as SessionId;
|
|
|
|
// Author session A.
|
|
const engineA = createEngine();
|
|
const offA = attachPersister(engineA, { key: engineSnapshotKey(sessA), storage });
|
|
const a1 = seedDoc(engineA, "a1");
|
|
const a2 = seedDoc(engineA, "a2");
|
|
offA();
|
|
|
|
// Author session B with completely different documents.
|
|
const engineB = createEngine();
|
|
const offB = attachPersister(engineB, { key: engineSnapshotKey(sessB), storage });
|
|
const b1 = seedDoc(engineB, "b1");
|
|
offB();
|
|
|
|
// Restore each into its own fresh engine; assert isolation.
|
|
const restoredA = createEngine();
|
|
const resA = restoreFromStorage(restoredA, { key: engineSnapshotKey(sessA), storage });
|
|
expect(resA.restored).toBe(true);
|
|
const aIds = restoredA.documents.list().map((d) => d.id).sort();
|
|
expect(aIds).toEqual([a1.id, a2.id].sort());
|
|
|
|
const restoredB = createEngine();
|
|
const resB = restoreFromStorage(restoredB, { key: engineSnapshotKey(sessB), storage });
|
|
expect(resB.restored).toBe(true);
|
|
const bIds = restoredB.documents.list().map((d) => d.id);
|
|
expect(bIds).toEqual([b1.id]);
|
|
|
|
// Sanity: each snapshot key really does hold a distinct snapshot.
|
|
const rawA = storage.getItem(engineSnapshotKey(sessA));
|
|
const rawB = storage.getItem(engineSnapshotKey(sessB));
|
|
expect(rawA).not.toBeNull();
|
|
expect(rawB).not.toBeNull();
|
|
const snapA = JSON.parse(rawA!) as EngineSnapshot;
|
|
const snapB = JSON.parse(rawB!) as EngineSnapshot;
|
|
expect(snapA.documents).toHaveLength(2);
|
|
expect(snapB.documents).toHaveLength(1);
|
|
});
|
|
});
|