@voltro/data-transfer 0.83.1 → 0.85.0

package/dist/index.d.ts

@@ -20,11 +20,11 @@ import { YieldableError } from 'effect/Cause';
 export declare const applyAction: (action: MaskAction, input: MaskInput) => unknown;
 
 /**
- * The `ImportError` inside a value, or `undefined` — through a `FiberFailure` if
+ * The `ImportError` inside a value, or `undefined` — through a Cause if
  * that is what it arrived as.
  *
  * A rejection that came out of the Effect runtime does not expose its payload by
- * property access: `err._tag` reads `undefined` on a `FiberFailure` whose cause
+ * property access: `err._tag` reads `undefined` on a Cause whose failures
  * holds a perfectly good `RowsRefusedError`. Every consumer that branches on the
  * tag therefore silently takes the "not my error" path — which is exactly how a
  * refusal report that was wired, tested and correct printed nothing.
@@ -60,10 +60,10 @@ export declare const assetDone: (ledger: Ledger, sha256: string) => boolean;
 /** One content-addressed asset. `path` is `assets/<sha256>`; `key` is the
  *  original storage key so the importer restores it under the same key. */
 export declare const AssetEntry: Schema.Struct<{
-    key: typeof Schema.String;
-    sha256: typeof Schema.String;
-    size: typeof Schema.Number;
-    contentType: typeof Schema.String;
+    readonly key: Schema.String;
+    readonly sha256: Schema.String;
+    readonly size: Schema.Number;
+    readonly contentType: Schema.String;
 }>;
 
 export declare type AssetEntry = Schema.Schema.Type<typeof AssetEntry>;
@@ -114,11 +114,11 @@ export declare interface AssetSource {
 }
 
 export declare const AssetSummary: Schema.Struct<{
-    count: typeof Schema.Number;
-    totalBytes: typeof Schema.Number;
+    readonly count: Schema.Number;
+    readonly totalBytes: Schema.Number;
     /** Bundle-relative path of the asset index (`assets/index.ndjson`), when any
      *  assets were exported. Each line is an {@link AssetEntry}. */
-    index: Schema.optional<typeof Schema.String>;
+    readonly index: Schema.optional<Schema.String>;
 }>;
 
 export declare type AssetSummary = Schema.Schema.Type<typeof AssetSummary>;
