@undefineds.co/xpod 0.3.18 → 0.3.23

package/dist/solidfs/SolidFsPathUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolidFsPathUtils.js","sourceRoot":"","sources":["../../src/solidfs/SolidFsPathUtils.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from 'node:crypto';\nimport { createReadStream } from 'node:fs';\nimport {\n  readdir,\n  stat,\n} from 'node:fs/promises';\nimport path from 'node:path';\nimport { pathToFileURL } from 'node:url';\n\nimport type {\n  SolidFsEntrySource,\n  SolidFsProjection,\n} from './types';\nimport { rdfContentTypeForPath } from '../storage/rdf/RdfContentTypes';\n\nexport interface SolidFsFileSnapshot {\n  relativePath: string;\n  absolutePath: string;\n  version: string;\n}\n\nexport function contentTypeForPath(filePath: string): string | undefined {\n  const lower = filePath.toLowerCase();\n  const rdfContentType = rdfContentTypeForPath(lower);\n  if (rdfContentType) {\n    return rdfContentType;\n  }\n  if (lower.endsWith('.md') || lower.endsWith('.markdown') || lower.endsWith('.mdown')) {\n    return 'text/markdown';\n  }\n  if (lower.endsWith('.txt') || lower.endsWith('.log')) {\n    return 'text/plain';\n  }\n  return undefined;\n}\n\nexport function sourceForProjection(projection: SolidFsProjection, workspace: string): SolidFsEntrySource {\n  if (projection === 'hydrated-object') {\n    return 'object';\n  }\n  if (/^https?:/u.test(workspace)) {\n    return 'pod-http';\n  }\n  return 'filesystem';\n}\n\nexport function resolveWorkspaceResource(workspace: string, relativePath: string): string | undefined {\n  if (path.isAbsolute(workspace)) {\n    return pathToFileURL(path.join(workspace, relativePath)).href;\n  }\n\n  try {\n    const base = new URL(workspace.endsWith('/') ? workspace : `${workspace}/`);\n    const normalized = relativePath.split(path.sep).join('/');\n    return new URL(normalized, base).href;\n  } catch {\n    return undefined;\n  }\n}\n\nexport function safeRelativePath(input: string): string {\n  const normalized = input.split(/[\\\\/]+/u).filter((part) => part.length > 0).join(path.sep);\n  if (!normalized || path.isAbsolute(input) || normalized.split(path.sep).includes('..')) {\n    throw new Error(`Invalid SolidFS relative path: ${input}`);\n  }\n  return normalized;\n}\n\nexport async function maybeFileVersion(filePath: string): Promise<string | undefined> {\n  try {\n    return await fileVersion(filePath);\n  } catch {\n    return undefined;\n  }\n}\n\nexport async function fileVersion(filePath: string): Promise<string> {\n  const fileStat = await stat(filePath);\n  const hash = createHash('sha256');\n  await new Promise<void>((resolve, reject) => {\n    const stream = createReadStream(filePath);\n    stream.on('data', (chunk) => hash.update(chunk));\n    stream.on('error', reject);\n    stream.on('end', resolve);\n  });\n  return `${fileStat.size}:${fileStat.mtimeMs}:${hash.digest('hex')}`;\n}\n\nexport async function snapshotDirectory(\n  root: string,\n  filter?: (relativePath: string) => boolean,\n): Promise<SolidFsFileSnapshot[]> {\n  const snapshots: SolidFsFileSnapshot[] = [];\n\n  async function walk(current: string): Promise<void> {\n    let entries;\n    try {\n      entries = await readdir(current, { withFileTypes: true });\n    } catch {\n      return;\n    }\n\n    for (const entry of entries) {\n      const absolute = path.join(current, entry.name);\n      const relative = path.relative(root, absolute);\n      if (entry.isDirectory()) {\n        await walk(absolute);\n        continue;\n      }\n      if (!entry.isFile()) {\n        continue;\n      }\n      if (filter && !filter(relative)) {\n        continue;\n      }\n      snapshots.push({\n        relativePath: relative,\n        absolutePath: absolute,\n        version: await fileVersion(absolute),\n      });\n    }\n  }\n\n  await walk(root);\n  return snapshots.sort((left, right) => left.relativePath.localeCompare(right.relativePath));\n}\n"]}

