@knpkv/control-center 0.1.0

package/dist/server/server/persistence/Persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Persistence.d.ts","sourceRoot":"","sources":["../../../../src/server/persistence/Persistence.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qeAkOzD,CAAA;AAEF,8EAA8E;AAC9E,MAAM,WAAW,kBAAmB,SAAQ,OAAO,CAAC,OAAO,eAAe,CAAC;CAAG;;AAE9E,oFAAoF;AACpF,qBAAa,WAAY,SAAQ,gBAEhC;CAAG;AAIJ,kFAAkF;AAClF,eAAO,MAAM,4BAA4B,GACvC,OAAO,OAAO,KACb,KAAK,CAAC,KAAK,CACZ,WAAW,EACX,cAAc,GAAG,sBAAsB,EACvC,MAAM,CAAC,MAAM,GAAG,QAAQ,GAAG,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAuD3D,CAAA;AAEH,qFAAqF;AACrF,eAAO,MAAM,gBAAgB,GAC3B,OAAO,OAAO,KACb,KAAK,CAAC,KAAK,CACZ,WAAW,EACX,qBAAqB,EACrB,MAAM,CAAC,MAAM,GAAG,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAC+B,CAAA"}

package/dist/server/server/persistence/PersistenceConfig.d.ts

@@ -0,0 +1,27 @@
+import { Effect, Schema } from "effect";
+import { PersistenceConfigError } from "./errors.js";
+/** Local libSQL database URL accepted by the Control Center persistence layer. */
+export declare const LocalDatabaseUrl: Schema.brand<Schema.String, "LocalDatabaseUrl">;
+/** Decoded local libSQL database URL. */
+export type LocalDatabaseUrl = typeof LocalDatabaseUrl.Type;
+/** Absolute owner-controlled root for content-addressed blob bytes. */
+export declare const BlobRoot: Schema.brand<Schema.String, "BlobRoot">;
+/** Decoded owner-controlled blob root. */
+export type BlobRoot = typeof BlobRoot.Type;
+/** Secret-free configuration shared by the database and blob persistence layers. */
+export declare const PersistenceConfig: Schema.Struct<{
+    readonly blobRoot: Schema.brand<Schema.String, "BlobRoot">;
+    readonly busyTimeoutMilliseconds: Schema.Literal<5000>;
+    readonly databaseUrl: Schema.brand<Schema.String, "LocalDatabaseUrl">;
+    readonly maxConnections: Schema.Literal<1>;
+}>;
+/** Decoded Control Center persistence configuration. */
+export type PersistenceConfig = typeof PersistenceConfig.Type;
+/** Decode untrusted persistence configuration without exposing rejected values. */
+export declare const decodePersistenceConfig: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+    readonly blobRoot: Schema.brand<Schema.String, "BlobRoot">;
+    readonly busyTimeoutMilliseconds: Schema.Literal<5000>;
+    readonly databaseUrl: Schema.brand<Schema.String, "LocalDatabaseUrl">;
+    readonly maxConnections: Schema.Literal<1>;
+}, "Type">, PersistenceConfigError, never>;
+//# sourceMappingURL=PersistenceConfig.d.ts.map

package/dist/server/server/persistence/PersistenceConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistenceConfig.d.ts","sourceRoot":"","sources":["../../../../src/server/persistence/PersistenceConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAwBpD,kFAAkF;AAClF,eAAO,MAAM,gBAAgB,iDAOW,CAAA;AAExC,yCAAyC;AACzC,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D,uEAAuE;AACvE,eAAO,MAAM,QAAQ,yCAKW,CAAA;AAEhC,0CAA0C;AAC1C,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C,oFAAoF;AACpF,eAAO,MAAM,iBAAiB;;;;;EAKkB,CAAA;AAEhD,wDAAwD;AACxD,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAA;AAE7D,mFAAmF;AACnF,eAAO,MAAM,uBAAuB;;;;;0CAYlC,CAAA"}

package/dist/server/server/persistence/backup/BackupArchive.d.ts

@@ -0,0 +1,32 @@
+import type { Crypto } from "effect";
+import { Effect, FileSystem, Path } from "effect";
+import type * as Scope from "effect/Scope";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import type { PersistenceConfig } from "../PersistenceConfig.js";
+import type { BackupVerification, PublishedBackup, RestoredBackup } from "./BackupManifest.js";
+import { type BackupFailure } from "./errors.js";
+/** Input for a caller-requested backup of the live database. */
+export interface CreateVerifiedBackupInput {
+    readonly destination: string;
+    readonly persistenceConfig: PersistenceConfig;
+    readonly sql: SqlClient.SqlClient;
+}
+/** Input for an offline backup that opens an existing database without changing its schema. */
+export interface CreateOfflineVerifiedBackupInput {
+    readonly destination: string;
+    readonly persistenceConfig: PersistenceConfig;
+}
+/** Input for restoring a verified archive into a nonexistent configured data root. */
+export interface RestoreBackupInput {
+    readonly archiveRoot: string;
+    readonly configuredDataRoot: string;
+}
+/** Verify a complete physical archive without modifying it. */
+export declare const verifyBackup: (configuredArchiveRoot: string) => Effect.Effect<BackupVerification, BackupFailure, Crypto.Crypto | FileSystem.FileSystem | Path.Path>;
+/** Create and verify a portable manual backup using SQLite's consistent snapshot operation. */
+export declare const createVerifiedBackup: (input: CreateVerifiedBackupInput) => Effect.Effect<PublishedBackup, BackupFailure, Scope.Scope | Crypto.Crypto | FileSystem.FileSystem | Path.Path>;
+/** Create a verified backup from an existing, stopped data root without changing its schema. */
+export declare const createOfflineVerifiedBackup: (input: CreateOfflineVerifiedBackupInput) => Effect.Effect<PublishedBackup, BackupFailure, Crypto.Crypto | FileSystem.FileSystem | Path.Path>;
+/** Verify, restore, revalidate, and exclusively publish a fresh Control Center data root. */
+export declare const restoreBackup: (input: RestoreBackupInput) => Effect.Effect<RestoredBackup, BackupFailure, Crypto.Crypto | FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=BackupArchive.d.ts.map

