@smthrs/engine-store 0.0.0-stage → 1.0.0-rc.3

package/dist/esm/DisasterRecovery.d.ts

@@ -0,0 +1,431 @@
+/**
+ * Hot backup, verified restore, and restore-time fencing for the durable
+ * flows store.
+ *
+ * A backup captures the whole SQLite database — journal, run store, step
+ * cache, engine state, and the out-of-ladder objects created by
+ * `internal/EngineStateSchema.ts` — with `VACUUM INTO`, which reads one
+ * consistent snapshot under WAL while writers stay live. The content-addressed
+ * artifact blobs are copied beside it, digest-verified, after the database
+ * snapshot: results reference artifacts only after publication
+ * (`packages/smithers/flows/step-cache/docs/api.md`), so a blob walk taken after the
+ * database snapshot is a superset of every digest the snapshot references.
+ * A manifest written last records the digests a restore must verify, so a
+ * partial backup is detectable by its missing manifest.
+ *
+ * Restore never lets a pre-backup owner resurrect. The fencing token is the
+ * `OwnerId` triple mirrored on `flows_runs` and arbitrated by the journal's
+ * `flows_consensus_leases` — Temporal's shard `rangeID` equality check reduced
+ * to one SQL predicate (`reference/temporal`
+ * `service/history/shard/context_impl.go`, `renewRangeLocked`). Temporal
+ * fences a restored shard by bumping the persisted epoch above anything a
+ * surviving owner could hold; the equivalent bump for an identity fence is
+ * {@link fence}: clear every persisted claim, owner, and consensus lease in
+ * one serialized write transaction, so every pre-backup `OwnerId` fails its
+ * equality compare-and-swap (`FenceLost`, journal `fence_lost`) and the
+ * restored runs are claimable immediately instead of after the heartbeat
+ * staleness cutoff.
+ *
+ * Host access arrives through Effect's `FileSystem` and `SqlClient` tags and
+ * hashing through the injected `Crypto` service, so the module carries no
+ * platform binding. The SQL dialect is SQLite — a non-SQLite backend fails
+ * with the `sql` code rather than pretending to snapshot. Every file is
+ * stat-checked before it is buffered for hashing or copying. The configurable
+ * ceiling defaults to {@link defaultMaxFileSizeBytes}; an oversized file fails
+ * with the typed `io` code instead of reaching the host's allocation limit.
+ *
+ * @since 0.1.0
+ */
+import { DurableWriter } from "@smthrs/database/DurableWriter";
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import type * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+/**
+ * The database file name inside a backup directory and a restored store
+ * directory.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const databaseFileName = "store.sqlite3";
+/**
+ * The manifest file name inside a backup directory. It is written last, so
+ * its presence marks a complete backup.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const manifestFileName = "manifest.json";
+/**
+ * The artifact blob directory name inside a backup directory and a restored
+ * store directory, laid out with the store's own two-hex-prefix fanout.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const objectsDirectoryName = "objects";
+/**
+ * The marker file a restore writes into the target directory, recording when
+ * the restore happened and which backup it came from.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const restoredMarkerFileName = "restored.json";
+/**
+ * Default ceiling for one backup file read into memory: 512 MiB.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const defaultMaxFileSizeBytes: number;
+/**
+ * One applied row of the shared `flows_migrations` table, recorded at backup
+ * time and re-verified at fence time as the schema version of the snapshot.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const AppliedMigration: Schema.Struct<{
+    readonly migrationId: Schema.Number;
+    readonly name: Schema.String;
+}>;
+/**
+ * One applied row of the shared `flows_migrations` table.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type AppliedMigration = typeof AppliedMigration.Type;
+/**
+ * One captured artifact blob. `sizeBytes` is informational for operators; the
+ * digest is the integrity check.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const ArtifactEntry: Schema.Struct<{
+    readonly digest: Schema.brand<Schema.String, "@smthrs/crypto/Sha256/Digest">;
+    readonly sizeBytes: Schema.Number;
+}>;
+/**
+ * One captured artifact blob.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ArtifactEntry = typeof ArtifactEntry.Type;
+/**
+ * The verification contract of a backup: the database snapshot's digest and
+ * schema version, and the digest of every captured artifact blob.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const BackupManifest: Schema.Struct<{
+    readonly formatVersion: Schema.Literal<1>;
+    readonly createdAtMs: Schema.Number;
+    readonly database: Schema.Struct<{
+        readonly file: Schema.Literal<"store.sqlite3">;
+        readonly sha256: Schema.brand<Schema.String, "@smthrs/crypto/Sha256/Digest">;
+        readonly sizeBytes: Schema.Number;
+        readonly migrations: Schema.$Array<Schema.Struct<{
+            readonly migrationId: Schema.Number;
+            readonly name: Schema.String;
+        }>>;
+    }>;
+    readonly artifacts: Schema.$Array<Schema.Struct<{
+        readonly digest: Schema.brand<Schema.String, "@smthrs/crypto/Sha256/Digest">;
+        readonly sizeBytes: Schema.Number;
+    }>>;
+}>;
+/**
+ * The verification contract of a backup.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type BackupManifest = typeof BackupManifest.Type;
+/**
+ * Stable failure codes surfaced by backup, verify, restore, and fence.
+ * `invalid_options` reports a public option that cannot be admitted safely.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare const DisasterRecoveryErrorCode: Schema.Literals<readonly ["invalid_options", "not_empty", "invalid_manifest", "missing_file", "digest_mismatch", "artifact_corruption", "snapshot_incomplete", "schema_mismatch", "io", "sql"]>;
+/**
+ * A stable disaster-recovery failure code.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export type DisasterRecoveryErrorCode = typeof DisasterRecoveryErrorCode.Type;
+declare const DisasterRecoveryError_base: Schema.Class<DisasterRecoveryError, Schema.TaggedStruct<"@smthrs/engine-store/DisasterRecoveryError", {
+    readonly code: Schema.Literals<readonly ["invalid_options", "not_empty", "invalid_manifest", "missing_file", "digest_mismatch", "artifact_corruption", "snapshot_incomplete", "schema_mismatch", "io", "sql"]>;
+    readonly method: Schema.String;
+    readonly message: Schema.String;
+    readonly cause: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A normalized backup or restore failure. The identity string equals this
+ * module's package path, per the house rule that a new identity is the
+ * defining module path.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class DisasterRecoveryError extends DisasterRecoveryError_base {
+}
+/**
+ * Shared buffering limit for backup, verification, and restore operations.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface FileSizeOptions {
+    /**
+     * Largest file, in bytes, that backup, verification, or restore may buffer.
+     * The value must be a finite non-negative safe integer. Defaults to
+     * {@link defaultMaxFileSizeBytes}.
+     */
+    readonly maxFileSizeBytes?: number | undefined;
+}
+/**
+ * Where a backup is written and which artifact store it captures.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface BackupOptions<R = never, E = never> extends FileSizeOptions {
+    /** The directory the backup is written into. Created when absent; must be empty when present. */
+    readonly directory: string;
+    /**
+     * The live store's content-addressed objects directory (the
+     * `ArtifactStore.layerFileSystem` directory). When set, the whole capture
+     * holds the cross-process artifact backup lease, so a concurrent
+     * `ArtifactGc.gc` sweep cannot delete a blob between the database snapshot
+     * and its copy. Absent means the composition has no filesystem artifact
+     * tier: the backup carries no blobs and takes no lease, because there is
+     * no objects directory to fence, and a frozen snapshot that references any
+     * artifact digest fails with `snapshot_incomplete` instead of reporting
+     * success. A filesystem-backed composition must therefore pass the same
+     * directory it gives `ArtifactStore.layerFileSystem`.
+     */
+    readonly objectsDirectory?: string | undefined;
+    /**
+     * Opens the frozen `VACUUM INTO` file so backup can enumerate artifact
+     * roots and migrations from that exact snapshot, independently of the live
+     * connection. The host should open this file without applying migrations.
+     */
+    readonly snapshotDatabaseLayer: (databaseFile: string) => Layer.Layer<SqlClient.SqlClient, E, R>;
+}
+/**
+ * Which backup to restore and where the restored store lands.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface RestoreOptions extends FileSizeOptions {
+    /** The directory a previous {@link backup} wrote. */
+    readonly backupDirectory: string;
+    /** The fresh directory the restored store is written into. Created when absent; must be empty when present. */
+    readonly targetDirectory: string;
+}
+/**
+ * Which backup to restore and how to open the freshly restored SQLite file
+ * for restore-time fencing.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface RestoreAndFenceOptions<R = never, E = never> extends RestoreOptions {
+    /**
+     * Builds the database and durable-writer layer for the newly restored file.
+     * This keeps database opening as the caller's host composition rather than
+     * importing a Node-only driver into this browser-safe module.
+     */
+    readonly databaseLayer: (databaseFile: string) => Layer.Layer<DurableWriter | SqlClient.SqlClient, E, R>;
+}
+/**
+ * The restored store's on-disk locations, ready to compose database and
+ * artifact layers over.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface RestoredStore {
+    readonly databaseFile: string;
+    readonly objectsDirectory: string;
+    readonly manifest: BackupManifest;
+}
+/**
+ * A restored store after restore-time fencing has invalidated pre-backup
+ * owners.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface FencedRestoredStore extends RestoredStore {
+    readonly fence: FenceSummary;
+}
+/**
+ * What {@link fence} invalidated on the restored store.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface FenceSummary {
+    /** Runs whose pending claim columns were cleared. */
+    readonly clearedClaims: number;
+    /** Runs that were `running` at backup time, now suspended with their owner fence cleared. */
+    readonly suspendedRuns: number;
+}
+/**
+ * Captures a hot backup of the live store into an empty directory.
+ *
+ * The database is snapshotted first with `VACUUM INTO` — a read transaction
+ * under WAL, so live writers are never blocked and the copy is one consistent
+ * point in time. The artifact walk runs after it, so every digest the
+ * snapshot references is captured (publication precedes reference). Blobs are
+ * digest-verified as they are copied; a blob whose bytes no longer hash to
+ * its address fails the backup loudly rather than capturing corruption. The
+ * manifest is encoded and admitted under the same file-size ceiling before it
+ * is written last, so a successful backup remains readable with its own
+ * options.
+ *
+ * With an `objectsDirectory`, the whole capture holds the artifact backup
+ * lease, so concurrent sweep deletion cannot remove a referenced blob
+ * mid-copy. Without one, no lease is taken; the frozen-root verification
+ * still fails the backup loudly when the snapshot references any blob, so an
+ * unfenced capture can never report success while missing artifact bytes.
+ *
+ * @since 0.1.0
+ * @category operations
+ */
+export declare const backup: <R = never, E = never>(options: BackupOptions<R, E>) => Effect.Effect<BackupManifest, DisasterRecoveryError | E, SqlClient.SqlClient | FileSystem.FileSystem | Crypto.Crypto | R>;
+/**
+ * Verifies a backup directory against its manifest without restoring it:
+ * the manifest decodes, the database snapshot hashes to its recorded digest,
+ * and every listed artifact blob is present and hashes to its address.
+ *
+ * @since 0.1.0
+ * @category operations
+ */
+export declare const verify: (backupDirectory: string, options?: FileSizeOptions | undefined) => Effect.Effect<{
+    readonly formatVersion: 1;
+    readonly createdAtMs: number;
+    readonly database: {
+        readonly file: "store.sqlite3";
+        readonly sha256: string & import("effect/Brand").Brand<"@smthrs/crypto/Sha256/Digest">;
+        readonly sizeBytes: number;
+        readonly migrations: readonly {
+            readonly migrationId: number;
+            readonly name: string;
+        }[];
+    };
+    readonly artifacts: readonly {
+        readonly digest: string & import("effect/Brand").Brand<"@smthrs/crypto/Sha256/Digest">;
+        readonly sizeBytes: number;
+    }[];
+}, DisasterRecoveryError, FileSystem.FileSystem | Crypto.Crypto>;
+/**
+ * Restores a verified backup into an empty target directory.
+ *
+ * Every byte is re-verified against the manifest as it is copied, so a backup
+ * that rotted in storage is refused rather than restored. The target holds
+ * the database file, the objects directory, and a `restored.json` marker; it
+ * is a fresh store directory to compose `NodeDatabase.layer` and
+ * `ArtifactStore.layerFileSystem` over. The database is restored with the
+ * pre-backup owner fences still in place — run {@link fence} against it
+ * before any engine adopts it.
+ *
+ * @since 0.1.0
+ * @category operations
+ */
+export declare const restore: (options: RestoreOptions) => Effect.Effect<{
+    databaseFile: string;
+    objectsDirectory: string;
+    manifest: {
+        readonly formatVersion: 1;
+        readonly createdAtMs: number;
+        readonly database: {
+            readonly file: "store.sqlite3";
+            readonly sha256: string & import("effect/Brand").Brand<"@smthrs/crypto/Sha256/Digest">;
+            readonly sizeBytes: number;
+            readonly migrations: readonly {
+                readonly migrationId: number;
+                readonly name: string;
+            }[];
+        };
+        readonly artifacts: readonly {
+            readonly digest: string & import("effect/Brand").Brand<"@smthrs/crypto/Sha256/Digest">;
+            readonly sizeBytes: number;
+        }[];
+    };
+}, DisasterRecoveryError, FileSystem.FileSystem | Crypto.Crypto>;
+/**
+ * Bumps the restored store's fencing epoch so pre-backup owners are fenced
+ * out.
+ *
+ * The store's fence is `OwnerId` equality, so the epoch bump is fence
+ * invalidation: in one serialized write transaction every pending claim is
+ * cleared, every run that was `running` at backup time is suspended with its
+ * owner and heartbeat cleared, and every consensus lease is deleted. A
+ * surviving pre-backup owner then fails every fenced operation against the
+ * restored store — `heartbeat` and `transitionOwned` report `FenceLost`,
+ * fenced journal appends fail `fence_lost` — exactly as a stale Temporal owner
+ * fails its `rangeID` compare-and-swap. The suspended runs are claimable
+ * immediately, without waiting out the heartbeat staleness cutoff and without
+ * liveness evidence.
+ *
+ * Every migration recorded in the manifest must remain applied with the same
+ * ID and namespaced name. Forward additions within any installed block are
+ * compatible, including engine-store `3006` below an existing plan `4003`;
+ * the current database layer applies them on open. A missing or renamed
+ * historical entry fails `schema_mismatch` before ownership is cleared.
+ *
+ * In-flight attempt rows are deliberately untouched: attempt writes are
+ * fenced on the run row's ownership, and the resuming engine adopts or
+ * retries them under its own fresh owner.
+ *
+ * @since 0.1.0
+ * @category operations
+ */
+export declare const fence: (manifest: {
+    readonly formatVersion: 1;
+    readonly createdAtMs: number;
+    readonly database: {
+        readonly file: "store.sqlite3";
+        readonly sha256: string & import("effect/Brand").Brand<"@smthrs/crypto/Sha256/Digest">;
+        readonly sizeBytes: number;
+        readonly migrations: readonly {
+            readonly migrationId: number;
+            readonly name: string;
+        }[];
+    };
+    readonly artifacts: readonly {
+        readonly digest: string & import("effect/Brand").Brand<"@smthrs/crypto/Sha256/Digest">;
+        readonly sizeBytes: number;
+    }[];
+}) => Effect.Effect<{
+    clearedClaims: number;
+    suspendedRuns: number;
+}, DisasterRecoveryError, SqlClient.SqlClient | DurableWriter>;
+/**
+ * Restores a backup and immediately fences the restored database.
+ *
+ * This is the one-shot operator API for disaster recovery. The database
+ * driver itself still arrives through a caller-supplied Layer so this module
+ * remains host-neutral and browser-bundleable; the bundled Node script passes
+ * `NodeDatabase.layer` for the restored file.
+ *
+ * @since 0.1.0
+ * @category operations
+ */
+export declare const restoreAndFence: <R = never, E = never>(options: RestoreAndFenceOptions<R, E>) => Effect.Effect<FencedRestoredStore, DisasterRecoveryError | E, FileSystem.FileSystem | Crypto.Crypto | R>;
+export {};
+//# sourceMappingURL=DisasterRecovery.d.ts.map

package/dist/esm/DisasterRecovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DisasterRecovery.d.ts","sourceRoot":"","sources":["../../src/DisasterRecovery.ts"],"names":[],"mappings":"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"}