swarm-deploy 0.0.0 → 0.2.0

package/dist/storage/root-coordinator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRootLease = withRootLease;
+exports.withNameLease = withNameLease;
+const leases = new Map();
+function withLease(key, operation) {
+    const previous = leases.get(key) || Promise.resolve();
+    const result = previous.then(operation, operation);
+    const tracked = result.then(() => undefined, () => undefined);
+    leases.set(key, tracked);
+    return result.finally(() => {
+        if (leases.get(key) === tracked)
+            leases.delete(key);
+    });
+}
+function withRootLease(root, operation) {
+    return withLease(root, operation);
+}
+/**
+ * Serializes inspection, admission, replacement, and recovery for one visible
+ * name. Distinct names stay concurrent. Callers that also need the root lease
+ * must take the name lease first.
+ */
+function withNameLease(root, name, operation) {
+    return withLease(`${root}\u0000${name}`, operation);
+}
+//# sourceMappingURL=root-coordinator.js.map

package/dist/storage/root-coordinator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-coordinator.js","sourceRoot":"","sources":["../../src/storage/root-coordinator.ts"],"names":[],"mappings":";;;;AAAA,MAAM,MAAM,GAAG,IAAI,GAAG,EAAyB,CAAA;AAE/C,SAAS,SAAS,CAAI,GAAW,EAAE,SAA+B;IAChE,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,OAAO,EAAE,CAAA;IACrD,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;IAClD,MAAM,OAAO,GAAkB,MAAM,CAAC,IAAI,CACxC,GAAG,EAAE,CAAC,SAAS,EACf,GAAG,EAAE,CAAC,SAAS,CAChB,CAAA;IACD,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;IACxB,OAAO,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE;QACzB,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,OAAO;YAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;IACrD,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,uBAAiC,IAAY,EAAE,SAA+B;IAC5E,OAAO,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;AACnC,CAAC;AAED;;;;GAIG;AACH,uBACE,IAAY,EACZ,IAAY,EACZ,SAA+B;IAE/B,OAAO,SAAS,CAAC,GAAG,IAAI,SAAS,IAAI,EAAE,EAAE,SAAS,CAAC,CAAA;AACrD,CAAC"}

package/dist/storage/session-store.d.ts

@@ -0,0 +1,2 @@
+/** Durable direct-TAR storage authority. */
+export { TarSessionStore as SessionStore, type TarAdmission, type TarSession } from './tar-session-store.js';

package/dist/storage/session-store.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionStore = void 0;
+/** Durable direct-TAR storage authority. */
+var tar_session_store_js_1 = require("./tar-session-store.js");
+Object.defineProperty(exports, "SessionStore", { enumerable: true, get: function () { return tar_session_store_js_1.TarSessionStore; } });
+//# sourceMappingURL=session-store.js.map

package/dist/storage/session-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-store.js","sourceRoot":"","sources":["../../src/storage/session-store.ts"],"names":[],"mappings":";;;AAAA,4CAA4C;AAC5C,+DAI+B;AAH7B,oHAAA,eAAe,OAAgB"}

package/dist/storage/tar-session-store.d.ts

