@voltro/data-transfer 0.49.0 → 0.50.0

package/CHANGELOG.md

@@ -39,6 +39,64 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.50.0] — 2026-08-23
+
+### ⚠ BREAKING
+
+- **@voltro/cli** — The read-only run-history endpoint moved:
+
+  GET /_voltro/admin/imports → GET /_voltro/admin/transfers
+
+  Same secret, same query parameters, same response shape. Only the path changed.
+
+  It answers for four directions now — import, export, native backup, native restore — and it named one of them. The subcommand and the table were renamed for exactly that reason in 0.49.0 and this path was left behind, which is worse than renaming none of them: a reader who follows a rename tries the matching path, gets a 404, and concludes the instance is too old.
+
+  `voltro data transfers --target api` uses the new path for you. What needs a hand is anything calling it directly — a monitoring check, an uptime probe, a curl in a runbook, a dashboard datasource. The codemod is `manual` and declares `reach: 'beyond-source'`, so it prints whether or not the path is found in your repository.
+- **@voltro/database, @voltro/voltro** — `InterruptedReplace.tables` is `number | null`, and the interface gains `kind?: 'replace' | 'restore'`.
+
+  `_voltro_replace_in_progress` records two destructive operations now — an import's `--mode replace` and a native `voltro data restore`. A restore replaces the whole database from an artefact, so "how many tables was this going to empty and refill" has no answer: not known up front, not meaningful after.
+
+  Writing `0` would have preserved the type and been worse. That number is rendered into the boot refusal, which is read under pressure, and it would have said `began emptying 0 table(s)` — a measurement that was never taken. The framework's own text says "this database" instead; `Number(null)` is `0`, so coercing it reintroduces exactly the sentence being avoided.
+
+  `DataTransferRun.direction` also widens to name `'backup'` and `'restore'` explicitly. That one is documentary — the union already ended in `| string`, so no assignability changes.
+
+  **`voltro update` carries you across this** — codemod `0.50.0/03_interrupted-replace-tables-nullable`.
+
+### Added
+
+- **@voltro/cli, @voltro/data-transfer, @voltro/database** — `voltro data backup --assets` and `voltro data restore --assets` now move the stored blobs alongside the vendor dump, through the same content-addressed phase the logical `export` / `import` path uses — streamed, deduped by sha256, verified on the way back, resumable per key.
+
+  `--assets` was accepted by `backup` and silently ignored, with the only signal a field in the closing JSON reading `NOT included`; `restore` did not accept it at all. A rows-only backup restores a database whose rows reference objects nothing puts back, and the reference and the object are checked at different times, so that state is discovered by a user rather than by the restore.
+
+  Three refusals, each for a belief that is otherwise acted on silently: `backup --assets` with no storage provider is refused rather than swallowed; `restore --assets` on a rows-only artefact is refused; a restore WITHOUT `--assets` over an artefact that has them warns and proceeds, because restoring rows without blobs is legitimate and refusing it would push people at `--force`.
+
+  The dump itself still has no resume — a vendor artefact is one opaque file with no offset to restart from, and the logical path is what exists for that.
+- **@voltro/cli, @voltro/database, @voltro/data-transfer** — A native `backup` / `restore` now writes to the same `_voltro_data_transfers` record `import` and `export` use, so `voltro data transfers` answers "did last night's backup finish" from the instance that ran it. A native run reports blobs rather than rows — a vendor tool reports no row count we can trust, and printing `0 row(s)` over a dump that worked would be a wrong measurement.
+
+  `restore` also writes the `_voltro_replace_in_progress` marker before its first destructive statement and clears it after the last write, blobs included, so a killed restore refuses the next boot instead of serving a half-loaded database. `--allow-live` guards from the wrong side — it asks you not to — and this guards from the right one. The marker carries a `kind` so the refusal can say something different for a `replace` (re-import the capture) and a `restore` (finish the restore), and `tables` is nullable because a native restore has no table count to claim.
+
+  The sqlite / turso restore is atomic now (temp file + rename): its marker lives in the very file being replaced, so a plain in-place copy would leave a truncated database with nothing left to catch it.
+
+  A target with no `_voltro_data_transfers` table still gets its backup; the closing line says it was not recorded rather than implying it was.
+- **@voltro/cli** — A re-issued migration note for the `voltro data imports` → `voltro data transfers` rename that shipped in 0.49.0.
+
+  Codemods are selected by `from < version <= to`, so the 0.49.0 note fires once, on the jump that crosses 0.49.0, and cannot be corrected for anyone already past it. Its gate searched `.ts` / `.tsx` while the command it is about lives in shell scripts, CI job definitions and runbooks — so a project whose only occurrence sat in `.gitlab-ci.yml` crossed 0.49.0 and was told there was nothing to apply.
+
+  The re-issue is filed under 0.50.0, prints unconditionally, and says what to grep for. Redundant for anyone already fixed; the alternative is firing for nobody.
+
+### Fixed
+
+- **@voltro/cli** — A `manual` codemod's `appliesTo` can now search every text file the project owns — `.sh`, `.yml`, `.json`, `.md`, `Makefile`, the `.js` scripts — through a new `ctx.text` on the predicate context, and a codemod may declare `reach: 'beyond-source'` to print its note even when nothing matched.
+
+  Both halves close the same gap, and it was in the codemod most in need of a gate. A manual codemod exists BECAUSE its subject could not be transformed, which usually means it is not source at all — and `appliesTo` was reading the ts-morph project, which holds `.ts` / `.tsx` and nothing else. Measured with one identical CLI invocation in four files: the `.ts` one printed the note, the `.sh`, `.yml` and `.md` ones printed nothing, and the run reported `codemods: nothing to apply for this jump`. That is an acquittal from a check that never looked at the file, and an acquittal gets acted on.
+
+  `reach: 'beyond-source'` covers what no scan of one repository can reach — an inline script in a CI runner's own UI, a CronJob spec in another repo, a wiki runbook. The note prints either way; only its framing changes, and an uncertain one says plainly that we could not look there.
+- **@voltro/data-transfer** — When `mariadb-dump` is absent and the mysql-family fallback runs Oracle's `mysqldump` against a MariaDB server, the failure now names the way out.
+
+  The stderr it prints is the child's own words and is the right first thing to show — and on its own it is a dead end: `Unknown table 'COLUMN_STATISTICS' in information_schema (1109)` names a table nobody asked for, in a schema nobody wrote, about a feature nobody enabled. Everything needed to act on it was known where the fallback was DECIDED: which binary we wanted, which one we took, and why the difference matters. That travels with the step now and prints under the stderr, including the counter-move a reader reaches for on their own (`--column-statistics=0` does not exist on `mariadb-dump`, so it fixes the wrong client and breaks the right one).
+
+---
+
 ## [0.49.0] — 2026-08-23
 
 ### ⚠ BREAKING