@@ -150,14 +150,14 @@ export declare interface BlobSource {
 
 /** A bundle is malformed: bad manifest, unknown format version, missing file. */
 export declare class BundleError extends BundleError_base {
+    /** The text a log line or a run record shows for this refusal. */
+    get message(): string;
 }
 
-declare const BundleError_base: Schema.TaggedErrorClass<BundleError, "BundleError", {
-    readonly _tag: Schema.tag<"BundleError">;
-} & {
-    reason: typeof Schema.String;
-    path: Schema.optional<typeof Schema.String>;
-}>;
+declare const BundleError_base: Schema.Class<BundleError, Schema.TaggedStruct<"BundleError", {
+    readonly reason: Schema.String;
+    readonly path: Schema.optional<Schema.String>;
+}>, YieldableError>;
 
 /** The portable meaning of a DSL column type. */
 export declare type CanonicalCategory = 'string' | 'integer' | 'float' | 'boolean' | 'datetime' | 'date' | 'json' | 'binary' | 'reference' | 'vector' | 'enum' | 'array' | 'interval' | 'raw';
@@ -281,12 +281,10 @@ export declare const classifyImportDrift: (bundle: ReadonlyArray<DriftTable>, ta
 export declare class CodecError extends CodecError_base {
 }
 
-declare const CodecError_base: Schema.TaggedErrorClass<CodecError, "CodecError", {
-    readonly _tag: Schema.tag<"CodecError">;
-} & {
-    table: typeof Schema.String;
-    reason: typeof Schema.String;
-}>;
+declare const CodecError_base: Schema.Class<CodecError, Schema.TaggedStruct<"CodecError", {
+    readonly table: Schema.String;
+    readonly reason: Schema.String;
+}>, YieldableError>;
 
 export declare interface ColumnClassification {
     readonly sensitive?: {
@@ -337,13 +335,11 @@ export declare const computeSubsetIds: (store: DataStore, snapshot: SchemaSnapsh
 export declare class CrossDialectError extends CrossDialectError_base {
 }
 
-declare const CrossDialectError_base: Schema.TaggedErrorClass<CrossDialectError, "CrossDialectError", {
-    readonly _tag: Schema.tag<"CrossDialectError">;
-} & {
-    sourceDialect: typeof Schema.String;
-    targetDialect: typeof Schema.String;
-    blocking: Schema.Array$<typeof Schema.String>;
-}>;
+declare const CrossDialectError_base: Schema.Class<CrossDialectError, Schema.TaggedStruct<"CrossDialectError", {
+    readonly sourceDialect: Schema.String;
+    readonly targetDialect: Schema.String;
+    readonly blocking: Schema.$Array<Schema.String>;
+}>, YieldableError>;
 
 export declare const DATA_DIR = "data";
 
@@ -392,7 +388,7 @@ export declare const decideStaging: (input: {
     readonly canRunSql: boolean;
 }) => StagingDecision;
 
-export declare const decodeManifest: (u: unknown, overrideOptions?: ParseOptions) => {
+export declare const decodeManifest: (input: unknown, options?: ParseOptions) => {
     readonly createdAt: string;
     readonly source: {
         readonly dialect: string;
@@ -406,25 +402,25 @@ export declare const decodeManifest: (u: unknown, overrideOptions?: ParseOptions
     };
     readonly tables: readonly {
         readonly name: string;
-        readonly primaryKey: string;
         readonly file: string;
         readonly rowCount: number;
         readonly checksum: string;
         readonly columnTypes: {
             readonly [x: string]: string;
         };
+        readonly primaryKey: string;
     }[];
-    readonly formatVersion: number;
     readonly consistency: "live" | "snapshot";
     readonly compression: "zstd" | "gzip" | "none";
+    readonly formatVersion: number;
     readonly assets: {
-        readonly index?: string | undefined;
         readonly count: number;
         readonly totalBytes: number;
+        readonly index?: string | undefined;
     };
     readonly masking?: {
-        readonly policyId?: string | undefined;
         readonly transformed: readonly string[];
+        readonly policyId?: string | undefined;
     } | undefined;
 };
 
@@ -516,7 +512,7 @@ export declare const dumpExcludedTables: (dialect: string) => ReadonlyArray<stri
 
 export declare const emptyLedger: () => Ledger;
 
-export declare const encodeManifest: (a: {
+export declare const encodeManifest: (input: {
     readonly createdAt: string;
     readonly source: {
         readonly dialect: string;
@@ -530,27 +526,27 @@ export declare const encodeManifest: (a: {
     };
     readonly tables: readonly {
         readonly name: string;
-        readonly primaryKey: string;
         readonly file: string;
         readonly rowCount: number;
         readonly checksum: string;
         readonly columnTypes: {
             readonly [x: string]: string;
         };
+        readonly primaryKey: string;
     }[];
-    readonly formatVersion: number;
     readonly consistency: "live" | "snapshot";
     readonly compression: "zstd" | "gzip" | "none";
+    readonly formatVersion: number;
     readonly assets: {
-        readonly index?: string | undefined;
         readonly count: number;
         readonly totalBytes: number;
+        readonly index?: string | undefined;
     };
     readonly masking?: {
-        readonly policyId?: string | undefined;
         readonly transformed: readonly string[];
+        readonly policyId?: string | undefined;
     } | undefined;
-}, overrideOptions?: ParseOptions) => string;
+}, options?: ParseOptions) => string;
 
 /** Encode a whole row to a JSON-safe object. */
 export declare const encodeRow: (row: Row, columnTypes: ColumnTypes) => Record<string, unknown>;
@@ -705,9 +701,9 @@ export declare interface ExportOptions {
 /** Export scope — what was selected. `all` = every table; `tenant` = the rows
  *  of one tenant (+ its FK closure); `tables` = an explicit set. */
 export declare const ExportScope: Schema.Struct<{
-    kind: Schema.Literal<["all", "tenant", "tables"]>;
-    tenantId: Schema.optional<typeof Schema.String>;
-    tables: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    readonly kind: Schema.Literals<readonly ["all", "tenant", "tables"]>;
+    readonly tenantId: Schema.optional<Schema.String>;
+    readonly tables: Schema.optional<Schema.$Array<Schema.String>>;
     /**
      * Names deliberately left OUT of a `kind: 'all'` export.
      *
@@ -723,7 +719,7 @@ export declare const ExportScope: Schema.Struct<{
      * runs, and the manifest still says "everything, except these", which is a
      * different and truer claim than "these".
      */
-    exclude: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    readonly exclude: Schema.optional<Schema.$Array<Schema.String>>;
 }>;
 
 export declare type ExportScope = Schema.Schema.Type<typeof ExportScope>;
@@ -778,14 +774,14 @@ export declare type ImportMode = 'upsert' | 'append' | 'replace';
  *  bundle — e.g. `replace` (which truncates) against a PARTIAL bundle (a subset
  *  or tenant/table scope), which would delete rows the bundle never carried. */
 export declare class ImportModeError extends ImportModeError_base {
+    /** The text a log line or a run record shows for this refusal. */
+    get message(): string;
 }
 
-declare const ImportModeError_base: Schema.TaggedErrorClass<ImportModeError, "ImportModeError", {
-    readonly _tag: Schema.tag<"ImportModeError">;
-} & {
-    mode: typeof Schema.String;
-    reason: typeof Schema.String;
-}>;
+declare const ImportModeError_base: Schema.Class<ImportModeError, Schema.TaggedStruct<"ImportModeError", {
+    readonly mode: Schema.String;
+    readonly reason: Schema.String;
+}>, YieldableError>;
 
 export declare interface ImportOptions {
     /** Target store to write into. */
@@ -980,15 +976,15 @@ export declare interface ImportOutcome {
 /** An integrity check failed — a table's content checksum or row count did not
  *  match the manifest, or an asset's bytes did not hash to its recorded id. */
 export declare class IntegrityError extends IntegrityError_base {
+    /** The text a log line or a run record shows for this refusal. */
+    get message(): string;
 }
 
-declare const IntegrityError_base: Schema.TaggedErrorClass<IntegrityError, "IntegrityError", {
-    readonly _tag: Schema.tag<"IntegrityError">;
-} & {
-    what: typeof Schema.String;
-    expected: typeof Schema.String;
-    actual: typeof Schema.String;
-}>;
+declare const IntegrityError_base: Schema.Class<IntegrityError, Schema.TaggedStruct<"IntegrityError", {
+    readonly what: Schema.String;
+    readonly expected: Schema.String;
+    readonly actual: Schema.String;
+}>, YieldableError>;
 
 /** Is this table one whose rows are about the deployment rather than the app? */
 export declare const isEnvironmentLocal: (tableName: string) => boolean;
@@ -1047,17 +1043,17 @@ export declare const makeCompressor: (c: Compression) => Duplex;
 export declare const makeDecompressor: (c: Compression) => Duplex;
 
 export declare const Manifest: Schema.Struct<{
-    formatVersion: typeof Schema.Number;
+    readonly formatVersion: Schema.Number;
     /** ISO-8601 stamp of when the export started. */
-    createdAt: typeof Schema.String;
-    source: Schema.Struct<{
-        dialect: typeof Schema.String;
-        schemaFingerprint: typeof Schema.String;
+    readonly createdAt: Schema.String;
+    readonly source: Schema.Struct<{
+        readonly dialect: Schema.String;
+        readonly schemaFingerprint: Schema.String;
     }>;
-    scope: Schema.Struct<{
-        kind: Schema.Literal<["all", "tenant", "tables"]>;
-        tenantId: Schema.optional<typeof Schema.String>;
-        tables: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    readonly scope: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["all", "tenant", "tables"]>;
+        readonly tenantId: Schema.optional<Schema.String>;
+        readonly tables: Schema.optional<Schema.$Array<Schema.String>>;
         /**
          * Names deliberately left OUT of a `kind: 'all'` export.
          *
@@ -1073,35 +1069,35 @@ export declare const Manifest: Schema.Struct<{
          * runs, and the manifest still says "everything, except these", which is a
          * different and truer claim than "these".
          */
-        exclude: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        readonly exclude: Schema.optional<Schema.$Array<Schema.String>>;
     }>;
-    consistency: Schema.Literal<["live", "snapshot"]>;
-    compression: Schema.Literal<["zstd", "gzip", "none"]>;
-    tables: Schema.Array$<Schema.Struct<{
-        name: typeof Schema.String;
+    readonly consistency: Schema.Literals<readonly ["live", "snapshot"]>;
+    readonly compression: Schema.Literals<readonly ["zstd", "gzip", "none"]>;
+    readonly tables: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
         /** Bundle-relative path, e.g. `data/users.ndjson.zst`. */
-        file: typeof Schema.String;
-        rowCount: typeof Schema.Number;
+        readonly file: Schema.String;
+        readonly rowCount: Schema.Number;
         /** sha256 hex of the uncompressed NDJSON bytes. */
-        checksum: typeof Schema.String;
+        readonly checksum: Schema.String;
         /** column name → logical column type (the `ColumnType` union, as a string). */
-        columnTypes: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+        readonly columnTypes: Schema.$Record<Schema.String, Schema.String>;
         /** The unique column keyset-streamed on export (usually `id`). */
-        primaryKey: typeof Schema.String;
+        readonly primaryKey: Schema.String;
     }>>;
-    assets: Schema.Struct<{
-        count: typeof Schema.Number;
-        totalBytes: typeof Schema.Number;
+    readonly assets: Schema.Struct<{
+        readonly count: Schema.Number;
+        readonly totalBytes: Schema.Number;
         /** Bundle-relative path of the asset index (`assets/index.ndjson`), when any
          *  assets were exported. Each line is an {@link AssetEntry}. */
-        index: Schema.optional<typeof Schema.String>;
+        readonly index: Schema.optional<Schema.String>;
     }>;
     /** Masking audit — present when the export applied a masking policy. Lists
      *  every `table.column` that was transformed (not copied verbatim), so a
      *  reviewer can see exactly what was pseudonymised. */
-    masking: Schema.optional<Schema.Struct<{
-        policyId: Schema.optional<typeof Schema.String>;
-        transformed: Schema.Array$<typeof Schema.String>;
+    readonly masking: Schema.optional<Schema.Struct<{
+        readonly policyId: Schema.optional<Schema.String>;
+        readonly transformed: Schema.$Array<Schema.String>;
     }>>;
 }>;
 
@@ -1121,14 +1117,15 @@ export declare type MaskAction = 'keep' | 'null' | 'redact' | 'hash' | 'dateShif
  *  neither `.sensitive()` nor `.safe()` (fail-closed). Lists them so the author
  *  can classify each — a new column can never silently leak to a lower env. */
 export declare class MaskingError extends MaskingError_base {
+    /** The run record and the operator log carry this text; it names both lists
+     *  because they have different fixes. */
+    get message(): string;
 }
 
-declare const MaskingError_base: Schema.TaggedErrorClass<MaskingError, "MaskingError", {
-    readonly _tag: Schema.tag<"MaskingError">;
-} & {
+declare const MaskingError_base: Schema.Class<MaskingError, Schema.TaggedStruct<"MaskingError", {
     /** Columns that are neither `.sensitive()` nor `.safe()` nor covered by the
      *  policy — the fix is to classify them. */
-    unclassified: Schema.Array$<typeof Schema.String>;
+    readonly unclassified: Schema.$Array<Schema.String>;
     /**
      * Columns whose policy names an action this build cannot carry out — the fix
      * is to correct the policy. Kept separate from `unclassified` because a
@@ -1138,8 +1135,8 @@ declare const MaskingError_base: Schema.TaggedErrorClass<MaskingError, "MaskingE
      * Empty on every pre-existing failure, so a reader that only knows
      * `unclassified` is unaffected.
      */
-    invalidActions: Schema.optional<Schema.Array$<typeof Schema.String>>;
-}>;
+    readonly invalidActions: Schema.optional<Schema.$Array<Schema.String>>;
+}>, YieldableError>;
 
 export declare interface MaskingPlan {
     /** `table.column` → resolved action (excludes columns that resolve to error). */
@@ -1568,21 +1565,19 @@ declare interface RollbackCapture {
 export declare class RowsRefusedError extends RowsRefusedError_base {
 }
 
-declare const RowsRefusedError_base: Schema.TaggedErrorClass<RowsRefusedError, "RowsRefusedError", {
-    readonly _tag: Schema.tag<"RowsRefusedError">;
-} & {
+declare const RowsRefusedError_base: Schema.Class<RowsRefusedError, Schema.TaggedStruct<"RowsRefusedError", {
     /** The refused rows (capped — see {@link totalCount}), PRIMARY ones first. */
-    rows: Schema.Array$<Schema.Struct<{
-        table: typeof Schema.String;
-        id: typeof Schema.String;
-        reason: typeof Schema.String;
+    readonly rows: Schema.$Array<Schema.Struct<{
+        readonly table: Schema.String;
+        readonly id: Schema.String;
+        readonly reason: Schema.String;
         /** This row failed because another failed row was its parent. */
-        derived: typeof Schema.Boolean;
+        readonly derived: Schema.Boolean;
     }>>;
     /** Refused rows that are NOT a consequence of another refused row. */
-    primaryCount: typeof Schema.Number;
+    readonly primaryCount: Schema.Number;
     /** Total number of refused rows (may exceed `rows.length`). */
-    totalCount: typeof Schema.Number;
+    readonly totalCount: Schema.Number;
     /**
      * Every table that refused a row, with COMPLETE counts — not counts of the
      * capped `rows` list.
@@ -1595,14 +1590,14 @@ declare const RowsRefusedError_base: Schema.TaggedErrorClass<RowsRefusedError, "
      * worst-first and capped separately (a bundle can carry thousands of tables;
      * a hundred failing ones is already a different conversation).
      */
-    byTable: Schema.Array$<Schema.Struct<{
-        table: typeof Schema.String;
+    readonly byTable: Schema.$Array<Schema.Struct<{
+        readonly table: Schema.String;
         /** Rows of this table that were refused. */
-        refused: typeof Schema.Number;
+        readonly refused: Schema.Number;
         /** …of which are not a consequence of another refused row. */
-        primary: typeof Schema.Number;
+        readonly primary: Schema.Number;
     }>>;
-}>;
+}>, YieldableError>;
 
 /** Row stream → NDJSON byte stream (each row → typed-encoded JSON + `\n`). The
  *  source stream's error + requirement channels pass straight through. */
@@ -1643,31 +1638,31 @@ export declare const scanForLeaks: (rows: ReadonlyArray<Row>, table: string, act
  *  the observable schema differences (missing/extra tables, per-table column
  *  changes) so the operator can see exactly what moved. */
 export declare class SchemaDriftError extends SchemaDriftError_base {
+    /** The text a log line or a run record shows for this refusal. */
+    get message(): string;
 }
 
-declare const SchemaDriftError_base: Schema.TaggedErrorClass<SchemaDriftError, "SchemaDriftError", {
-    readonly _tag: Schema.tag<"SchemaDriftError">;
-} & {
+declare const SchemaDriftError_base: Schema.Class<SchemaDriftError, Schema.TaggedStruct<"SchemaDriftError", {
     /** The fingerprint stamped in the bundle manifest (the source schema). */
-    bundleFingerprint: typeof Schema.String;
+    readonly bundleFingerprint: Schema.String;
     /** The target app's current schema fingerprint. */
-    targetFingerprint: typeof Schema.String;
+    readonly targetFingerprint: Schema.String;
     /** Human-readable summary of the drift (capped), or a note that the shape
      *  differs but the specific diff was not enumerated. */
-    diff: Schema.Array$<typeof Schema.String>;
-}>;
+    readonly diff: Schema.$Array<Schema.String>;
+}>, YieldableError>;
 
 /** An export scope could not be resolved safely — e.g. `{ kind: 'tenant' }`
  *  without a `tenantId`. Fail-closed: a scoping ambiguity refuses the export
  *  instead of silently widening to more rows than the operator asked for. */
 export declare class ScopeError extends ScopeError_base {
+    /** The text a log line or a run record shows for this refusal. */
+    get message(): string;
 }
 
-declare const ScopeError_base: Schema.TaggedErrorClass<ScopeError, "ScopeError", {
-    readonly _tag: Schema.tag<"ScopeError">;
-} & {
-    reason: typeof Schema.String;
-}>;
+declare const ScopeError_base: Schema.Class<ScopeError, Schema.TaggedStruct<"ScopeError", {
+    readonly reason: Schema.String;
+}>, YieldableError>;
 
 /**
  * A store that can run raw SQL for us.
@@ -1831,16 +1826,16 @@ export declare const tableDone: (ledger: Ledger, name: string) => boolean;
  *  re-introspecting the source. `checksum` is the sha256 of the UNCOMPRESSED
  *  NDJSON payload — verified during import. */
 export declare const TableEntry: Schema.Struct<{
-    name: typeof Schema.String;
+    readonly name: Schema.String;
     /** Bundle-relative path, e.g. `data/users.ndjson.zst`. */
-    file: typeof Schema.String;
-    rowCount: typeof Schema.Number;
+    readonly file: Schema.String;
+    readonly rowCount: Schema.Number;
     /** sha256 hex of the uncompressed NDJSON bytes. */
-    checksum: typeof Schema.String;
+    readonly checksum: Schema.String;
     /** column name → logical column type (the `ColumnType` union, as a string). */
-    columnTypes: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    readonly columnTypes: Schema.$Record<Schema.String, Schema.String>;
     /** The unique column keyset-streamed on export (usually `id`). */
-    primaryKey: typeof Schema.String;
+    readonly primaryKey: Schema.String;
 }>;
 
 export declare type TableEntry = Schema.Schema.Type<typeof TableEntry>;