@@ -0,0 +1,147 @@
+import { type AnyMetadataRecord } from '../tar-protocol/controls.js';
+import type { StorageAdapter, StorageLayout } from './types.js';
+import type { ArtifactKind, Clock } from '../types.js';
+/** Directory sessions are persisted at a version no file-only server understands. */
+export declare const TREE_SESSION_VERSION = 4;
+declare const RECEIVING = "receiving";
+declare const VERIFIED = "verified";
+declare const DELETING = "deleting";
+type State = typeof RECEIVING | typeof VERIFIED | typeof DELETING;
+export interface TarSession {
+    id: string;
+    transferId: Buffer;
+    ownerKey: Buffer;
+    kind: ArtifactKind;
+    name: string;
+    sourceParent?: string;
+    /** Payload bytes: the file size, or the aggregate tree payload size. */
+    size: number;
+    /** The file digest, or the canonical tree digest. */
+    digest: Buffer;
+    /** Present only for a directory session. */
+    entryCount?: number;
+    tarSize: number;
+    tarDigest: Buffer;
+    tarPath: string;
+    /** Present only for a directory session. */
+    treePath?: string;
+    state: State;
+    createdAt: number;
+    updatedAt: number;
+    partialTarSize: number;
+}
+export type TarAdmission = {
+    status: 'ACCEPT';
+    offset: 0;
+} | {
+    status: 'RESUME';
+    offset: number;
+    prefixSha256: Buffer;
+} | {
+    status: 'VERIFIED';
+};
+export interface TarSessionStoreOptions {
+    layout: StorageLayout;
+    maxStagingBytes: number;
+    minFreeBytes?: number;
+    clock?: Clock;
+    resumeTtl?: number;
+    isSessionActive?: (session: TarSession) => boolean;
+    storage?: StorageAdapter;
+}
+/** Durable direct-TAR session authority. */
+export declare class TarSessionStore {
+    readonly layout: StorageLayout;
+    readonly maxStagingBytes: number;
+    readonly minFreeBytes: number;
+    readonly clock: Clock;
+    readonly resumeTtl: number | undefined;
+    readonly isSessionActive: (session: TarSession) => boolean;
+    readonly storage: StorageAdapter;
+    readonly sessions: Map<string, TarSession>;
+    reservedBytes: number;
+    purgedSessions: number;
+    /** Sessions dropped from memory whose staging files could not be unlinked. */
+    strandedSessions: number;
+    initialized: boolean;
+    closed: boolean;
+    private closing;
+    private pending;
+    private closePromise;
+    private readonly verifying;
+    private readonly verificationTasks;
+    private run;
+    constructor({ layout, maxStagingBytes, minFreeBytes, clock, resumeTtl, isSessionActive, storage }: TarSessionStoreOptions);
+    private sessionPath;
+    private tarPath;
+    private filePath;
+    private treeStagingPath;
+    /** Removes a staged tree through the contained primitives; never `storage.rm`. */
+    private removeStagedTree;
+    private journalPath;
+    private reserve;
+    private assertReady;
+    private metadata;
+    private fileMetadata;
+    private treeFromDisk;
+    private fromDisk;
+    /**
+     * Version 3 only adds `sourceParent`, so a session without one is written as
+     * version 2. An older server can then still read, and resume, every session
+     * whose record it fully understands; only parent-bearing ones are lost to a
+     * downgrade.
+     */
+    private serialize;
+    private writeSession;
+    private remove;
+    /** A verified directory session must still own its staging tree. */
+    private assertStagedTree;
+    /** Verified directory sessions mid-commit may only have a durable journal tree. */
+    private assertVerifiedDirectorySession;
+    private purgeCorruptSession;
+    /** Removes only a regular crash residue and syncs its parent before reporting it purged. */
+    private purgeSafeResidue;
+    private hashPrefix;
+    private ensureTarLength;
+    private diskReserve;
+    init(): Promise<void>;
+    admit(ownerKey: Uint8Array, input: AnyMetadataRecord): Promise<TarAdmission>;
+    append(ownerKey: Uint8Array, input: AnyMetadataRecord, offset: number, data: Uint8Array): Promise<number>;
+    private rollbackTar;
+    private rollbackOrQuarantine;
+    private resetUnlocked;
+    private quarantineVerificationFailure;
+    verify(ownerKey: Uint8Array, input: AnyMetadataRecord): Promise<TarSession>;
+    /**
+     * Extracts the complete directory archive into its staging tree, then proves
+     * the tree from the bytes on disk alone: the recomputed canonical digest,
+     * entry count, and payload size must equal the offered values.
+     */
+    private extractTree;
+    private readTar;
+    readVerified(transferId: Uint8Array): Promise<TarSession>;
+    /**
+     * Drops a session from the in-memory authority exactly once.
+     *
+     * `reservedBytes` must always equal the sum of `reserve()` over `sessions`,
+     * so the bookkeeping runs in a `finally`: a failed unlink would otherwise
+     * strand the reservation for the lifetime of the process, and leave the name
+     * permanently colliding in `admit()`. Any file that survives the failure is a
+     * crash residue, which `init()` purges on the next start.
+     */
+    private removeSession;
+    delete(transferId: Uint8Array): Promise<boolean>;
+    /**
+     * Sweeps expired sessions without letting one failure abort the rest.
+     *
+     * `admit()` runs this opportunistically on every offer, so a single session
+     * whose files cannot be unlinked must not deny service to every later
+     * upload. Failures are counted in `strandedSessions` and reported to the
+     * explicit `expire()` caller, which asked for the sweep and can act on it.
+     */
+    private expireUnlocked;
+    expire(ttl: number, predicate?: (session: TarSession) => boolean): Promise<number>;
+    retireCommitted(transferId: Uint8Array): Promise<boolean>;
+    close(): Promise<void>;
+}
+export {};