@substrat-run/kernel 0.148.0 → 0.150.0

package/dist/attachment-sweep.d.ts

@@ -0,0 +1,281 @@
+import type { ScopedSql, TenantBlobStore } from './scope-host.js';
+/**
+ * The orphan-byte sweep (#2314): delete attachment bytes that no `_substrat_attachments` row
+ * points at, written ONCE for both adapters.
+ *
+ * An attachment write puts the bytes first and the row second, so a crash between the two, a
+ * transport failure whose commit is unknown (#2311 keeps the bytes on doubt, K-54) and a PITR
+ * rewind past a row all leave an object nobody reads. The one thing this sweep must never do is
+ * delete bytes whose row committed, or whose row a restore can still bring back. Four guards
+ * hold that, each on its own:
+ *
+ * 1. **A tombstone is the linearization point.** The scope does not delete; it CONDEMNS. In one
+ *    scope transaction it records each candidate that has no row in `_substrat_attachment_condemned`,
+ *    and the attachment insert refuses a condemned id in ITS transaction
+ *    (`refuseCondemnedAttachment`). The scope serializes the two, so either the row commits first
+ *    and the condemnation sees it and skips the id, or the condemnation commits first and the row
+ *    is refused: the upload fails and nothing commits without its bytes. Only a condemned id's
+ *    object is ever deleted. No clock and no timing is involved, so a slow upload, a retried call
+ *    or a skewed clock cannot turn a committed row into a deleted object.
+ * 2. **An age floor.** Only an object whose id (a ULID minted just before its `put`) is older than
+ *    `graceMs` is a candidate, so an upload still in flight is never condemned in the first place
+ *    and therefore never refused. The floor is courtesy, guard 1 is safety.
+ * 3. **The restore fence.** A row a rewind or a dump restore took away can come back: PITR keeps
+ *    every state of the last 30 days. Every path that replaces a scope's state writes a fence
+ *    object into the tenant's blob store BEFORE it does (`fenceAttachmentSweep`), and the sweep
+ *    deletes nothing of that scope until the fence is `fenceMs` old. The fence lives in the blob
+ *    store, never in the scope, because the rewind it records would erase it there. It is read
+ *    before the pass and again after the condemnation, immediately before the first delete, so a
+ *    rewind that lands mid-pass stops the deletes. A fence that cannot be read is a fence.
+ * 4. **The serving copy only, and only while it is live.** The judgement is only as good as the
+ *    copy that makes it. A host refuses a scope that is not active, a store that holds nothing, a
+ *    copy a carry wiped or kept, a fork, and a scope not provisioned for the tenant. It also
+ *    refuses while another script's copy of the scope is unsettled in the copy ledger
+ *    (any state but `SETTLED_COPY_STATES`), because that copy may hold rows the serving one lacks. Which
+ *    deployment is asked is the driver's business: the platform asks the one serving the scope.
+ *
+ * The instant a pass judges age and the fence against is the HOST's clock, never a caller's
+ * (`OrphanSweepRequest` carries none), so no caller can step past guard 2 or guard 3.
+ *
+ * A dry run condemns nothing and deletes nothing: it reports what a pass would condemn, and the
+ * scope records that as its licence (#2350). A destructive pass needs one in force, and deletes only
+ * what it lists (`ATTACHMENT_SWEEP_LICENCE_DDL`).
+ */
+/** The tombstone table, shared by both adapters so the two cannot part company. */
+export declare const ATTACHMENT_CONDEMNED_DDL = "\n  CREATE TABLE IF NOT EXISTS _substrat_attachment_condemned (\n    -- The attachment id whose object the sweep deleted, or is about to. No row may ever be\n    -- inserted for it again: the insert path refuses it (#2314).\n    id TEXT PRIMARY KEY,\n    condemned_at TEXT NOT NULL\n  );\n";
+/** The refusal reason an upload meets when its id was condemned before its row could commit. */
+export declare const ATTACHMENT_CONDEMNED = "attachment_condemned";
+/** How old an object must be before a pass looks at it, by default: seven days. */
+export declare const ORPHAN_SWEEP_GRACE_MS: number;
+/**
+ * How long a scope's bytes are left alone after its state was replaced, by default: 35 days. A
+ * Durable Object keeps 30 days of point-in-time history, so a row a rewind took away can be
+ * restored for that long; five more days absorb the clocks and the time a rewind takes to arm.
+ */
+export declare const ORPHAN_SWEEP_FENCE_MS: number;
+/** The most objects one pass deletes, by default. */
+export declare const ORPHAN_SWEEP_LIMIT = 500;
+/** The most ids one condemnation call carries: one JSON parameter, so no SQL limit applies. */
+export declare const ORPHAN_CONDEMN_BATCH = 100;
+/**
+ * How long a tombstone is kept. Past this no upload that minted the id can still be in flight
+ * (an upload holds its body in memory, and its call to the scope is one request), so the
+ * tombstone guards nothing any more.
+ */
+export declare const ORPHAN_TOMBSTONE_RETENTION_MS: number;
+/**
+ * Refuse an insert of a condemned attachment id. Called by both adapters inside the
+ * attachment write's own transaction, before its `INSERT`, so it and the condemnation are
+ * serialized by the scope (guard 1). A `conflict` is a refusal the scope ANSWERS, so the host
+ * compensates the object away (it is already gone, or about to be) and the caller is told.
+ */
+export declare function refuseCondemnedAttachment(sql: ScopedSql, attachmentId: string): void;
+/**
+ * Refuse a dump load that would put back a row for an id this store has condemned (#2314). A
+ * load is the other way an `_substrat_attachments` row is written, so it meets the same
+ * tombstone the insert does: a restore that raced a pass must not land a row whose bytes that
+ * pass is deleting. Called inside the load's transaction, BEFORE its first drop, against the
+ * store as it is. A store with no tombstone table (from before #2314) has condemned nothing.
+ */
+export declare function refuseCondemnedInDump(sql: ScopedSql, tables: readonly {
+    name: string;
+    columns: readonly string[];
+    rows: readonly (readonly unknown[])[];
+}[]): void;
+/** The ids in `ids` that no `_substrat_attachments` row names. Read-only. */
+export declare function rowlessAttachmentIds(sql: ScopedSql, ids: readonly string[]): string[];
+/**
+ * Condemn the ids in `ids` that no row names, inside the caller's scope transaction (guard 1),
+ * and return every id that is condemned and rowless now: the ones condemned here and the ones an
+ * earlier pass condemned but did not get to delete. Only those may be deleted. Idempotent.
+ *
+ * Each returned id's tombstone is stamped `now`, re-stamped if an earlier pass condemned it, so
+ * the prune of tombstones past `ORPHAN_TOMBSTONE_RETENTION_MS` that follows can never take the
+ * tombstone of an id this pass is about to delete.
+ */
+export declare function condemnOrphanAttachments(sql: ScopedSql, ids: readonly string[], now: string): string[];
+/**
+ * The dry-run-first licence (#2350), held by the scope's own storage so the rule holds whoever asks
+ * for a pass: one row per attachment id the scope's last dry run listed, stamped with the host's
+ * clock at that run. A destructive pass is refused without one in force
+ * (`refuseUnlicensedOrphanSweep`), condemns only ids it lists (`condemnLicensedOrphanAttachments`),
+ * and takes each id it deleted out of it (`consumeOrphanSweepLicence`).
+ *
+ * It only ever NARROWS what a pass may delete: every guard of the pass still runs on the ids it
+ * lists. So a licence that a rewind brought back, or that outlived the rows it was judged against,
+ * can permit nothing the pass would not permit without it. A dump never carries its rows and every
+ * load drops them, so a restore, a carry or a fork leaves the next pass a dry run.
+ */
+export declare const ATTACHMENT_SWEEP_LICENCE_DDL = "\n  CREATE TABLE IF NOT EXISTS _substrat_attachment_sweep_licence (\n    -- An attachment id the scope's last orphan-sweep dry run listed, and that no destructive\n    -- pass has deleted since (#2350). Store-local: never dumped, and cleared by every load.\n    id TEXT PRIMARY KEY,\n    licensed_at TEXT NOT NULL\n  );\n";
+/** The licence table's name, for the dump export that leaves its rows out and the load that drops them. */
+export declare const ATTACHMENT_SWEEP_LICENCE_TABLE = "_substrat_attachment_sweep_licence";
+/** The refusal reason a destructive pass meets when the scope holds no dry-run licence in force. */
+export declare const ORPHAN_SWEEP_UNLICENSED = "orphan_sweep_unlicensed";
+/** How long a scope's dry-run licence stays in force, judged against the host's clock: seven days. */
+export declare const ORPHAN_SWEEP_DRY_RUN_WINDOW_MS: number;
+/** The most ids one licence holds. A dry run that lists more licenses its first this many. */
+export declare const ORPHAN_SWEEP_LICENCE_CAP = 1000;
+/**
+ * When the scope's licence was recorded, if it holds one in force at `now`, else null. A licence
+ * stamped more than a minute later than `now` (a clock that went back) is not in force: the next
+ * pass is a dry run.
+ */
+export declare function orphanSweepLicensedAt(sql: ScopedSql, now: string): string | null;
+/** Refuse a destructive pass over a scope that holds no dry-run licence in force at `now`. */
+export declare function refuseUnlicensedOrphanSweep(sql: ScopedSql, now: string): void;
+/**
+ * Record what a dry run found as the scope's licence, inside the caller's scope transaction: the
+ * first `ORPHAN_SWEEP_LICENCE_CAP` of `ids`, stamped `now`. Writes only when that set differs from
+ * the one held, or the one held is older than half the window, so a dry run that keeps finding the
+ * same orphans moves no write revision (a carry and a kept-copy release are fenced on it). An empty
+ * set clears a held licence, and writes nothing when there is none. Returns whether it wrote.
+ */
+export declare function recordOrphanSweepLicence(sql: ScopedSql, ids: readonly string[], now: string): boolean;
+/**
+ * `condemnOrphanAttachments` over only the ids in `ids` the scope's licence lists, while it is in
+ * force at `now`: a destructive pass deletes nothing its dry run did not list. Inside the caller's
+ * scope transaction, so a load that dropped the licence meanwhile leaves nothing to condemn.
+ */
+export declare function condemnLicensedOrphanAttachments(sql: ScopedSql, ids: readonly string[], now: string): string[];
+/** The ids the scope's licence lists, held or expired: at most `ORPHAN_SWEEP_LICENCE_CAP`. */
+export declare function licensedOrphanIds(sql: ScopedSql): string[];
+/**
+ * Take ids out of the licence: the ones a destructive pass deleted, and the ones whose objects are
+ * gone some other way, so its next pass in the window goes on with the ids it has not reached and
+ * never back to what is gone. A licence left with nothing is no licence, so the next destructive
+ * pass is refused and the scope is dry-run again. Writes only when one of `ids` is held.
+ */
+export declare function consumeOrphanSweepLicence(sql: ScopedSql, ids: readonly string[]): void;
+/** Drop the whole licence: every dump load does, so a restored, carried or forked store starts with none. */
+export declare function clearOrphanSweepLicence(sql: ScopedSql): void;
+/**
+ * The copy-ledger states (#1722) in which another script's copy of a scope can no longer hold a
+ * row the serving copy lacks, nor discover one. An ALLOWLIST: every other state, a future one
+ * included, holds the pass. Only `done` qualifies: the copy was wiped (or found already wiped),
+ * reaped with its scope, or is the move's destination, the copy that serves. Every other state can
+ * still hold, or still turn up, a write the serving copy never saw:
+ *
+ * - `pending`: a move in flight; its outcome is not known yet.
+ * - `eligible`: a carry's source awaiting its fenced wipe. The wipe is what discovers a write that
+ *   landed after the export and turns the copy `kept`, and it is best effort, so until it has run
+ *   the copy may hold an upload whose bytes share this scope's prefix.
+ * - `kept`: such a write was found; staff resolve it.
+ * - `retained`: a copy kept on purpose (a bind that did not land, a copy from before the ledger),
+ *   whose contents nobody checked against the serving copy.
+ */
+export declare const SETTLED_COPY_STATES: readonly string[];
+/** The refusal of a pass over a scope with a copy not yet settled, or null when there is none. */
+export declare function unsettledCopyRefusal(scopeId: string, copies: readonly {
+    state: string;
+    scriptRef: string;
+}[]): Error | null;
+/**
+ * What a pass throws when the deployment holds no attachment store for the tenant, yet the scope
+ * holds attachment rows (#2314): its store binding is missing, which is a failure to fix, never the
+ * `bucket: 'none'` of a scope that keeps no files.
+ */
+export declare function missingAttachmentStore(tenantId: string, scopeId: string): Error;
+/** The blob key of a scope's restore fence (guard 3). Outside `att/`, so no pass ever lists it. */
+export declare function attachmentSweepFenceKey(scopeId: string): string;
+/**
+ * Record that a scope's state is about to be replaced (a PITR rewind, a dump restore), so no pass
+ * deletes its bytes for `ORPHAN_SWEEP_FENCE_MS`. Call it BEFORE the replacement and let a throw
+ * refuse the replacement: a rewind whose fence was not written could hand the sweep a state that
+ * lacks rows a later restore brings back.
+ */
+export declare function fenceAttachmentSweep(store: TenantBlobStore, scopeId: string, now: string): Promise<void>;
+/**
+ * What a caller asks of a host's pass (`ScopeHost.sweepOrphanAttachments`). No instant: the
+ * host judges the age floor and the fence against its OWN clock, so no caller can step past
+ * either by handing in a later time.
+ */
+export interface OrphanSweepRequest {
+    /** Report what a pass would condemn and delete, and change nothing. */
+    dryRun?: boolean;
+    /** The most objects deleted in one pass. Default `ORPHAN_SWEEP_LIMIT`. */
+    limit?: number;
+    /**
+     * A host with no directory (a CP-less deployment) cannot read the copy ledger, so it cannot see
+     * a kept or pending copy of the scope in another version's script, whose rows the serving copy
+     * lacks. It refuses unless its caller says it checked the ledger and found no such copy.
+     */
+    copiesSettled?: boolean;
+    /**
+     * The version the platform routed this pass to: the one the scope runs, by the directory. A host
+     * that knows the version its own code is deployed as refuses a pass routed to another (a stale
+     * script, a dispatch mixup, a promote mid-pass). See {@link orphanSweepVersionRefusal}.
+     */
+    expectedVersionId?: string;
+}
+/**
+ * Why a pass may not run in a script deployed as `deployed`, when the platform routed it to the
+ * script running `expected` (#2314), or null. A script deployed as another version refuses any
+ * pass. A deployed script that carries no version identity cannot be told it is the one routed to,
+ * so it refuses a destructive pass and lets a dry run proceed, since a dry run deletes nothing.
+ * No `expected` (a host the platform does not route to, a self-host) asks nothing.
+ */
+export declare function orphanSweepVersionRefusal(deployed: string | null, expected: string | undefined, destructive: boolean): Error | null;
+/** The options the kernel's pass takes from its host: the request, and the host's clock. */
+export interface OrphanSweepOptions {
+    /** The instant the pass judges age and the fence against: the HOST's clock, never a caller's. */
+    now: string;
+    /** Report what a pass would condemn and delete, and change nothing. */
+    dryRun?: boolean;
+    /** Candidate age floor in ms. Default `ORPHAN_SWEEP_GRACE_MS`; never below one day. */
+    graceMs?: number;
+    /** How long a fence holds. Default `ORPHAN_SWEEP_FENCE_MS`; never below 31 days. */
+    fenceMs?: number;
+    /** The most objects deleted in one pass. Default `ORPHAN_SWEEP_LIMIT`. */
+    limit?: number;
+}
+export interface OrphanSweepReport {
+    /** Objects under the scope's attachment prefix. */
+    listed: number;
+    /** Objects old enough to be judged. */
+    candidates: number;
+    /** Objects whose id no row names: condemned (or, in a dry run, that would be). */
+    orphans: number;
+    /** Objects deleted. Always 0 in a dry run, and while fenced. */
+    deleted: number;
+    /** The keys deleted, or in a dry run the keys that would be. At most `limit`. */
+    keys: string[];
+    /** Set when the restore fence held the pass: the instant until which it holds. */
+    fencedUntil?: string;
+    /**
+     * Set when a destructive pass could not bring the scope's dry-run licence up to date afterwards
+     * (#2350): take out what it deleted, and what is gone some other way. Any deletes stand and `keys`
+     * names them. The licence keeps rows for ids that are gone, which license nothing a pass could
+     * delete, and which the next pass that settles the licence takes out.
+     */
+    consumeFailed?: true;
+    dryRun: boolean;
+    /**
+     * `'none'` when the deployment holds no attachment store for the tenant at all, so nothing was
+     * listed (#2314). Set apart from a pass that listed an empty store, so a store binding missing
+     * from a vertical that does keep files cannot pass for a clean sweep.
+     */
+    bucket?: 'none';
+}
+/**
+ * What the scope side of a pass is: the read for a dry run, and the licence it records; the
+ * licensed condemnation otherwise, and the consumption of the licence by what was deleted.
+ */
+export interface OrphanSweepScope {
+    rowless(ids: readonly string[]): Promise<string[]>;
+    /** Condemn the ids the scope's licence lists (`condemnLicensedOrphanAttachments`). */
+    condemn(ids: readonly string[], now: string): Promise<string[]>;
+    /** Record what a dry run found as the scope's licence (`recordOrphanSweepLicence`). */
+    license(ids: readonly string[], now: string): Promise<void>;
+    /** The ids the scope's licence lists (`licensedOrphanIds`). */
+    licensed(): Promise<string[]>;
+    /** Take ids out of the licence (`consumeOrphanSweepLicence`). */
+    consume(ids: readonly string[]): Promise<void>;
+}
+/**
+ * One pass over one scope's attachment bytes. The host supplies the store and the scope side;
+ * this decides, in this order: the fence, the candidates by age, the condemnation in batches,
+ * the fence again, the deletes. Every failure before a delete leaves every object in place, and a
+ * delete that fails leaves its tombstone, so the next pass finishes it.
+ */
+export declare function sweepOrphanAttachments(store: TenantBlobStore, scopeId: string, scope: OrphanSweepScope, opts: OrphanSweepOptions): Promise<OrphanSweepReport>;
+//# sourceMappingURL=attachment-sweep.d.ts.map

package/dist/attachment-sweep.d.ts.map

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