package/dist/server/server/persistence/backup/BackupArchive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackupArchive.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/backup/BackupArchive.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACpC,OAAO,EAAW,MAAM,EAAE,UAAU,EAAiB,IAAI,EAAqB,MAAM,QAAQ,CAAA;AAC5F,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAS1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAEhE,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAE9F,OAAO,EAAE,KAAK,aAAa,EAAwD,MAAM,aAAa,CAAA;AAuBtG,gEAAgE;AAChE,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAA;IAC7C,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC,SAAS,CAAA;CAClC;AAED,+FAA+F;AAC/F,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAA;CAC9C;AAED,sFAAsF;AACtF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAA;CACpC;AAED,+DAA+D;AAC/D,eAAO,MAAM,YAAY,wIAQvB,CAAA;AAEF,+FAA+F;AAC/F,eAAO,MAAM,oBAAoB,sJAa/B,CAAA;AAEF,gGAAgG;AAChG,eAAO,MAAM,2BAA2B,+IAkHtC,CAAA;AAEF,6FAA6F;AAC7F,eAAO,MAAM,aAAa,gIA6ExB,CAAA"}

package/dist/server/server/persistence/backup/BackupArchiveCore.d.ts

@@ -0,0 +1,23 @@
+import { Crypto, Effect, FileSystem, Path } from "effect";
+import type * as Scope from "effect/Scope";
+import type { PersistenceConfig } from "../PersistenceConfig.js";
+import { type BackupVerification, type PublishedBackup } from "./BackupManifest.js";
+import { type BackupFailure, BackupIntegrityError, BackupLimitError, BackupStorageError } from "./errors.js";
+/** Internal archive assembly contract; snapshot entry points own how the database file is produced. */
+export interface CreateVerifiedArchiveInput {
+    readonly destination: string;
+    readonly kind: "manual";
+    readonly persistenceConfig: PersistenceConfig;
+    readonly writeDatabase: (destination: string) => Effect.Effect<void, BackupFailure, FileSystem.FileSystem>;
+}
+interface RestoreArchiveWriter<Failure, Requirements> {
+    readonly writeTransferredFile: (pathSegments: ReadonlyArray<string>, bytes: Uint8Array) => Effect.Effect<void, Failure, Requirements>;
+}
+/** Populate an unclaimed data root only from bytes revalidated against the verified archive. */
+export declare const restoreVerifiedArchiveInto: <WriterFailure, WriterRequirements>(configuredArchiveRoot: string, writer: RestoreArchiveWriter<WriterFailure, WriterRequirements>, verification: BackupVerification) => Effect.Effect<undefined, BackupLimitError | BackupStorageError | BackupIntegrityError | WriterFailure, Crypto.Crypto | FileSystem.FileSystem | Path.Path | WriterRequirements>;
+/** Verify a complete archive without modifying it. */
+export declare const verifyBackupInternal: (configuredArchiveRoot: string) => Effect.Effect<BackupVerification, BackupFailure, Crypto.Crypto | FileSystem.FileSystem | Path.Path>;
+/** Assemble and publish one physical, portable database-and-blob archive. */
+export declare const createVerifiedArchive: (input: CreateVerifiedArchiveInput) => Effect.Effect<PublishedBackup, BackupFailure, Scope.Scope | Crypto.Crypto | FileSystem.FileSystem | Path.Path>;
+export {};
+//# sourceMappingURL=BackupArchiveCore.d.ts.map

package/dist/server/server/persistence/backup/BackupArchiveCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackupArchiveCore.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/backup/BackupArchiveCore.ts"],"names":[],"mappings":"AACA,OAAO,EACL,MAAM,EAEN,MAAM,EAGN,UAAU,EAEV,IAAI,EAIL,MAAM,QAAQ,CAAA;AACf,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAK1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACrB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,KAAK,aAAa,EAElB,oBAAoB,EACpB,gBAAgB,EAGhB,kBAAkB,EACnB,MAAM,aAAa,CAAA;AAapB,uGAAuG;AACvG,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAA;IAC7C,QAAQ,CAAC,aAAa,EAAE,CACtB,WAAW,EAAE,MAAM,KAChB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,CAAC,UAAU,CAAC,CAAA;CAC/D;AAOD,UAAU,oBAAoB,CAAC,OAAO,EAAE,YAAY;IAClD,QAAQ,CAAC,oBAAoB,EAAE,CAC7B,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,EACnC,KAAK,EAAE,UAAU,KACd,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,YAAY,CAAC,CAAA;CAChD;AAkMD,gGAAgG;AAChG,eAAO,MAAM,0BAA0B,GACrC,aAAa,EACb,kBAAkB,qTAgDlB,CAAA;AAyKF,sDAAsD;AACtD,eAAO,MAAM,oBAAoB,wIAkC/B,CAAA;AAuJF,6EAA6E;AAC7E,eAAO,MAAM,qBAAqB,uJA8GhC,CAAA"}