package/dist/solidfs/SolidFsSyncJournal.d.ts

@@ -0,0 +1,117 @@
+import type { SolidFsChange, SolidFsEntrySource, SolidFsManifest, SolidFsPrepareInput, SolidFsProjection, SolidFsSyncer } from './types';
+export type SolidFsSyncJournalStage = 'local_committed' | 'failed_retryable' | 'failed_permanent' | 'reconcile_required' | 'done';
+export interface SolidFsSyncJournalOptions {
+    path: string;
+    now?: () => number;
+    doneRetentionMs?: number;
+    tombstoneRetentionMs?: number;
+    failedPermanentRetentionMs?: number;
+}
+export interface SolidFsSyncJournalOperation {
+    id: string;
+    txId?: string;
+    workspace: SolidFsManifest;
+    change: SolidFsChange;
+    stage: SolidFsSyncJournalStage;
+    afterHash?: string;
+    retryCount: number;
+    lastError?: string;
+    createdAt: number;
+    updatedAt: number;
+    doneAt?: number;
+}
+export interface SolidFsJournalBootstrapInput {
+    workspace: string;
+    cwd: string;
+    projection?: SolidFsProjection;
+    source?: SolidFsEntrySource;
+    shouldTrackPath?: (relativePath: string) => boolean;
+}
+export interface SolidFsJournalBootstrapResult {
+    scanned: number;
+    enqueued: number;
+    skipped: number;
+}
+export interface SolidFsJournalReplayResult {
+    attempted: number;
+    completed: number;
+    failed: number;
+    reconcileRequired: number;
+}
+export interface SolidFsJournalCompactResult {
+    deletedOps: number;
+}
+/**
+ * Per-Pod SolidFS recovery journal.
+ *
+ * This is an outbox for derived work after the authority file is already
+ * committed. It stores enough metadata to replay index/remote refreshes, but
+ * never stores file bodies.
+ */
+export declare class SqliteSolidFsSyncJournal {
+    private readonly db;
+    private readonly now;
+    private readonly doneRetentionMs;
+    private readonly tombstoneRetentionMs;
+    private readonly failedPermanentRetentionMs;
+    constructor(options: SolidFsSyncJournalOptions);
+    close(): void;
+    recordLocalCommitted(change: SolidFsChange, workspace: SolidFsManifest, txId?: string): Promise<SolidFsSyncJournalOperation>;
+    getOperation(id: string): SolidFsSyncJournalOperation | undefined;
+    listOperations(stages?: SolidFsSyncJournalStage[]): SolidFsSyncJournalOperation[];
+    listPending(): SolidFsSyncJournalOperation[];
+    markDone(id: string): Promise<void>;
+    markRetryableFailure(id: string, error: unknown): Promise<void>;
+    markReconcileRequired(id: string, reason: string): Promise<void>;
+    markFailedPermanent(id: string, error: unknown): Promise<void>;
+    replayPending(syncer: SolidFsSyncer, context?: unknown): Promise<SolidFsJournalReplayResult>;
+    bootstrapWorkspace(input: SolidFsJournalBootstrapInput): Promise<SolidFsJournalBootstrapResult>;
+    compact(): Promise<SolidFsJournalCompactResult>;
+    private validateOperationForReplay;
+    private getCheckpoint;
+    private listCheckpoints;
+    private upsertCheckpoint;
+    private initializeSchema;
+}
+export interface JournaledSolidFsSyncerOptions {
+    syncer: SolidFsSyncer;
+    journal: SqliteSolidFsSyncJournal;
+}
+export interface WorkspaceJournaledSolidFsSyncerOptions {
+    syncer: SolidFsSyncer;
+    journalRoot?: string;
+    resolveJournalPath?: (workspace: SolidFsManifest) => string;
+    now?: () => number;
+    doneRetentionMs?: number;
+    tombstoneRetentionMs?: number;
+    failedPermanentRetentionMs?: number;
+}
+export declare class JournaledSolidFsSyncer implements SolidFsSyncer {
+    private readonly syncer;
+    private readonly journal;
+    constructor(options: JournaledSolidFsSyncerOptions);
+    shouldTrack(input: SolidFsPrepareInput): boolean;
+    shouldTrackPath(relativePath: string): boolean;
+    sync(change: SolidFsChange, workspace: SolidFsManifest, context?: unknown): Promise<void>;
+    replayPending(context?: unknown): Promise<SolidFsJournalReplayResult>;
+    compact(): Promise<SolidFsJournalCompactResult>;
+    bootstrapWorkspace(input: Omit<SolidFsJournalBootstrapInput, 'shouldTrackPath'> & {
+        shouldTrackPath?: (relativePath: string) => boolean;
+    }): Promise<SolidFsJournalBootstrapResult>;
+}
+export declare class WorkspaceJournaledSolidFsSyncer implements SolidFsSyncer {
+    private readonly options;
+    private readonly syncer;
+    private readonly journals;
+    constructor(options: WorkspaceJournaledSolidFsSyncerOptions);
+    shouldTrack(input: SolidFsPrepareInput): boolean;
+    shouldTrackPath(relativePath: string): boolean;
+    initializeWorkspace(workspace: SolidFsManifest, context?: unknown): Promise<void>;
+    sync(change: SolidFsChange, workspace: SolidFsManifest, context?: unknown): Promise<void>;
+    replayPending(workspace: SolidFsManifest, context?: unknown): Promise<SolidFsJournalReplayResult>;
+    compact(workspace: SolidFsManifest): Promise<SolidFsJournalCompactResult>;
+    journalPathFor(workspace: SolidFsManifest): string;
+    close(): void;
+    private journalFor;
+}
+export declare function resolveSolidFsJournalPath(workspace: SolidFsManifest, journalRoot?: string): string;

