@smthrs/artifacts 0.0.0-stage → 1.0.0-rc.12

package/dist/cjs/ArtifactSweep.d.ts

@@ -0,0 +1,185 @@
+/**
+ * The sweep half of artifact garbage collection: enumerate this host's blobs
+ * and delete one, fenced by its age.
+ *
+ * This surface is deliberately NOT part of `ArtifactStore.Service`. The store
+ * contract is shared by memory, filesystem, and network tiers, and a remote
+ * tier can neither enumerate its address space nor accept a delete — Bazel
+ * draws the same line: its disk-cache collector
+ * (class `DiskCacheGarbageCollector` in
+ * `com.google.devtools.build.lib.remote.disk`) walks the local directory, while
+ * the remote tier owns its own retention. Only the
+ * host-local filesystem store implements this.
+ *
+ * The *policy* — which digests are live, how old a dead blob must be before it
+ * goes — belongs to the engine composition, which is the only place the
+ * durable roots (attempt rows, cache entries) are visible. This module ships
+ * mechanics alone; `@smthrs/engine-store` owns the mark policy and grace
+ * period.
+ *
+ * @since 1.0.0-rc.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as ArtifactStore from "./ArtifactStore.ts";
+/**
+ * One enumerated blob: its content address, when it was last written or
+ * freshened, and its size.
+ *
+ * `modifiedAtMs` is the age evidence a sweep fences on — the same signal git
+ * (`git prune --expire`) and Bazel's disk-cache collector read, because it is
+ * the one timestamp a filesystem maintains without any bookkeeping of ours.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export interface BlobStat {
+    readonly digest: string;
+    readonly modifiedAtMs: number;
+    readonly sizeBytes: number;
+}
+/**
+ * Fencing predicate for a sweep deletion.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export interface RemoveOptions {
+    /**
+     * Deletes the blob only while its mtime is still at or before this bound.
+     * A blob freshened after the caller computed its live set — a concurrent
+     * `put` re-referencing the same bytes — fails the fence and survives, the
+     * same shape as `CacheStore.evict`'s `ifRecordedBy`: the guard rides in the
+     * delete, never in a prior read alone.
+     */
+    readonly ifUnmodifiedSinceMs?: number | undefined;
+}
+/**
+ * Host-local blob enumeration and fenced deletion.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export interface Service {
+    /**
+     * Every content-addressed blob this host's store currently holds. In-flight
+     * `.tmp-*` scratch files, foreign files, and blobs whose age cannot be
+     * measured are excluded — what the sweep cannot judge it must not touch.
+     */
+    readonly inventory: Effect.Effect<Array<BlobStat>, ArtifactStore.ArtifactStoreError>;
+    /**
+     * Deletes the blob at `digest`, returning whether bytes were removed. A
+     * missing blob reports `false` rather than failing, so a crashed and
+     * re-run sweep converges instead of erroring on its own progress.
+     *
+     * `false` covers three outcomes a caller cannot tell apart, all of which mean
+     * "nothing was reclaimed, and retrying later is safe": the blob was already
+     * gone, it failed the `ifUnmodifiedSinceMs` fence, or a live backup lease
+     * fenced the deletion (see `ArtifactBackupLease`). The last one is not
+     * progress — the blob is still there — so a collector that counts reclaimed
+     * bytes must not count it, and the next pass after the backup finishes
+     * removes it.
+     */
+    readonly remove: (digest: string, options?: RemoveOptions) => Effect.Effect<boolean, ArtifactStore.ArtifactStoreError>;
+}
+declare const ArtifactSweep_base: Context.ServiceClass<ArtifactSweep, "@smthrs/artifacts/ArtifactSweep", Service>;
+/**
+ * Service tag for host-local artifact sweeping.
+ *
+ * The identity string equals this module's package path, per the house rule
+ * that a new identity is the defining module path.
+ *
+ * @category services
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export declare class ArtifactSweep extends ArtifactSweep_base {
+}
+/**
+ * How the sweep reaches the objects directory.
+ *
+ * Deliberately not `ArtifactStore.FileSystemOptions`: the sweep never writes a
+ * blob, so `durability` would be an accepted argument it ignores. Both fields
+ * must match the store built over the same directory — see `coordination`.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface SweepOptions {
+    /**
+     * The objects directory to enumerate, the one the paired
+     * `ArtifactStore.makeFileSystem` publishes into. Defaults to
+     * `ArtifactStore.defaultDirectory`.
+     */
+    readonly directory?: string | undefined;
+    /**
+     * `required` takes the same per-digest lock file a publishing writer takes,
+     * and consults the backup lease, before deleting. It fences nothing unless
+     * the paired store was built with `required` too: a store on `process` never
+     * takes the lock this sweep waits on, so the fence would read as armed while
+     * protecting nothing. `process` is the explicit weaker browser/test mode.
+     */
+    readonly coordination?: "required" | "process" | undefined;
+}
+/**
+ * Builds the filesystem-backed sweep surface over the same objects directory
+ * an `ArtifactStore.makeFileSystem` publishes into.
+ *
+ * Enumeration is conservative by construction. Only paths in the store's
+ * canonical fanout shape — `xx/<digest>` with `xx` equal to the digest's
+ * two-hex prefix — are blobs; anything else in the directory (a temp file, a
+ * lock file, a foreign file, a fanout directory itself) is skipped, never
+ * deleted. A blob that vanishes between listing and stat was removed by someone
+ * else and is likewise skipped.
+ *
+ * Pair it with the store over the SAME `directory` and the SAME `coordination`.
+ * Nothing checks the pairing, and a mismatch is silent: a sweep on `required`
+ * beside a store on `process` deletes blobs no writer is fenced against.
+ *
+ * Under `required`, one deletion costs two lock acquisitions — the per-digest
+ * lock, then the workspace-global backup-lease gate — which is roughly ten
+ * filesystem operations and two forked heartbeat fibers per blob. The gate is
+ * one file for the whole workspace, so concurrent deletions serialize through
+ * it. That is the price of never deleting a blob a running backup already
+ * recorded; size a collection window with it in mind.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export declare const makeFileSystem: (fs: FileSystem.FileSystem, options?: SweepOptions) => Service;
+/**
+ * Provides the filesystem-backed sweep surface.
+ *
+ * Give it the same `directory` and `coordination` as the `ArtifactStore` layer
+ * it sweeps behind; see {@link makeFileSystem}.
+ *
+ * @category layers
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export declare const layerFileSystem: (options?: SweepOptions) => Layer.Layer<ArtifactSweep, never, FileSystem.FileSystem>;
+/**
+ * Builds a sweep surface whose every operation fails as unavailable, with
+ * per-method overrides.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export declare const makeNoop: (overrides?: Partial<Service>) => Service;
+/**
+ * Provides a no-op sweep surface.
+ *
+ * @category layers
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export declare const layerNoop: (overrides?: Partial<Service>) => Layer.Layer<ArtifactSweep>;
+export {};
+//# sourceMappingURL=ArtifactSweep.d.ts.map

package/dist/cjs/ArtifactSweep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArtifactSweep.d.ts","sourceRoot":"","sources":["../../src/ArtifactSweep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAIrC,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAInD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAClD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAA;IACpF;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,MAAM,EAAE,CACf,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,aAAa,KACpB,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAA;CAC9D;;AAED;;;;;;;;;GASG;AACH,qBAAa,aAAc,SAAQ,kBAA4E;CAAG;AAelH;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACvC;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,CAAA;CAC3D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc,GACzB,IAAI,UAAU,CAAC,UAAU,EACzB,UAAS,YAAiB,KACzB,OA2HF,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAS,YAAiB,KACzB,KAAK,CAAC,KAAK,CAAC,aAAa,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAC2C,CAAA;AAErG;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GAAI,YAAW,OAAO,CAAC,OAAO,CAAM,KAAG,OAI1D,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,GAAI,YAAW,OAAO,CAAC,OAAO,CAAM,KAAG,KAAK,CAAC,KAAK,CAAC,aAAa,CACnC,CAAA"}

package/dist/cjs/ArtifactSweep.js

@@ -0,0 +1,171 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ArtifactSweep_exports = {};
+__export(ArtifactSweep_exports, {
+  ArtifactSweep: () => ArtifactSweep,
+  layerFileSystem: () => layerFileSystem,
+  layerNoop: () => layerNoop,
+  makeFileSystem: () => makeFileSystem,
+  makeNoop: () => makeNoop
+});
+module.exports = __toCommonJS(ArtifactSweep_exports);
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var FileSystem = __toESM(require("effect/FileSystem"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var PlatformError = __toESM(require("effect/PlatformError"), 1);
+var ArtifactBackupLease = __toESM(require("./ArtifactBackupLease.js"), 1);
+var ArtifactStore = __toESM(require("./ArtifactStore.js"), 1);
+var ArtifactLocks = __toESM(require("./internal/ArtifactLocks.js"), 1);
+var ArtifactPath = __toESM(require("./internal/ArtifactPath.js"), 1);
+class ArtifactSweep extends Context.Service()("@smthrs/artifacts/ArtifactSweep") {
+}
+const error = (message, cause) => new ArtifactStore.ArtifactStoreError({
+  code: "unavailable",
+  message,
+  ...cause === void 0 ? {} : { cause }
+});
+const hostFailure = (cause) => error(`the host filesystem refused a sweep operation: ${String(cause)}`, cause);
+const isNotFound = (cause) => cause instanceof PlatformError.PlatformError && cause.reason._tag === "NotFound";
+const makeFileSystem = (fs, options = {}) => {
+  const directory = (options.directory ?? ArtifactStore.defaultDirectory).replace(/([^/])\/+$/, "$1");
+  const coordination = options.coordination ?? "required";
+  const blobPath = (digest) => `${directory}/${digest.slice(0, 2)}/${digest}`;
+  const inventory = Effect.gen(function* () {
+    const checkRoot = yield* ArtifactPath.guard(fs, directory).pipe(Effect.mapError(hostFailure));
+    const parents = yield* fs.readDirectory(directory).pipe(
+      Effect.catch((cause) => isNotFound(cause) ? Effect.succeed([]) : Effect.fail(hostFailure(cause)))
+    );
+    const entries = [];
+    for (const parent of parents) {
+      if (!/^[0-9a-f]{2}$/.test(parent)) continue;
+      yield* checkRoot.pipe(Effect.mapError(hostFailure));
+      const safe = yield* ArtifactPath.guard(fs, `${directory}/${parent}`).pipe(Effect.option);
+      if (Option.isNone(safe)) continue;
+      const children = yield* fs.readDirectory(`${directory}/${parent}`).pipe(
+        Effect.orElseSucceed(() => [])
+      );
+      for (const child of children) entries.push(`${parent}/${child}`);
+    }
+    const candidates = entries.filter((entry) => {
+      if (entry.includes(".tmp-")) return false;
+      const separator = entry.indexOf("/");
+      const fan = entry.slice(0, separator);
+      const digest = entry.slice(separator + 1);
+      return /^[0-9a-f]{64}$/.test(digest) && fan === digest.slice(0, 2);
+    });
+    const blobs = yield* Effect.forEach(candidates, (entry) => Effect.gen(function* () {
+      const separator = entry.indexOf("/");
+      const fan = entry.slice(0, separator);
+      const digest = entry.slice(separator + 1);
+      const info = yield* Effect.gen(function* () {
+        yield* checkRoot;
+        yield* ArtifactPath.guard(fs, `${directory}/${fan}`);
+        yield* ArtifactPath.guard(fs, `${directory}/${entry}`, "File");
+        return yield* fs.stat(`${directory}/${entry}`);
+      }).pipe(Effect.option);
+      if (Option.isNone(info) || info.value.type !== "File") return void 0;
+      const mtime = Option.getOrUndefined(info.value.mtime);
+      if (mtime === void 0) return void 0;
+      return {
+        digest,
+        modifiedAtMs: mtime.getTime(),
+        sizeBytes: Number(info.value.size)
+      };
+    }), { concurrency: 16 });
+    return blobs.filter((blob) => blob !== void 0);
+  });
+  const remove = Effect.fn("ArtifactSweep.remove")(
+    (digest, removeOptions) => Effect.gen(function* () {
+      const validated = yield* ArtifactStore.validateDigest(digest);
+      const bound = removeOptions?.ifUnmodifiedSinceMs;
+      if (bound !== void 0 && (typeof bound !== "number" || Number.isNaN(bound))) {
+        return yield* Effect.fail(
+          new ArtifactStore.ArtifactStoreError({
+            code: "invalid_configuration",
+            message: "invalid sweep option: ifUnmodifiedSinceMs"
+          })
+        );
+      }
+      yield* Effect.annotateCurrentSpan({ digest: validated });
+      const checkRoot = yield* ArtifactPath.guard(fs, directory).pipe(Effect.mapError(hostFailure));
+      const checkParent = yield* ArtifactPath.guard(fs, `${directory}/${validated.slice(0, 2)}`).pipe(
+        Effect.mapError(hostFailure)
+      );
+      return yield* ArtifactLocks.withDigest(
+        fs,
+        directory,
+        validated,
+        coordination === "process" ? removeBlob() : ArtifactBackupLease.unlessActive(fs, directory, removeBlob(), hostFailure).pipe(
+          Effect.map(Option.getOrElse(() => false))
+        ),
+        hostFailure,
+        coordination
+      );
+      function removeBlob() {
+        return Effect.gen(function* () {
+          const path = blobPath(validated);
+          yield* checkRoot.pipe(Effect.mapError(hostFailure));
+          yield* checkParent.pipe(Effect.mapError(hostFailure));
+          const checkBlob = yield* ArtifactPath.guard(fs, path, "File").pipe(Effect.mapError(hostFailure));
+          if (bound !== void 0) {
+            const info = yield* fs.stat(path).pipe(Effect.option);
+            if (Option.isNone(info)) return false;
+            const mtime = Option.getOrUndefined(info.value.mtime);
+            if (mtime === void 0 || mtime.getTime() > bound) return false;
+          }
+          yield* checkRoot.pipe(Effect.mapError(hostFailure));
+          yield* checkParent.pipe(Effect.mapError(hostFailure));
+          yield* checkBlob.pipe(Effect.mapError(hostFailure));
+          return yield* fs.remove(path).pipe(
+            Effect.as(true),
+            // The blob may have been removed between the fence and here; only a
+            // refusal over bytes that still exist is a host failure.
+            Effect.catch(
+              (cause) => fs.exists(path).pipe(
+                Effect.mapError((probeCause) => hostFailure({ remove: cause, existenceProbe: probeCause })),
+                Effect.flatMap((present) => present ? Effect.fail(hostFailure(cause)) : Effect.succeed(false))
+              )
+            )
+          );
+        });
+      }
+    })
+  );
+  return { inventory, remove };
+};
+const layerFileSystem = (options = {}) => Layer.effect(ArtifactSweep)(Effect.map(FileSystem.FileSystem, (fs) => makeFileSystem(fs, options)));
+const makeNoop = (overrides = {}) => ({
+  inventory: Effect.fail(error("inventory is unavailable")),
+  remove: Effect.fn("ArtifactSweep.remove")(() => Effect.fail(error("remove is unavailable"))),
+  ...overrides
+});
+const layerNoop = (overrides = {}) => Layer.succeed(ArtifactSweep)(makeNoop(overrides));
+//# sourceMappingURL=ArtifactSweep.js.map

package/dist/cjs/ArtifactSweep.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/ArtifactSweep.ts"],
+  "sourcesContent": ["/**\n * The sweep half of artifact garbage collection: enumerate this host's blobs\n * and delete one, fenced by its age.\n *\n * This surface is deliberately NOT part of `ArtifactStore.Service`. The store\n * contract is shared by memory, filesystem, and network tiers, and a remote\n * tier can neither enumerate its address space nor accept a delete \u2014 Bazel\n * draws the same line: its disk-cache collector\n * (class `DiskCacheGarbageCollector` in\n * `com.google.devtools.build.lib.remote.disk`) walks the local directory, while\n * the remote tier owns its own retention. Only the\n * host-local filesystem store implements this.\n *\n * The *policy* \u2014 which digests are live, how old a dead blob must be before it\n * goes \u2014 belongs to the engine composition, which is the only place the\n * durable roots (attempt rows, cache entries) are visible. This module ships\n * mechanics alone; `@smthrs/engine-store` owns the mark policy and grace\n * period.\n *\n * @since 1.0.0-rc.0\n */\n\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as FileSystem from \"effect/FileSystem\"\nimport * as Layer from \"effect/Layer\"\nimport * as Option from \"effect/Option\"\nimport * as PlatformError from \"effect/PlatformError\"\nimport * as ArtifactBackupLease from \"./ArtifactBackupLease.ts\"\nimport * as ArtifactStore from \"./ArtifactStore.ts\"\nimport * as ArtifactLocks from \"./internal/ArtifactLocks.ts\"\nimport * as ArtifactPath from \"./internal/ArtifactPath.ts\"\n\n/**\n * One enumerated blob: its content address, when it was last written or\n * freshened, and its size.\n *\n * `modifiedAtMs` is the age evidence a sweep fences on \u2014 the same signal git\n * (`git prune --expire`) and Bazel's disk-cache collector read, because it is\n * the one timestamp a filesystem maintains without any bookkeeping of ours.\n *\n * @category models\n * @since 1.0.0-rc.0\n * @slop\n */\nexport interface BlobStat {\n  readonly digest: string\n  readonly modifiedAtMs: number\n  readonly sizeBytes: number\n}\n\n/**\n * Fencing predicate for a sweep deletion.\n *\n * @category models\n * @since 1.0.0-rc.0\n * @slop\n */\nexport interface RemoveOptions {\n  /**\n   * Deletes the blob only while its mtime is still at or before this bound.\n   * A blob freshened after the caller computed its live set \u2014 a concurrent\n   * `put` re-referencing the same bytes \u2014 fails the fence and survives, the\n   * same shape as `CacheStore.evict`'s `ifRecordedBy`: the guard rides in the\n   * delete, never in a prior read alone.\n   */\n  readonly ifUnmodifiedSinceMs?: number | undefined\n}\n\n/**\n * Host-local blob enumeration and fenced deletion.\n *\n * @category models\n * @since 1.0.0-rc.0\n * @slop\n */\nexport interface Service {\n  /**\n   * Every content-addressed blob this host's store currently holds. In-flight\n   * `.tmp-*` scratch files, foreign files, and blobs whose age cannot be\n   * measured are excluded \u2014 what the sweep cannot judge it must not touch.\n   */\n  readonly inventory: Effect.Effect<Array<BlobStat>, ArtifactStore.ArtifactStoreError>\n  /**\n   * Deletes the blob at `digest`, returning whether bytes were removed. A\n   * missing blob reports `false` rather than failing, so a crashed and\n   * re-run sweep converges instead of erroring on its own progress.\n   *\n   * `false` covers three outcomes a caller cannot tell apart, all of which mean\n   * \"nothing was reclaimed, and retrying later is safe\": the blob was already\n   * gone, it failed the `ifUnmodifiedSinceMs` fence, or a live backup lease\n   * fenced the deletion (see `ArtifactBackupLease`). The last one is not\n   * progress \u2014 the blob is still there \u2014 so a collector that counts reclaimed\n   * bytes must not count it, and the next pass after the backup finishes\n   * removes it.\n   */\n  readonly remove: (\n    digest: string,\n    options?: RemoveOptions\n  ) => Effect.Effect<boolean, ArtifactStore.ArtifactStoreError>\n}\n\n/**\n * Service tag for host-local artifact sweeping.\n *\n * The identity string equals this module's package path, per the house rule\n * that a new identity is the defining module path.\n *\n * @category services\n * @since 1.0.0-rc.0\n * @slop\n */\nexport class ArtifactSweep extends Context.Service<ArtifactSweep, Service>()(\"@smthrs/artifacts/ArtifactSweep\") {}\n\nconst error = (message: string, cause?: unknown): ArtifactStore.ArtifactStoreError =>\n  new ArtifactStore.ArtifactStoreError({\n    code: \"unavailable\",\n    message,\n    ...(cause === undefined ? {} : { cause })\n  })\n\nconst hostFailure = (cause: unknown): ArtifactStore.ArtifactStoreError =>\n  error(`the host filesystem refused a sweep operation: ${String(cause)}`, cause)\n\nconst isNotFound = (cause: unknown): boolean =>\n  cause instanceof PlatformError.PlatformError && cause.reason._tag === \"NotFound\"\n\n/**\n * How the sweep reaches the objects directory.\n *\n * Deliberately not `ArtifactStore.FileSystemOptions`: the sweep never writes a\n * blob, so `durability` would be an accepted argument it ignores. Both fields\n * must match the store built over the same directory \u2014 see `coordination`.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface SweepOptions {\n  /**\n   * The objects directory to enumerate, the one the paired\n   * `ArtifactStore.makeFileSystem` publishes into. Defaults to\n   * `ArtifactStore.defaultDirectory`.\n   */\n  readonly directory?: string | undefined\n  /**\n   * `required` takes the same per-digest lock file a publishing writer takes,\n   * and consults the backup lease, before deleting. It fences nothing unless\n   * the paired store was built with `required` too: a store on `process` never\n   * takes the lock this sweep waits on, so the fence would read as armed while\n   * protecting nothing. `process` is the explicit weaker browser/test mode.\n   */\n  readonly coordination?: \"required\" | \"process\" | undefined\n}\n\n/**\n * Builds the filesystem-backed sweep surface over the same objects directory\n * an `ArtifactStore.makeFileSystem` publishes into.\n *\n * Enumeration is conservative by construction. Only paths in the store's\n * canonical fanout shape \u2014 `xx/<digest>` with `xx` equal to the digest's\n * two-hex prefix \u2014 are blobs; anything else in the directory (a temp file, a\n * lock file, a foreign file, a fanout directory itself) is skipped, never\n * deleted. A blob that vanishes between listing and stat was removed by someone\n * else and is likewise skipped.\n *\n * Pair it with the store over the SAME `directory` and the SAME `coordination`.\n * Nothing checks the pairing, and a mismatch is silent: a sweep on `required`\n * beside a store on `process` deletes blobs no writer is fenced against.\n *\n * Under `required`, one deletion costs two lock acquisitions \u2014 the per-digest\n * lock, then the workspace-global backup-lease gate \u2014 which is roughly ten\n * filesystem operations and two forked heartbeat fibers per blob. The gate is\n * one file for the whole workspace, so concurrent deletions serialize through\n * it. That is the price of never deleting a blob a running backup already\n * recorded; size a collection window with it in mind.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n * @slop\n */\nexport const makeFileSystem = (\n  fs: FileSystem.FileSystem,\n  options: SweepOptions = {}\n): Service => {\n  const directory = (options.directory ?? ArtifactStore.defaultDirectory).replace(/([^/])\\/+$/, \"$1\")\n  const coordination = options.coordination ?? \"required\"\n  const blobPath = (digest: string): string => `${directory}/${digest.slice(0, 2)}/${digest}`\n\n  const inventory: Service[\"inventory\"] = Effect.gen(function*() {\n    // A store that never published anything has no directory; that is an\n    // empty inventory, not a failure.\n    const checkRoot = yield* ArtifactPath.guard(fs, directory).pipe(Effect.mapError(hostFailure))\n    const parents = yield* fs.readDirectory(directory).pipe(\n      Effect.catch((cause) => isNotFound(cause) ? Effect.succeed([] as Array<string>) : Effect.fail(hostFailure(cause)))\n    )\n    const entries: Array<string> = []\n    for (const parent of parents) {\n      if (!/^[0-9a-f]{2}$/.test(parent)) continue\n      yield* checkRoot.pipe(Effect.mapError(hostFailure))\n      const safe = yield* ArtifactPath.guard(fs, `${directory}/${parent}`).pipe(Effect.option)\n      if (Option.isNone(safe)) continue\n      const children = yield* fs.readDirectory(`${directory}/${parent}`).pipe(\n        Effect.orElseSucceed(() => [] as Array<string>)\n      )\n      for (const child of children) entries.push(`${parent}/${child}`)\n    }\n    const candidates = entries.filter((entry) => {\n      if (entry.includes(\".tmp-\")) return false\n      const separator = entry.indexOf(\"/\")\n      const fan = entry.slice(0, separator)\n      const digest = entry.slice(separator + 1)\n      return /^[0-9a-f]{64}$/.test(digest) && fan === digest.slice(0, 2)\n    })\n    const blobs = yield* Effect.forEach(candidates, (entry) =>\n      Effect.gen(function*() {\n        const separator = entry.indexOf(\"/\")\n        const fan = entry.slice(0, separator)\n        const digest = entry.slice(separator + 1)\n        // The stat is per-candidate and tolerant: a blob another process\n        // removed between the listing and here simply is not in the\n        // inventory, and one whose mtime the host cannot report offers no\n        // age evidence, so the sweep must never judge it.\n        const info = yield* Effect.gen(function*() {\n          yield* checkRoot\n          yield* ArtifactPath.guard(fs, `${directory}/${fan}`)\n          yield* ArtifactPath.guard(fs, `${directory}/${entry}`, \"File\")\n          return yield* fs.stat(`${directory}/${entry}`)\n        }).pipe(Effect.option)\n        if (Option.isNone(info) || info.value.type !== \"File\") return undefined\n        const mtime = Option.getOrUndefined(info.value.mtime)\n        if (mtime === undefined) return undefined\n        return {\n          digest,\n          modifiedAtMs: mtime.getTime(),\n          sizeBytes: Number(info.value.size)\n        }\n      }), { concurrency: 16 })\n    return blobs.filter((blob) => blob !== undefined)\n  })\n\n  const remove: Service[\"remove\"] = Effect.fn(\"ArtifactSweep.remove\")((digest, removeOptions) =>\n    Effect.gen(function*() {\n      const validated = yield* ArtifactStore.validateDigest(digest)\n      const bound = removeOptions?.ifUnmodifiedSinceMs\n      // NaN fails every comparison, so the fence below would read it as \"not\n      // modified since\" and delete a blob a concurrent put just freshened.\n      if (bound !== undefined && (typeof bound !== \"number\" || Number.isNaN(bound))) {\n        return yield* Effect.fail(\n          new ArtifactStore.ArtifactStoreError({\n            code: \"invalid_configuration\",\n            message: \"invalid sweep option: ifUnmodifiedSinceMs\"\n          })\n        )\n      }\n      yield* Effect.annotateCurrentSpan({ digest: validated })\n      const checkRoot = yield* ArtifactPath.guard(fs, directory).pipe(Effect.mapError(hostFailure))\n      const checkParent = yield* ArtifactPath.guard(fs, `${directory}/${validated.slice(0, 2)}`).pipe(\n        Effect.mapError(hostFailure)\n      )\n      return yield* ArtifactLocks.withDigest(\n        fs,\n        directory,\n        validated,\n        coordination === \"process\"\n          ? removeBlob()\n          : ArtifactBackupLease.unlessActive(fs, directory, removeBlob(), hostFailure).pipe(\n            Effect.map(Option.getOrElse(() => false))\n          ),\n        hostFailure,\n        coordination\n      )\n\n      function removeBlob(): Effect.Effect<boolean, ArtifactStore.ArtifactStoreError> {\n        return Effect.gen(function*() {\n          const path = blobPath(validated)\n          yield* checkRoot.pipe(Effect.mapError(hostFailure))\n          yield* checkParent.pipe(Effect.mapError(hostFailure))\n          const checkBlob = yield* ArtifactPath.guard(fs, path, \"File\").pipe(Effect.mapError(hostFailure))\n          if (bound !== undefined) {\n            const info = yield* fs.stat(path).pipe(Effect.option)\n            // Already gone is a completed deletion, and an unmeasurable mtime is\n            // no proof of age: both refuse rather than delete.\n            if (Option.isNone(info)) return false\n            const mtime = Option.getOrUndefined(info.value.mtime)\n            if (mtime === undefined || mtime.getTime() > bound) return false\n          }\n          yield* checkRoot.pipe(Effect.mapError(hostFailure))\n          yield* checkParent.pipe(Effect.mapError(hostFailure))\n          yield* checkBlob.pipe(Effect.mapError(hostFailure))\n          return yield* fs.remove(path).pipe(\n            Effect.as(true),\n            // The blob may have been removed between the fence and here; only a\n            // refusal over bytes that still exist is a host failure.\n            Effect.catch((cause) =>\n              fs.exists(path).pipe(\n                Effect.mapError((probeCause) => hostFailure({ remove: cause, existenceProbe: probeCause })),\n                Effect.flatMap((present) => present ? Effect.fail(hostFailure(cause)) : Effect.succeed(false))\n              )\n            )\n          )\n        })\n      }\n    })\n  )\n\n  return { inventory, remove }\n}\n\n/**\n * Provides the filesystem-backed sweep surface.\n *\n * Give it the same `directory` and `coordination` as the `ArtifactStore` layer\n * it sweeps behind; see {@link makeFileSystem}.\n *\n * @category layers\n * @since 1.0.0-rc.0\n * @slop\n */\nexport const layerFileSystem = (\n  options: SweepOptions = {}\n): Layer.Layer<ArtifactSweep, never, FileSystem.FileSystem> =>\n  Layer.effect(ArtifactSweep)(Effect.map(FileSystem.FileSystem, (fs) => makeFileSystem(fs, options)))\n\n/**\n * Builds a sweep surface whose every operation fails as unavailable, with\n * per-method overrides.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n * @slop\n */\nexport const makeNoop = (overrides: Partial<Service> = {}): Service => ({\n  inventory: Effect.fail(error(\"inventory is unavailable\")),\n  remove: Effect.fn(\"ArtifactSweep.remove\")(() => Effect.fail(error(\"remove is unavailable\"))),\n  ...overrides\n})\n\n/**\n * Provides a no-op sweep surface.\n *\n * @category layers\n * @since 1.0.0-rc.0\n * @slop\n */\nexport const layerNoop = (overrides: Partial<Service> = {}): Layer.Layer<ArtifactSweep> =>\n  Layer.succeed(ArtifactSweep)(makeNoop(overrides))\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/CombinedArtifacts.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Two artifact tiers composed into one: local first, remote second, with
+ * write-back into the local tier.
+ *
+ * This is the shape of Bazel's `CombinedCache`
+ * (`com.google.devtools.build.lib.remote.CombinedCache`): a read consults the
+ * disk cache, falls back to the remote cache only on a miss, and *uploads what it
+ * found back into the disk cache* so the next read is local
+ * (`downloadActionResultFromRemote`, lines 230-303). A write goes to both.
+ *
+ * Deviation from Bazel: policy is declared once by the remote tier rather than
+ * threaded through every call. `downloadPolicy` controls prefetch and local
+ * materialization; composing only the local tier opts out of shared storage.
+ *
+ * @since 1.0.0-rc.0
+ */
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ArtifactStore from "./ArtifactStore.ts";
+import * as RemoteArtifacts from "./RemoteArtifacts.ts";
+/**
+ * The two tiers to compose.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export interface Options {
+    /** The fast, machine-local tier. Every read tries this one first. */
+    readonly local: ArtifactStore.Service;
+    /** The shared tier. Consulted only on a local miss; written through on put. */
+    readonly remote: ArtifactStore.Service;
+    /**
+     * How long a `put` waits for its opportunistic upload to the shared tier
+     * before abandoning it. The local digest is already in hand when the upload
+     * starts, so the deadline bounds only how long a stalled remote can delay
+     * the answer — an abandoned upload is dropped exactly like a refused one.
+     * Defaults to 60 seconds, Bazel's `--remote_timeout` default
+     * (its `RemoteOptions`).
+     */
+    readonly uploadTimeout?: Duration.Input | undefined;
+    /**
+     * How long a `get` waits for opportunistic local write-back before
+     * interrupting it and returning the verified remote bytes. Defaults to
+     * 60 seconds, matching the default upload deadline.
+     */
+    readonly writeBackTimeout?: Duration.Input | undefined;
+    /**
+     * How eagerly a read materializes a blob into the local tier. Defaults to
+     * the policy the remote tier declares (`RemoteArtifacts.Options.downloadPolicy`),
+     * and to `all` for a remote tier that declares none.
+     *
+     * `all` and `toplevel` both write a fetched blob back into the local tier, so
+     * the second read is local; they differ only in whether
+     * `@smthrs/engine-store`'s `ArtifactSync.hydrate` prefetches. `minimal`
+     * serves the bytes without writing them back, so a host that must not
+     * accumulate other machines' artifacts never does. `minimal` still repairs a
+     * *corrupt* local address, because a rewrite of an address the local tier
+     * already claims is repair rather than growth.
+     *
+     * No policy makes the write-back load-bearing: a local tier that refuses it
+     * costs the next read a network round trip, never this read's answer.
+     */
+    readonly downloadPolicy?: RemoteArtifacts.DownloadPolicy | undefined;
+}
+/**
+ * Composes a local and a remote artifact store.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export declare const make: (options: Options) => Effect.Effect<RemoteArtifacts.Service, ArtifactStore.ArtifactStoreError>;
+/**
+ * The two tiers as effects, plus the options {@link make} takes.
+ *
+ * Both tiers are supplied as *effects* rather than layers because they inhabit
+ * the same tag: composing two `Layer<ArtifactStore>` would just shadow one
+ * with the other. Pair `ArtifactStore.makeFileSystem` (wrapped in
+ * `Effect.sync`) or `Effect.map(FileSystem.FileSystem, ...)` with
+ * `RemoteArtifacts.make`.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export interface LayerOptions<EL, RL, ER, RR> {
+    readonly local: Effect.Effect<ArtifactStore.Service, EL, RL>;
+    readonly remote: Effect.Effect<ArtifactStore.Service, ER, RR>;
+    readonly uploadTimeout?: Duration.Input | undefined;
+    readonly writeBackTimeout?: Duration.Input | undefined;
+    readonly downloadPolicy?: RemoteArtifacts.DownloadPolicy | undefined;
+}
+/**
+ * Provides a local-first artifact store, backed by local and remote effects, as
+ * the `ArtifactStore` tag.
+ *
+ * @category layers
+ * @since 1.0.0-rc.0
+ */
+export declare const layer: <EL, RL, ER, RR>(options: LayerOptions<EL, RL, ER, RR>) => Layer.Layer<ArtifactStore.ArtifactStore, EL | ER | ArtifactStore.ArtifactStoreError, RL | RR>;
+//# sourceMappingURL=CombinedArtifacts.d.ts.map

package/dist/cjs/CombinedArtifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CombinedArtifacts.d.ts","sourceRoot":"","sources":["../../src/CombinedArtifacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAIrC,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAEvD;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAA;IACrC,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAA;IACtC;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAA;IACnD;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAA;IACtD;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,eAAe,CAAC,cAAc,GAAG,SAAS,CAAA;CACrE;AAyBD;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GACf,SAAS,OAAO,KACf,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,aAAa,CAAC,kBAAkB,CAsNtE,CAAA;AAEJ;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,CAAA;IAC5D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,CAAA;IAC7D,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAA;IACnD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAA;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,eAAe,CAAC,cAAc,GAAG,SAAS,CAAA;CACrE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,GAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAClC,SAAS,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,KACpC,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,aAAa,EAAE,EAAE,GAAG,EAAE,GAAG,aAAa,CAAC,kBAAkB,EAAE,EAAE,GAAG,EAAE,CAa5F,CAAA"}