package/dist/server/server/persistence/backup/BackupManifest.d.ts

@@ -0,0 +1,136 @@
+import { Schema } from "effect";
+/** Stable identity of one published backup archive. */
+export declare const BackupId: Schema.brand<Schema.String, "BackupId">;
+/** Stable identity of one published backup archive. */
+export type BackupId = typeof BackupId.Type;
+/** Commit boundary and row counts captured from the verified database snapshot. */
+export declare const BackupBoundaryV1: Schema.Struct<{
+    readonly domainEventCursor: Schema.Number;
+    readonly domainEventRows: Schema.Number;
+    readonly entityRevisionRows: Schema.Number;
+    readonly highestEntityRevision: Schema.Number;
+    readonly highestReleaseRevision: Schema.Number;
+    readonly releaseRevisionRows: Schema.Number;
+}>;
+/** Commit boundary and row counts captured from the verified database snapshot. */
+export type BackupBoundaryV1 = typeof BackupBoundaryV1.Type;
+/** One content-addressed object expected by the snapshot database. */
+export declare const BackupBlobEntryV1: Schema.Struct<{
+    readonly byteLength: Schema.Number;
+    readonly classification: Schema.Literals<readonly ["durable", "reproducible-cache"]>;
+    readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+}>;
+/** One content-addressed object expected by the snapshot database. */
+export type BackupBlobEntryV1 = typeof BackupBlobEntryV1.Type;
+/** Database artifact included in every Control Center backup. */
+export declare const BackupDatabaseArtifactV1: Schema.Struct<{
+    readonly byteLength: Schema.Number;
+    readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+    readonly relativePath: Schema.Literal<"control-center.db">;
+}>;
+/** Database artifact included in every Control Center backup. */
+export type BackupDatabaseArtifactV1 = typeof BackupDatabaseArtifactV1.Type;
+/** Count summary cross-checked against the exact blob inventory. */
+export declare const BackupBlobCountsV1: Schema.Struct<{
+    readonly durable: Schema.Number;
+    readonly reproducibleCache: Schema.Number;
+    readonly total: Schema.Number;
+}>;
+/** Strict first version of the portable Control Center backup manifest. */
+export declare const BackupManifestV1: Schema.Struct<{
+    readonly backupId: Schema.brand<Schema.String, "BackupId">;
+    readonly blobs: Schema.$Array<Schema.Struct<{
+        readonly byteLength: Schema.Number;
+        readonly classification: Schema.Literals<readonly ["durable", "reproducible-cache"]>;
+        readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    }>>;
+    readonly boundary: Schema.Struct<{
+        readonly domainEventCursor: Schema.Number;
+        readonly domainEventRows: Schema.Number;
+        readonly entityRevisionRows: Schema.Number;
+        readonly highestEntityRevision: Schema.Number;
+        readonly highestReleaseRevision: Schema.Number;
+        readonly releaseRevisionRows: Schema.Number;
+    }>;
+    readonly counts: Schema.Struct<{
+        readonly durable: Schema.Number;
+        readonly reproducibleCache: Schema.Number;
+        readonly total: Schema.Number;
+    }>;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly database: Schema.Struct<{
+        readonly byteLength: Schema.Number;
+        readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+        readonly relativePath: Schema.Literal<"control-center.db">;
+    }>;
+    readonly format: Schema.Literal<"@knpkv/control-center-backup">;
+    readonly kind: Schema.Literal<"manual">;
+    readonly schemaVersion: Schema.Literal<"unstable">;
+    readonly version: Schema.Literal<1>;
+}>;
+/** Strict first version of the portable Control Center backup manifest. */
+export type BackupManifestV1 = typeof BackupManifestV1.Type;
+/** JSON codec used exclusively at the owner-controlled archive boundary. */
+export declare const BackupManifestJsonV1: Schema.fromJsonString<Schema.Struct<{
+    readonly backupId: Schema.brand<Schema.String, "BackupId">;
+    readonly blobs: Schema.$Array<Schema.Struct<{
+        readonly byteLength: Schema.Number;
+        readonly classification: Schema.Literals<readonly ["durable", "reproducible-cache"]>;
+        readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    }>>;
+    readonly boundary: Schema.Struct<{
+        readonly domainEventCursor: Schema.Number;
+        readonly domainEventRows: Schema.Number;
+        readonly entityRevisionRows: Schema.Number;
+        readonly highestEntityRevision: Schema.Number;
+        readonly highestReleaseRevision: Schema.Number;
+        readonly releaseRevisionRows: Schema.Number;
+    }>;
+    readonly counts: Schema.Struct<{
+        readonly durable: Schema.Number;
+        readonly reproducibleCache: Schema.Number;
+        readonly total: Schema.Number;
+    }>;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly database: Schema.Struct<{
+        readonly byteLength: Schema.Number;
+        readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+        readonly relativePath: Schema.Literal<"control-center.db">;
+    }>;
+    readonly format: Schema.Literal<"@knpkv/control-center-backup">;
+    readonly kind: Schema.Literal<"manual">;
+    readonly schemaVersion: Schema.Literal<"unstable">;
+    readonly version: Schema.Literal<1>;
+}>>;
+/** Reproducible object that can be recovered rather than making restore fail. */
+export declare const ReproducibleBlobGap: Schema.Struct<{
+    readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+    readonly reason: Schema.Literals<readonly ["corrupt", "missing"]>;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+}>;
+/** Reproducible object that can be recovered rather than making restore fail. */
+export type ReproducibleBlobGap = typeof ReproducibleBlobGap.Type;
+/** Verified archive state; only reproducible content may produce a degraded success. */
+export type BackupVerification = {
+    readonly _tag: "Complete";
+    readonly manifest: BackupManifestV1;
+    readonly reproducibleBlobGaps: readonly [];
+} | {
+    readonly _tag: "RecoverableCacheGaps";
+    readonly manifest: BackupManifestV1;
+    readonly reproducibleBlobGaps: ReadonlyArray<ReproducibleBlobGap>;
+};
+/** Result returned after exclusive destination claim, manifest-last completion, and verification. */
+export interface PublishedBackup {
+    readonly archiveRoot: string;
+    readonly verification: BackupVerification;
+}
+/** Result returned only after a verified restore has been durably claimed. */
+export interface RestoredBackup {
+    readonly configuredDataRoot: string;
+    readonly verification: BackupVerification;
+}
+//# sourceMappingURL=BackupManifest.d.ts.map