package/dist/solidfs/SolidFsSyncJournal.js

@@ -0,0 +1,553 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceJournaledSolidFsSyncer = exports.JournaledSolidFsSyncer = exports.SqliteSolidFsSyncJournal = void 0;
+exports.resolveSolidFsJournalPath = resolveSolidFsJournalPath;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
+const SqliteRuntime_1 = require("../storage/SqliteRuntime");
+const RdfContentTypes_1 = require("../storage/rdf/RdfContentTypes");
+const SolidFsPathUtils_1 = require("./SolidFsPathUtils");
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_DONE_RETENTION_MS = 7 * DAY_MS;
+const DEFAULT_TOMBSTONE_RETENTION_MS = 30 * DAY_MS;
+const DEFAULT_FAILED_PERMANENT_RETENTION_MS = 30 * DAY_MS;
+/**
+ * Per-Pod SolidFS recovery journal.
+ *
+ * This is an outbox for derived work after the authority file is already
+ * committed. It stores enough metadata to replay index/remote refreshes, but
+ * never stores file bodies.
+ */
+class SqliteSolidFsSyncJournal {
+    constructor(options) {
+        this.now = options.now ?? Date.now;
+        this.doneRetentionMs = options.doneRetentionMs ?? DEFAULT_DONE_RETENTION_MS;
+        this.tombstoneRetentionMs = options.tombstoneRetentionMs ?? DEFAULT_TOMBSTONE_RETENTION_MS;
+        this.failedPermanentRetentionMs = options.failedPermanentRetentionMs ?? DEFAULT_FAILED_PERMANENT_RETENTION_MS;
+        this.db = (0, SqliteRuntime_1.getSqliteRuntime)().openDatabase(options.path);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('busy_timeout = 5000');
+        this.initializeSchema();
+    }
+    close() {
+        this.db.close();
+    }
+    async recordLocalCommitted(change, workspace, txId) {
+        const normalizedChange = normalizeChange(change);
+        const afterHash = normalizedChange.type === 'deleted'
+            ? undefined
+            : await (0, SolidFsPathUtils_1.maybeFileVersion)(normalizedChange.sourcePath);
+        const opId = operationId(workspace.workspace, normalizedChange, afterHash);
+        const now = this.now();
+        const existing = this.getOperation(opId);
+        if (existing) {
+            return existing;
+        }
+        const journalWorkspace = journalWorkspaceSnapshot(workspace);
+        this.db.prepare(`
+      INSERT INTO sync_ops (
+        id,
+        tx_id,
+        workspace,
+        path,
+        op_type,
+        stage,
+        source_path,
+        resource,
+        content_type,
+        source,
+        projection,
+        source_version,
+        after_hash,
+        workspace_json,
+        change_json,
+        retry_count,
+        created_at,
+        updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+    `).run(opId, txId ?? null, workspace.workspace, normalizedChange.path, normalizedChange.type, 'local_committed', normalizedChange.sourcePath, normalizedChange.resource ?? null, normalizedChange.contentType ?? null, normalizedChange.source, normalizedChange.projection, normalizedChange.sourceVersion ?? null, afterHash ?? null, JSON.stringify(journalWorkspace), JSON.stringify(normalizedChange), now, now);
+        return this.getOperation(opId);
+    }
+    getOperation(id) {
+        const row = this.db.prepare(`
+      SELECT id, tx_id, workspace_json, change_json, stage, after_hash, retry_count,
+             last_error, created_at, updated_at, done_at
+      FROM sync_ops
+      WHERE id = ?
+    `).get(id);
+        return row ? rowToOperation(row) : undefined;
+    }
+    listOperations(stages) {
+        const rows = stages && stages.length > 0
+            ? this.db.prepare(`
+          SELECT id, tx_id, workspace_json, change_json, stage, after_hash, retry_count,
+                 last_error, created_at, updated_at, done_at
+          FROM sync_ops
+          WHERE stage IN (${stages.map(() => '?').join(', ')})
+          ORDER BY created_at ASC, id ASC
+        `).all(...stages)
+            : this.db.prepare(`
+          SELECT id, tx_id, workspace_json, change_json, stage, after_hash, retry_count,
+                 last_error, created_at, updated_at, done_at
+          FROM sync_ops
+          ORDER BY created_at ASC, id ASC
+        `).all();
+        return rows.map(rowToOperation);
+    }
+    listPending() {
+        return this.listOperations(['local_committed', 'failed_retryable']);
+    }
+    async markDone(id) {
+        const op = this.getOperation(id);
+        if (!op) {
+            return;
+        }
+        const now = this.now();
+        this.db.transaction(() => {
+            this.db.prepare(`
+        UPDATE sync_ops
+        SET stage = 'done',
+            last_error = NULL,
+            done_at = ?,
+            updated_at = ?,
+            tombstone_confirmed_at = CASE WHEN op_type = 'deleted' THEN ? ELSE tombstone_confirmed_at END
+        WHERE id = ?
+      `).run(now, now, now, id);
+            this.upsertCheckpoint(op, now);
+        })();
+    }
+    async markRetryableFailure(id, error) {
+        const now = this.now();
+        this.db.prepare(`
+      UPDATE sync_ops
+      SET stage = 'failed_retryable',
+          retry_count = retry_count + 1,
+          last_error = ?,
+          updated_at = ?
+      WHERE id = ?
+    `).run(errorMessage(error), now, id);
+    }
+    async markReconcileRequired(id, reason) {
+        const now = this.now();
+        this.db.prepare(`
+      UPDATE sync_ops
+      SET stage = 'reconcile_required',
+          last_error = ?,
+          updated_at = ?
+      WHERE id = ?
+    `).run(reason, now, id);
+    }
+    async markFailedPermanent(id, error) {
+        const now = this.now();
+        this.db.prepare(`
+      UPDATE sync_ops
+      SET stage = 'failed_permanent',
+          last_error = ?,
+          updated_at = ?
+      WHERE id = ?
+    `).run(errorMessage(error), now, id);
+    }
+    async replayPending(syncer, context) {
+        const result = {
+            attempted: 0,
+            completed: 0,
+            failed: 0,
+            reconcileRequired: 0,
+        };
+        for (const op of this.listPending()) {
+            result.attempted += 1;
+            const validation = await this.validateOperationForReplay(op);
+            if (validation) {
+                await this.markReconcileRequired(op.id, validation);
+                result.reconcileRequired += 1;
+                continue;
+            }
+            try {
+                await syncer.sync(op.change, op.workspace, context);
+                await this.markDone(op.id);
+                result.completed += 1;
+            }
+            catch (error) {
+                await this.markRetryableFailure(op.id, error);
+                result.failed += 1;
+            }
+        }
+        return result;
+    }
+    async bootstrapWorkspace(input) {
+        const projection = input.projection ?? 'direct';
+        const source = input.source ?? (0, SolidFsPathUtils_1.sourceForProjection)(projection, input.workspace);
+        const manifest = {
+            workspace: input.workspace,
+            cwd: input.cwd,
+            projection,
+            entries: [],
+        };
+        const snapshots = await (0, SolidFsPathUtils_1.snapshotDirectory)(input.cwd, input.shouldTrackPath);
+        const currentPaths = new Set(snapshots.map((snapshot) => snapshot.relativePath));
+        const result = {
+            scanned: snapshots.length,
+            enqueued: 0,
+            skipped: 0,
+        };
+        for (const snapshot of snapshots) {
+            const checkpoint = this.getCheckpoint(input.workspace, snapshot.relativePath);
+            if (checkpoint?.source_version === snapshot.version && !checkpoint.deleted_at) {
+                result.skipped += 1;
+                continue;
+            }
+            const op = await this.recordLocalCommitted({
+                path: snapshot.relativePath,
+                resource: (0, SolidFsPathUtils_1.resolveWorkspaceResource)(input.workspace, snapshot.relativePath),
+                source,
+                sourcePath: snapshot.absolutePath,
+                contentType: (0, SolidFsPathUtils_1.contentTypeForPath)(snapshot.relativePath),
+                projection,
+                type: 'created',
+            }, manifest);
+            result.enqueued += op.stage === 'done' ? 0 : 1;
+        }
+        const checkpoints = this.listCheckpoints(input.workspace);
+        for (const checkpoint of checkpoints) {
+            if (currentPaths.has(checkpoint.path) || checkpoint.deleted_at) {
+                continue;
+            }
+            const op = await this.recordLocalCommitted({
+                path: checkpoint.path,
+                resource: (0, SolidFsPathUtils_1.resolveWorkspaceResource)(input.workspace, checkpoint.path),
+                source,
+                sourcePath: node_path_1.default.join(input.cwd, checkpoint.path),
+                contentType: (0, SolidFsPathUtils_1.contentTypeForPath)(checkpoint.path),
+                projection,
+                type: 'deleted',
+                sourceVersion: checkpoint.source_version ?? undefined,
+            }, manifest);
+            result.enqueued += op.stage === 'done' ? 0 : 1;
+        }
+        return result;
+    }
+    async compact() {
+        const now = this.now();
+        const rows = this.db.prepare(`
+      SELECT id, workspace, path, op_type, after_hash, stage, done_at, updated_at, tombstone_confirmed_at
+      FROM sync_ops
+      WHERE stage IN ('done', 'failed_permanent')
+      ORDER BY created_at ASC
+    `).all();
+        const deletable = [];
+        for (const row of rows) {
+            if (row.stage === 'failed_permanent') {
+                if (row.updated_at <= now - this.failedPermanentRetentionMs) {
+                    deletable.push(row.id);
+                }
+                continue;
+            }
+            if (!row.done_at) {
+                continue;
+            }
+            const checkpoint = this.getCheckpoint(row.workspace, row.path);
+            if (!checkpoint) {
+                continue;
+            }
+            if (row.op_type === 'deleted') {
+                if (row.done_at <= now - this.tombstoneRetentionMs &&
+                    row.tombstone_confirmed_at &&
+                    checkpoint.deleted_at) {
+                    deletable.push(row.id);
+                }
+                continue;
+            }
+            if (row.done_at <= now - this.doneRetentionMs && checkpoint.source_version === row.after_hash) {
+                deletable.push(row.id);
+            }
+        }
+        if (deletable.length === 0) {
+            return { deletedOps: 0 };
+        }
+        this.db.transaction(() => {
+            const deleteStatement = this.db.prepare('DELETE FROM sync_ops WHERE id = ?');
+            for (const id of deletable) {
+                deleteStatement.run(id);
+            }
+        })();
+        return { deletedOps: deletable.length };
+    }
+    async validateOperationForReplay(op) {
+        if (op.change.type === 'deleted') {
+            return undefined;
+        }
+        const currentHash = await (0, SolidFsPathUtils_1.maybeFileVersion)(op.change.sourcePath);
+        if (!currentHash) {
+            return `SolidFS journal source is missing: ${op.change.sourcePath}`;
+        }
+        if (op.afterHash && currentHash !== op.afterHash) {
+            return `SolidFS journal source changed before replay: ${op.change.path}`;
+        }
+        return undefined;
+    }
+    getCheckpoint(workspace, relativePath) {
+        return this.db.prepare(`
+      SELECT source_version, deleted_at
+      FROM sync_checkpoints
+      WHERE workspace = ? AND path = ?
+    `).get(workspace, relativePath);
+    }
+    listCheckpoints(workspace) {
+        return this.db.prepare(`
+      SELECT path, source_version, deleted_at
+      FROM sync_checkpoints
+      WHERE workspace = ?
+      ORDER BY path ASC
+    `).all(workspace);
+    }
+    upsertCheckpoint(op, now) {
+        if (op.change.type === 'deleted') {
+            this.db.prepare(`
+        INSERT INTO sync_checkpoints (workspace, path, source_version, deleted_at, updated_at, last_op_id)
+        VALUES (?, ?, NULL, ?, ?, ?)
+        ON CONFLICT(workspace, path) DO UPDATE SET
+          source_version = NULL,
+          deleted_at = excluded.deleted_at,
+          updated_at = excluded.updated_at,
+          last_op_id = excluded.last_op_id
+      `).run(op.workspace.workspace, op.change.path, now, now, op.id);
+            return;
+        }
+        this.db.prepare(`
+      INSERT INTO sync_checkpoints (workspace, path, source_version, deleted_at, updated_at, last_op_id)
+      VALUES (?, ?, ?, NULL, ?, ?)
+      ON CONFLICT(workspace, path) DO UPDATE SET
+        source_version = excluded.source_version,
+        deleted_at = NULL,
+        updated_at = excluded.updated_at,
+        last_op_id = excluded.last_op_id
+    `).run(op.workspace.workspace, op.change.path, op.afterHash ?? null, now, op.id);
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sync_ops (
+        id TEXT PRIMARY KEY,
+        tx_id TEXT,
+        workspace TEXT NOT NULL,
+        path TEXT NOT NULL,
+        op_type TEXT NOT NULL,
+        stage TEXT NOT NULL,
+        source_path TEXT NOT NULL,
+        resource TEXT,
+        content_type TEXT,
+        source TEXT NOT NULL,
+        projection TEXT NOT NULL,
+        source_version TEXT,
+        after_hash TEXT,
+        workspace_json TEXT NOT NULL,
+        change_json TEXT NOT NULL,
+        retry_count INTEGER NOT NULL DEFAULT 0,
+        last_error TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        done_at INTEGER,
+        tombstone_confirmed_at INTEGER
+      );
+
+      CREATE INDEX IF NOT EXISTS sync_ops_stage_created_idx
+        ON sync_ops(stage, created_at);
+      CREATE INDEX IF NOT EXISTS sync_ops_workspace_path_idx
+        ON sync_ops(workspace, path);
+
+      CREATE TABLE IF NOT EXISTS sync_checkpoints (
+        workspace TEXT NOT NULL,
+        path TEXT NOT NULL,
+        source_version TEXT,
+        deleted_at INTEGER,
+        updated_at INTEGER NOT NULL,
+        last_op_id TEXT,
+        PRIMARY KEY (workspace, path)
+      );
+    `);
+    }
+}
+exports.SqliteSolidFsSyncJournal = SqliteSolidFsSyncJournal;
+class JournaledSolidFsSyncer {
+    constructor(options) {
+        this.syncer = options.syncer;
+        this.journal = options.journal;
+    }
+    shouldTrack(input) {
+        return this.syncer.shouldTrack?.(input) ?? true;
+    }
+    shouldTrackPath(relativePath) {
+        return this.syncer.shouldTrackPath?.(relativePath) ?? (0, RdfContentTypes_1.isLineAddressableRdfPath)(relativePath);
+    }
+    async sync(change, workspace, context) {
+        const op = await this.journal.recordLocalCommitted(change, workspace);
+        if (op.stage === 'done') {
+            return;
+        }
+        try {
+            await this.syncer.sync(change, workspace, context);
+            await this.journal.markDone(op.id);
+        }
+        catch (error) {
+            await this.journal.markRetryableFailure(op.id, error);
+            throw error;
+        }
+    }
+    async replayPending(context) {
+        return this.journal.replayPending(this.syncer, context);
+    }
+    async compact() {
+        return this.journal.compact();
+    }
+    async bootstrapWorkspace(input) {
+        return this.journal.bootstrapWorkspace({
+            ...input,
+            shouldTrackPath: input.shouldTrackPath ?? this.shouldTrackPath.bind(this),
+        });
+    }
+}
+exports.JournaledSolidFsSyncer = JournaledSolidFsSyncer;
+class WorkspaceJournaledSolidFsSyncer {
+    constructor(options) {
+        this.options = options;
+        this.journals = new Map();
+        this.syncer = options.syncer;
+    }
+    shouldTrack(input) {
+        return this.syncer.shouldTrack?.(input) ?? true;
+    }
+    shouldTrackPath(relativePath) {
+        return this.syncer.shouldTrackPath?.(relativePath) ?? (0, RdfContentTypes_1.isLineAddressableRdfPath)(relativePath);
+    }
+    async initializeWorkspace(workspace, context) {
+        const journal = this.journalFor(workspace);
+        await journal.bootstrapWorkspace({
+            workspace: workspace.workspace,
+            cwd: workspace.cwd,
+            projection: workspace.projection,
+            source: (0, SolidFsPathUtils_1.sourceForProjection)(workspace.projection, workspace.workspace),
+            shouldTrackPath: this.shouldTrackPath.bind(this),
+        });
+        await journal.replayPending(this.syncer, context);
+        await journal.compact();
+    }
+    async sync(change, workspace, context) {
+        const journal = this.journalFor(workspace);
+        const op = await journal.recordLocalCommitted(change, workspace);
+        if (op.stage === 'done') {
+            return;
+        }
+        try {
+            await this.syncer.sync(change, workspace, context);
+            await journal.markDone(op.id);
+        }
+        catch (error) {
+            await journal.markRetryableFailure(op.id, error);
+            throw error;
+        }
+    }
+    async replayPending(workspace, context) {
+        return this.journalFor(workspace).replayPending(this.syncer, context);
+    }
+    async compact(workspace) {
+        return this.journalFor(workspace).compact();
+    }
+    journalPathFor(workspace) {
+        return this.options.resolveJournalPath?.(workspace)
+            ?? resolveSolidFsJournalPath(workspace, this.options.journalRoot ?? process.env.XPOD_SOLIDFS_JOURNAL_ROOT);
+    }
+    close() {
+        for (const journal of this.journals.values()) {
+            journal.close();
+        }
+        this.journals.clear();
+    }
+    journalFor(workspace) {
+        const journalPath = this.journalPathFor(workspace);
+        const existing = this.journals.get(journalPath);
+        if (existing) {
+            return existing;
+        }
+        const journal = new SqliteSolidFsSyncJournal({
+            path: journalPath,
+            now: this.options.now,
+            doneRetentionMs: this.options.doneRetentionMs,
+            tombstoneRetentionMs: this.options.tombstoneRetentionMs,
+            failedPermanentRetentionMs: this.options.failedPermanentRetentionMs,
+        });
+        this.journals.set(journalPath, journal);
+        return journal;
+    }
+}
+exports.WorkspaceJournaledSolidFsSyncer = WorkspaceJournaledSolidFsSyncer;
+function resolveSolidFsJournalPath(workspace, journalRoot) {
+    const root = journalRoot
+        ? node_path_1.default.resolve(journalRoot)
+        : node_path_1.default.join(node_path_1.default.dirname(node_path_1.default.resolve(workspace.cwd)), '.xpod-control', 'solidfs-journals');
+    const basename = safeJournalSegment(node_path_1.default.basename(workspace.cwd) || 'workspace');
+    const key = (0, node_crypto_1.createHash)('sha256')
+        .update(workspace.workspace)
+        .digest('hex')
+        .slice(0, 16);
+    return node_path_1.default.join(root, `${basename}-${key}`, 'sync-journal.sqlite');
+}
+function rowToOperation(row) {
+    return {
+        id: row.id,
+        txId: row.tx_id ?? undefined,
+        workspace: JSON.parse(row.workspace_json),
+        change: JSON.parse(row.change_json),
+        stage: row.stage,
+        afterHash: row.after_hash ?? undefined,
+        retryCount: row.retry_count,
+        lastError: row.last_error ?? undefined,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        doneAt: row.done_at ?? undefined,
+    };
+}
+function journalWorkspaceSnapshot(workspace) {
+    return {
+        workspace: workspace.workspace,
+        cwd: workspace.cwd,
+        projection: workspace.projection,
+        entries: [],
+    };
+}
+function normalizeChange(change) {
+    return {
+        ...change,
+        path: change.path.split(/[\\/]+/u).join(node_path_1.default.sep),
+    };
+}
+function operationId(workspace, change, afterHash) {
+    const digest = (0, node_crypto_1.createHash)('sha256')
+        .update(JSON.stringify({
+        workspace,
+        path: change.path,
+        type: change.type,
+        resource: change.resource,
+        source: change.source,
+        sourcePath: change.sourcePath,
+        projection: change.projection,
+        sourceVersion: change.sourceVersion,
+        afterHash,
+    }))
+        .digest('hex')
+        .slice(0, 32);
+    return `sync_${digest}`;
+}
+function safeJournalSegment(value) {
+    const safe = value.replace(/[^a-zA-Z0-9._-]+/gu, '_').slice(0, 64);
+    return safe || 'workspace';
+}
+function errorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+//# sourceMappingURL=SolidFsSyncJournal.js.map