package/dist/index.d.ts

@@ -76,6 +76,23 @@ export declare interface AssetInfo {
     readonly size: number;
 }
 
+/**
+ * The resume journal, as this phase needs it.
+ *
+ * Deliberately two functions rather than the `Ledger` type: the native path
+ * keeps its own sidecar and the logical path keeps the shared one, and neither
+ * has any business knowing the other's file layout. What both must agree on is
+ * the SEMANTICS — `done` is keyed by the asset KEY (not its hash), because an
+ * asset is skippable when the destination already has that key, and the hash is
+ * not known until the bytes have been read, which is the cost being avoided.
+ */
+export declare interface AssetProgress {
+    readonly done: (key: string) => boolean;
+    /** Record `key` as landed. Called AFTER the bytes are durable, never before —
+     *  a ledger written first turns a crash into silent data loss on resume. */
+    readonly mark: (key: string, entry: AssetEntry) => Effect.Effect<void, BundleError>;
+}
+
 export declare const ASSETS_DIR = "assets";
 
 /** Where import writes assets TO. */
@@ -149,6 +166,25 @@ export declare type CanonicalCategory = 'string' | 'integer' | 'float' | 'boolea
  *  types (a bundle from a newer framework) fall back to 'string' passthrough. */
 export declare const canonicalType: (type: string) => CanonicalCategory;
 