package/dist/server/server/persistence/backup/BackupManifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackupManifest.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/backup/BackupManifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAW/B,uDAAuD;AACvD,eAAO,MAAM,QAAQ,yCAGW,CAAA;AAEhC,uDAAuD;AACvD,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C,mFAAmF;AACnF,eAAO,MAAM,gBAAgB;;;;;;;EAO3B,CAAA;AAEF,mFAAmF;AACnF,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D,sEAAsE;AACtE,eAAO,MAAM,iBAAiB;;;;;EAK5B,CAAA;AAEF,sEAAsE;AACtE,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAA;AAE7D,iEAAiE;AACjE,eAAO,MAAM,wBAAwB;;;;EAInC,CAAA;AAEF,iEAAiE;AACjE,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAC,IAAI,CAAA;AAE3E,oEAAoE;AACpE,eAAO,MAAM,kBAAkB;;;;EAI7B,CAAA;AAEF,2EAA2E;AAC3E,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWkB,CAAA;AAE/C,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D,4EAA4E;AAC5E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0C,CAAA;AAE3E,iFAAiF;AACjF,eAAO,MAAM,mBAAmB;;;;EAI9B,CAAA;AAEF,iFAAiF;AACjF,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;AAEjE,wFAAwF;AACxF,MAAM,MAAM,kBAAkB,GAC1B;IACA,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAA;IACnC,QAAQ,CAAC,oBAAoB,EAAE,SAAS,EAAE,CAAA;CAC3C,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAA;IACrC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAA;IACnC,QAAQ,CAAC,oBAAoB,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAA;CAClE,CAAA;AAEH,qGAAqG;AACrG,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAA;CAC1C;AAED,8EAA8E;AAC9E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAA;IACnC,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAA;CAC1C"}

package/dist/server/server/persistence/backup/DatabaseSnapshot.d.ts

@@ -0,0 +1,53 @@
+import { Effect, Schema } from "effect";
+import type * as SqlClient from "effect/unstable/sql/SqlClient";
+import { CURRENT_SCHEMA_VERSION } from "../schema.js";
+import { BackupBlobEntryV1, BackupBoundaryV1 } from "./BackupManifest.js";
+import { BackupIntegrityError, BackupManifestError, BackupSqlError } from "./errors.js";
+/** Exact inventory read from a consistent SQLite snapshot. */
+export interface DatabaseSnapshotInventory {
+    readonly blobs: ReadonlyArray<typeof BackupBlobEntryV1.Type>;
+    readonly boundary: typeof BackupBoundaryV1.Type;
+    readonly schemaVersion: typeof CURRENT_SCHEMA_VERSION;
+}
+/** Verify SQLite page and foreign-key integrity without changing the database. */
+export declare const verifyDatabaseIntegrity: (sql: SqlClient.SqlClient) => Effect.Effect<undefined, BackupSqlError | BackupIntegrityError, never>;
+/** Require the exact unstable schema from a snapshot. */
+export declare const readSupportedSchema: (sql: SqlClient.SqlClient) => Effect.Effect<"unstable", BackupManifestError, never>;
+/** Read the authoritative schema, boundary, and blob inventory from one snapshot. */
+export declare const readDatabaseSnapshotInventory: (sql: SqlClient.SqlClient) => Effect.Effect<DatabaseSnapshotInventory, BackupSqlError | BackupManifestError | BackupIntegrityError, never>;
+/** Create a transactionally consistent standalone SQLite database file. */
+export declare const vacuumDatabaseInto: (sql: SqlClient.SqlClient, destination: string) => Effect.Effect<void, BackupSqlError, never>;
+/** Cross-check a decoded manifest against its authoritative snapshot inventory. */
+export declare const verifyManifestInventory: (manifest: Schema.Struct.ReadonlySide<{
+    readonly backupId: Schema.brand<Schema.String, "BackupId">;
+    readonly blobs: Schema.$Array<Schema.Struct<{
+        readonly byteLength: Schema.Number;
+        readonly classification: Schema.Literals<readonly ["durable", "reproducible-cache"]>;
+        readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    }>>;
+    readonly boundary: Schema.Struct<{
+        readonly domainEventCursor: Schema.Number;
+        readonly domainEventRows: Schema.Number;
+        readonly entityRevisionRows: Schema.Number;
+        readonly highestEntityRevision: Schema.Number;
+        readonly highestReleaseRevision: Schema.Number;
+        readonly releaseRevisionRows: Schema.Number;
+    }>;
+    readonly counts: Schema.Struct<{
+        readonly durable: Schema.Number;
+        readonly reproducibleCache: Schema.Number;
+        readonly total: Schema.Number;
+    }>;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly database: Schema.Struct<{
+        readonly byteLength: Schema.Number;
+        readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+        readonly relativePath: Schema.Literal<"control-center.db">;
+    }>;
+    readonly format: Schema.Literal<"@knpkv/control-center-backup">;
+    readonly kind: Schema.Literal<"manual">;
+    readonly schemaVersion: Schema.Literal<"unstable">;
+    readonly version: Schema.Literal<1>;
+}, "Type">, inventory: DatabaseSnapshotInventory) => Effect.Effect<undefined, BackupManifestError, never>;
+//# sourceMappingURL=DatabaseSnapshot.d.ts.map

package/dist/server/server/persistence/backup/DatabaseSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatabaseSnapshot.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/backup/DatabaseSnapshot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAE/D,OAAO,EAAE,sBAAsB,EAAyB,MAAM,cAAc,CAAA;AAC5E,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAyB,MAAM,qBAAqB,CAAA;AAChG,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AASvF,8DAA8D;AAC9D,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAA;IAC5D,QAAQ,CAAC,QAAQ,EAAE,OAAO,gBAAgB,CAAC,IAAI,CAAA;IAC/C,QAAQ,CAAC,aAAa,EAAE,OAAO,sBAAsB,CAAA;CACtD;AAoED,kFAAkF;AAClF,eAAO,MAAM,uBAAuB,sGAqBlC,CAAA;AAEF,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,qFAO9B,CAAA;AAgBF,qFAAqF;AACrF,eAAO,MAAM,6BAA6B,4IAkBxC,CAAA;AAEF,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,+FAK7B,CAAA;AAEF,mFAAmF;AACnF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yGAoDlC,CAAA"}

package/dist/server/server/persistence/backup/errors.d.ts

@@ -0,0 +1,53 @@
+import { Schema } from "effect";
+declare const BackupInputError_base: Schema.Class<BackupInputError, Schema.TaggedStruct<"BackupInputError", {
+    readonly operation: Schema.String;
+    readonly reason: Schema.Literals<readonly ["already-exists", "invalid-path", "overlap", "target-raced"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Untrusted archive or destination input did not satisfy the local operation contract. */
+export declare class BackupInputError extends BackupInputError_base {
+}
+declare const BackupLimitError_base: Schema.Class<BackupLimitError, Schema.TaggedStruct<"BackupLimitError", {
+    readonly artifact: Schema.Literals<readonly ["blob", "database", "manifest"]>;
+    readonly maximumBytes: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/** An archive artifact exceeded a documented bounded-read limit. */
+export declare class BackupLimitError extends BackupLimitError_base {
+}
+declare const BackupStorageError_base: Schema.Class<BackupStorageError, Schema.TaggedStruct<"BackupStorageError", {
+    readonly cause: Schema.Defect;
+    readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A platform storage operation failed; callers retain its cause for redacted diagnostics. */
+export declare class BackupStorageError extends BackupStorageError_base {
+}
+declare const BackupSqlError_base: Schema.Class<BackupSqlError, Schema.TaggedStruct<"BackupSqlError", {
+    readonly cause: Schema.Defect;
+    readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A database snapshot or integrity operation failed with its diagnostic cause retained. */
+export declare class BackupSqlError extends BackupSqlError_base {
+}
+declare const BackupManifestError_base: Schema.Class<BackupManifestError, Schema.TaggedStruct<"BackupManifestError", {
+    readonly reason: Schema.Literals<readonly ["blob-count-mismatch", "blob-inventory-mismatch", "boundary-mismatch", "duplicate-blob", "malformed", "schema-mismatch", "unsorted-blob-inventory", "unsupported"]>;
+}>, import("effect/Cause").YieldableError>;
+/** The manifest is malformed, unsupported, or inconsistent with its snapshot. */
+export declare class BackupManifestError extends BackupManifestError_base {
+}
+declare const BackupIntegrityError_base: Schema.Class<BackupIntegrityError, Schema.TaggedStruct<"BackupIntegrityError", {
+    readonly digest: Schema.NullOr<Schema.brand<Schema.String, "BlobDigest">>;
+    readonly reason: Schema.Literals<readonly ["blob-corrupt", "blob-missing", "database-corrupt", "database-digest-mismatch", "foreign-key-violation", "owner-mode-invalid", "unexpected-artifact"]>;
+    readonly workspaceId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">>;
+}>, import("effect/Cause").YieldableError>;
+/** Authoritative database or blob evidence did not pass integrity verification. */
+export declare class BackupIntegrityError extends BackupIntegrityError_base {
+}
+declare const SchemaWriteBarrierError_base: Schema.Class<SchemaWriteBarrierError, Schema.TaggedStruct<"SchemaWriteBarrierError", {
+    readonly phase: Schema.Literals<readonly ["acquire", "verify"]>;
+}>, import("effect/Cause").YieldableError>;
+/** The scoped SQLite write barrier could not be acquired for schema initialization. */
+export declare class SchemaWriteBarrierError extends SchemaWriteBarrierError_base {
+}
+/** Typed failures exposed by backup, verification, and restore operations. */
+export type BackupFailure = BackupInputError | BackupIntegrityError | BackupLimitError | BackupManifestError | BackupSqlError | BackupStorageError;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/server/server/persistence/backup/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/backup/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;;;;;AAW/B,2FAA2F;AAC3F,qBAAa,gBAAiB,SAAQ,qBAGpC;CAAG;;;;;AAEL,oEAAoE;AACpE,qBAAa,gBAAiB,SAAQ,qBAGpC;CAAG;;;;;AAEL,8FAA8F;AAC9F,qBAAa,kBAAmB,SAAQ,uBAGtC;CAAG;;;;;AAEL,4FAA4F;AAC5F,qBAAa,cAAe,SAAQ,mBAGlC;CAAG;;;;AAEL,iFAAiF;AACjF,qBAAa,mBAAoB,SAAQ,wBAcxC;CAAG;;;;;;AAEJ,mFAAmF;AACnF,qBAAa,oBAAqB,SAAQ,yBAezC;CAAG;;;;AAEJ,uFAAuF;AACvF,qBAAa,uBAAwB,SAAQ,4BAG5C;CAAG;AAEJ,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GACrB,gBAAgB,GAChB,oBAAoB,GACpB,gBAAgB,GAChB,mBAAmB,GACnB,cAAc,GACd,kBAAkB,CAAA"}

package/dist/server/server/persistence/backup/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./BackupArchive.js";
+export * from "./BackupManifest.js";
+export * from "./errors.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/persistence/backup/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/backup/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AACnC,cAAc,aAAa,CAAA"}

package/dist/server/server/persistence/errors.d.ts

@@ -0,0 +1,99 @@
+import * as Schema from "effect/Schema";
+declare const PersistenceConfigError_base: Schema.Class<PersistenceConfigError, Schema.TaggedStruct<"PersistenceConfigError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when persistence configuration cannot be decoded safely. */
+export declare class PersistenceConfigError extends PersistenceConfigError_base {
+}
+declare const DatabaseInitializationError_base: Schema.Class<DatabaseInitializationError, Schema.TaggedStruct<"DatabaseInitializationError", {
+    readonly operation: Schema.Literals<readonly ["connect", "configure", "initialize-schema", "verify-pragmas", "verify-schema"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when a database startup operation fails. */
+export declare class DatabaseInitializationError extends DatabaseInitializationError_base {
+}
+declare const RecordNotFoundError_base: Schema.Class<RecordNotFoundError, Schema.TaggedStruct<"RecordNotFoundError", {
+    readonly recordKey: Schema.String;
+    readonly recordKind: Schema.String;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when a workspace-scoped persisted record does not exist. */
+export declare class RecordNotFoundError extends RecordNotFoundError_base {
+}
+declare const RecordAlreadyExistsError_base: Schema.Class<RecordAlreadyExistsError, Schema.TaggedStruct<"RecordAlreadyExistsError", {
+    readonly recordKey: Schema.String;
+    readonly recordKind: Schema.String;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when creating a record would replace an existing workspace-scoped identity. */
+export declare class RecordAlreadyExistsError extends RecordAlreadyExistsError_base {
+}
+declare const PluginConnectionLimitError_base: Schema.Class<PluginConnectionLimitError, Schema.TaggedStruct<"PluginConnectionLimitError", {
+    readonly maximum: Schema.Number;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when a workspace has reached its bounded plugin-connection capacity. */
+export declare class PluginConnectionLimitError extends PluginConnectionLimitError_base {
+}
+declare const SourceIdentityMismatchError_base: Schema.Class<SourceIdentityMismatchError, Schema.TaggedStruct<"SourceIdentityMismatchError", {
+    readonly recordKey: Schema.String;
+    readonly recordKind: Schema.String;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when an entity update attempts to replace its immutable vendor identity. */
+export declare class SourceIdentityMismatchError extends SourceIdentityMismatchError_base {
+}
+declare const PersistenceOperationError_base: Schema.Class<PersistenceOperationError, Schema.TaggedStruct<"PersistenceOperationError", {
+    readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Stable boundary error for a failed persistence operation. */
+export declare class PersistenceOperationError extends PersistenceOperationError_base {
+}
+declare const ContentMetadataMismatchError_base: Schema.Class<ContentMetadataMismatchError, Schema.TaggedStruct<"ContentMetadataMismatchError", {
+    readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when identical content bytes are registered with conflicting durable metadata. */
+export declare class ContentMetadataMismatchError extends ContentMetadataMismatchError_base {
+}
+declare const ReproducibleContentUnavailableError_base: Schema.Class<ReproducibleContentUnavailableError, Schema.TaggedStruct<"ReproducibleContentUnavailableError", {
+    readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly reason: Schema.Literals<readonly ["corrupt", "missing"]>;
+    readonly recovery: Schema.Literal<"refetch">;
+}>, import("effect/Cause").YieldableError>;
+/** Reproducible bytes are unavailable and the owning adapter may safely refetch them. */
+export declare class ReproducibleContentUnavailableError extends ReproducibleContentUnavailableError_base {
+}
+declare const RevisionConflictError_base: Schema.Class<RevisionConflictError, Schema.TaggedStruct<"RevisionConflictError", {
+    readonly actualRevision: Schema.Union<readonly [Schema.Number, Schema.Null]>;
+    readonly expectedRevision: Schema.Number;
+    readonly recordKey: Schema.String;
+    readonly recordKind: Schema.String;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when a compare-and-swap update observes a different persisted revision. */
+export declare class RevisionConflictError extends RevisionConflictError_base {
+}
+declare const SecretReferenceScopeConflictError_base: Schema.Class<SecretReferenceScopeConflictError, Schema.TaggedStruct<"SecretReferenceScopeConflictError", {}>, import("effect/Cause").YieldableError>;
+/** Raised when an opaque secret reference is reused outside its durable first-use scope. */
+export declare class SecretReferenceScopeConflictError extends SecretReferenceScopeConflictError_base {
+}
+declare const PersistedRecordError_base: Schema.Class<PersistedRecordError, Schema.TaggedStruct<"PersistedRecordError", {
+    readonly diagnosticCode: Schema.String;
+    readonly recordKey: Schema.String;
+    readonly recordKind: Schema.String;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when a persisted record cannot be decoded into its trusted domain model. */
+export declare class PersistedRecordError extends PersistedRecordError_base {
+}
+declare const QuarantineWriteError_base: Schema.Class<QuarantineWriteError, Schema.TaggedStruct<"QuarantineWriteError", {
+    readonly recordKey: Schema.String;
+    readonly recordKind: Schema.String;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when a bounded quarantine diagnostic cannot be persisted. */
+export declare class QuarantineWriteError extends QuarantineWriteError_base {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/server/server/persistence/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/server/persistence/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;;;;AAkBvC,sEAAsE;AACtE,qBAAa,sBAAuB,SAAQ,2BAK3C;CAAG;;;;AAEJ,sDAAsD;AACtD,qBAAa,2BAA4B,SAAQ,gCAWhD;CAAG;;;;;;AAEJ,sEAAsE;AACtE,qBAAa,mBAAoB,SAAQ,wBAOxC;CAAG;;;;;;AAEJ,yFAAyF;AACzF,qBAAa,wBAAyB,SAAQ,6BAO7C;CAAG;;;;;AAEJ,kFAAkF;AAClF,qBAAa,0BAA2B,SAAQ,+BAM/C;CAAG;;;;;;AAEJ,sFAAsF;AACtF,qBAAa,2BAA4B,SAAQ,gCAOhD;CAAG;;;;AAEJ,gEAAgE;AAChE,qBAAa,yBAA0B,SAAQ,8BAS9C;CAAG;;;;;AAEJ,4FAA4F;AAC5F,qBAAa,4BAA6B,SAAQ,iCAMjD;CAAG;;;;;;;AAEJ,yFAAyF;AACzF,qBAAa,mCAAoC,SAAQ,wCAUxD;CAAG;;;;;;;;AAEJ,qFAAqF;AACrF,qBAAa,qBAAsB,SAAQ,0BAS1C;CAAG;;AAEJ,4FAA4F;AAC5F,qBAAa,iCAAkC,SAAQ,sCAGtD;CAAG;;;;;;;AAEJ,sFAAsF;AACtF,qBAAa,oBAAqB,SAAQ,yBAYzC;CAAG;;;;;;AAEJ,uEAAuE;AACvE,qBAAa,oBAAqB,SAAQ,yBAOzC;CAAG"}

package/dist/server/server/persistence/governedActionReconciliationLocator.d.ts

@@ -0,0 +1,14 @@
+import * as Schema from "effect/Schema";
+import { PluginActionReconciliationKey } from "../../domain/plugins/actions.js";
+/**
+ * SQL-only encoding for reconciliation by the action's immutable idempotency identity.
+ * Leading whitespace makes this value impossible to decode as a provider reconciliation key.
+ */
+export declare const PERSISTED_IDEMPOTENCY_RECONCILIATION_LOCATOR = " @knpkv/idempotency-reconciliation/v1";
+/** Provider locator or the private idempotency encoding stored in command projection columns. */
+export declare const PersistedGovernedActionReconciliationLocator: Schema.Union<readonly [Schema.brand<Schema.String, string>, Schema.Literal<" @knpkv/idempotency-reconciliation/v1">]>;
+/** Decoded SQL-only reconciliation locator. */
+export type PersistedGovernedActionReconciliationLocator = typeof PersistedGovernedActionReconciliationLocator.Type;
+/** Encode the domain's explicit null convention without weakening legacy SQL checks. */
+export declare const encodePersistedGovernedActionReconciliationLocator: (reconciliationKey: typeof PluginActionReconciliationKey.Type | null) => PersistedGovernedActionReconciliationLocator;
+//# sourceMappingURL=governedActionReconciliationLocator.d.ts.map

package/dist/server/server/persistence/governedActionReconciliationLocator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governedActionReconciliationLocator.d.ts","sourceRoot":"","sources":["../../../../src/server/persistence/governedActionReconciliationLocator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAA;AAE/E;;;GAGG;AACH,eAAO,MAAM,4CAA4C,0CAA0C,CAAA;AAEnG,iGAAiG;AACjG,eAAO,MAAM,4CAA4C,uHAGvD,CAAA;AAEF,+CAA+C;AAC/C,MAAM,MAAM,4CAA4C,GAAG,OAAO,4CAA4C,CAAC,IAAI,CAAA;AAEnH,wFAAwF;AACxF,eAAO,MAAM,kDAAkD,GAC7D,mBAAmB,OAAO,6BAA6B,CAAC,IAAI,GAAG,IAAI,KAClE,4CAAiH,CAAA"}

package/dist/server/server/persistence/index.d.ts

@@ -0,0 +1,11 @@
+/** Durable server-only Control Center state. */
+export * from "./backup/index.js";
+export type { PutContentInput, PutContentResult } from "./ContentStore.js";
+export * from "./errors.js";
+export { BlobContainmentError, BlobIntegrityError, BlobNotFoundError, type BlobStoreError, BlobStoreInputError, BlobStoreIoError, BlobTooLargeError, BlobUnexpectedEofError } from "./object-store/BlobStoreError.js";
+export type { BlobRange, BlobRangeRead, BlobReadStream, BlobVerification } from "./object-store/BlobStoreTypes.js";
+export { Persistence, persistenceLayer, type PersistenceLayerError, type PersistenceOperationFailure, type PersistenceService } from "./Persistence.js";
+export * from "./PersistenceConfig.js";
+export * from "./repositories/agentJobModels.js";
+export * from "./repositories/models.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/persistence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/persistence/index.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,cAAc,mBAAmB,CAAA;AACjC,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAC1E,cAAc,aAAa,CAAA;AAC3B,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,KAAK,cAAc,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,sBAAsB,EACvB,MAAM,kCAAkC,CAAA;AACzC,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAClH,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,kBAAkB,EACxB,MAAM,kBAAkB,CAAA;AACzB,cAAc,wBAAwB,CAAA;AACtC,cAAc,kCAAkC,CAAA;AAChD,cAAc,0BAA0B,CAAA"}

package/dist/server/server/persistence/object-store/BlobDigest.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from "effect";
+/** Exact lowercase hexadecimal encoding of a SHA-256 digest. */
+export declare const BlobDigest: Schema.brand<Schema.String, "BlobDigest">;
+/** Decoded content digest. */
+export type BlobDigest = typeof BlobDigest.Type;
+//# sourceMappingURL=BlobDigest.d.ts.map

package/dist/server/server/persistence/object-store/BlobDigest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlobDigest.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/object-store/BlobDigest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAI/B,gEAAgE;AAChE,eAAO,MAAM,UAAU,2CAIW,CAAA;AAElC,8BAA8B;AAC9B,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA"}

package/dist/server/server/persistence/object-store/BlobPath.d.ts

@@ -0,0 +1,12 @@
+import type { Path } from "effect";
+import type { WorkspaceId } from "../../../domain/identifiers.js";
+import type { BlobDigest } from "./BlobDigest.js";
+/** Derived path shape. It is kept inside the server persistence boundary. */
+export interface BlobPath {
+    readonly workspaceDirectory: string;
+    readonly objectDirectory: string;
+    readonly file: string;
+}
+/** Derives the partitioned object path from already-decoded identity values. */
+export declare const blobPath: (path: Path.Path, canonicalRoot: string, workspaceId: WorkspaceId, digest: BlobDigest) => BlobPath;
+//# sourceMappingURL=BlobPath.d.ts.map

package/dist/server/server/persistence/object-store/BlobPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlobPath.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/object-store/BlobPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,6EAA6E;AAC7E,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAA;IACnC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,gFAAgF;AAChF,eAAO,MAAM,QAAQ,GACnB,MAAM,IAAI,CAAC,IAAI,EACf,eAAe,MAAM,EACrB,aAAa,WAAW,EACxB,QAAQ,UAAU,KACjB,QAcF,CAAA"}

package/dist/server/server/persistence/object-store/BlobPublisher.d.ts

@@ -0,0 +1,8 @@
+import type { Crypto, FileSystem, Path } from "effect";
+import { Effect, Result } from "effect";
+import { type BlobStoreError } from "./BlobStoreError.js";
+import type { PinnedDirectory } from "./PinnedDirectory.js";
+export declare const BLOB_FILE_MODE = 384;
+/** Builds crash-safe exclusive publication around captured platform services. */
+export declare const makeBlobPublisher: (fs: FileSystem.FileSystem, path: Path.Path, cryptoService: Crypto.Crypto) => (directory: PinnedDirectory, destinationName: string, bytes: Uint8Array<ArrayBufferLike>, mode?: "replace" | "exclusive" | undefined, commit?: ((destination: string) => Effect.Effect<void, BlobStoreError>) | undefined) => Effect.Effect<Result.Result<void, import("effect/PlatformError").PlatformError>, BlobStoreError, never>;
+//# sourceMappingURL=BlobPublisher.d.ts.map

package/dist/server/server/persistence/object-store/BlobPublisher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlobPublisher.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/object-store/BlobPublisher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEvC,OAAO,EAAE,KAAK,cAAc,EAAoB,MAAM,qBAAqB,CAAA;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAE3D,eAAO,MAAM,cAAc,MAAQ,CAAA;AAanC,iFAAiF;AACjF,eAAO,MAAM,iBAAiB,GAC5B,IAAI,UAAU,CAAC,UAAU,EACzB,MAAM,IAAI,CAAC,IAAI,EACf,eAAe,MAAM,CAAC,MAAM,mKAeF,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,yHA0CzE,CAAA"}

package/dist/server/server/persistence/object-store/BlobRef.d.ts

@@ -0,0 +1,16 @@
+import { Schema } from "effect";
+/** Whether bytes are authoritative evidence or a safely regenerable cache. */
+export declare const BlobClassification: Schema.Literals<readonly ["durable", "reproducible-cache"]>;
+/** Decoded blob durability classification. */
+export type BlobClassification = typeof BlobClassification.Type;
+declare const BlobRef_base: Schema.Class<BlobRef, Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+    readonly sizeBytes: Schema.Number;
+    readonly classification: Schema.Literals<readonly ["durable", "reproducible-cache"]>;
+}>, {}>;
+/** Workspace-scoped reference persisted by repository metadata. */
+export declare class BlobRef extends BlobRef_base {
+}
+export {};
+//# sourceMappingURL=BlobRef.d.ts.map

package/dist/server/server/persistence/object-store/BlobRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlobRef.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/object-store/BlobRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAK/B,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB,6DAAqD,CAAA;AAEpF,8CAA8C;AAC9C,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAA;;;;;;;AAE/D,mEAAmE;AACnE,qBAAa,OAAQ,SAAQ,YAK3B;CAAG"}