+/**
+ * Stream every asset the source enumerates into the content-addressed `assetsDir`.
+ *
+ * `assetsDir` must exist. Each asset is hashed while it streams (never buffered
+ * whole), written to a temp file and renamed to `assets/<sha256>` — so identical
+ * blobs dedupe, a concurrent reader never sees a half-written asset, and the
+ * hash IS the integrity check the restore verifies against.
+ */
+export declare const captureAssetsToCas: (opts: {
+    readonly source: AssetSource;
+    readonly assetsDir: string;
+    readonly progress?: AssetProgress;
+}) => Effect.Effect<CapturedAssets, BundleError>;
+
+export declare interface CapturedAssets {
+    readonly count: number;
+    readonly totalBytes: number;
+}
+
 /**
  * Lint a bundle's column types against a target dialect. Same-dialect import is
  * always clean (returns []). Otherwise returns every column whose type won't
@@ -1075,6 +1111,9 @@ export declare type NativeStep = {
     readonly env: Readonly<Record<string, string>>;
     readonly stdoutFile?: string;
     readonly stdinFile?: string;
+    /** Something known at BUILD time that the failure could not otherwise
+     *  say — e.g. that this tool is a fallback for one that was absent. */
+    readonly hint?: string;
 } | {
     readonly kind: 'copy';
     readonly from: string;
@@ -1089,6 +1128,19 @@ export declare class NativeToolError extends NativeToolError_base<{
     readonly tool: string;
     readonly reason: string;
     readonly stderr?: string;
+    /**
+     * What the CALLER knew and the child could not say.
+     *
+     * The stderr above is the tool's own words, which is the right first answer
+     * and is sometimes a dead end on its own: `Unknown table 'COLUMN_STATISTICS'
+     * in information_schema (1109)` names a table nobody asked for, in a schema
+     * nobody wrote. The fact that turns it into an action — that we wanted
+     * `mariadb-dump`, could not find it, and took Oracle's `mysqldump` instead —
+     * is known where the step is BUILT and nowhere else. So it travels with the
+     * step (`NativeStep.hint`) and is printed under the child's words, never
+     * instead of them.
+     */
+    readonly hint?: string;
 }> {
     /**
      * The child's own words, not ours.
@@ -1117,6 +1169,11 @@ declare const NativeToolError_base: new <A extends Record<string, any> = {}>(arg
  *  rather than a bare SyntaxError. */
 export declare const ndjsonToRows: <E, R>(bytes: Stream.Stream<Uint8Array, E, R>, table: string, columnTypes: ColumnTypes) => Stream.Stream<Row, E | CodecError, R>;
 
+/** A progress journal that remembers nothing — every asset is transferred. Used
+ *  where there is no sidecar to keep, and named so a caller passing it is
+ *  saying "no resume" rather than passing `undefined` and hoping. */
+export declare const noAssetProgress: AssetProgress;
+
 export declare type OnConflict = 'skip' | 'fail';
 
 /** The caller's progress sink. Plain sync fn — never fails the job. */
@@ -1232,6 +1289,9 @@ export declare interface ProgressEvent {
 /** Which pipeline the event belongs to. */
 export declare type ProgressPhase = 'export' | 'import';
 
+/** Read a CAS index file (NDJSON, one {@link AssetEntry} per line) as a stream. */
+export declare const readAssetIndex: (indexPath: string) => Stream.Stream<AssetEntry, BundleError>;
+
 /** Read the ledger at `path`, or an empty one when it is absent / unreadable
  *  (a missing ledger just means "nothing done yet" — never a hard failure). */
 export declare const readLedger: (path: string) => Effect.Effect<Ledger>;
@@ -1270,6 +1330,20 @@ export declare const restoreAssetFromCas: (sink: AssetSink, assetsDir: string, e
     readonly contentType: string;
 }) => Effect.Effect<void, BundleError | IntegrityError | StorageError>;
 
+/**
+ * Push every asset named in the index back to the sink, re-hashing on the way.
+ *
+ * A hash mismatch is an {@link IntegrityError} and stops the phase — a corrupted
+ * artefact must never silently re-upload bad bytes over good ones, which is the
+ * one failure a restore has no way to notice afterwards.
+ */
+export declare const restoreAssetsFromCas: (opts: {
+    readonly sink: AssetSink;
+    readonly assetsDir: string;
+    readonly indexPath: string;
+    readonly progress?: AssetProgress;
+}) => Effect.Effect<number, BundleError | IntegrityError | StorageError>;
+
 /** Build the restore step for a dialect reading `inFile`. */
 export declare const restoreCommand: (dialect: string, conn: NativeConn, inFile: string) => NativeStep;