@effected/workspaces 0.5.2 → 0.6.0

package/ConfigDependencyHooks.js

@@ -39,17 +39,45 @@ const seedToConfig = (seed) => {
 	else catalogs[name] = { ...entries };
 	return {
 		catalog,
-		catalogs
+		catalogs,
+		minimumReleaseAge: void 0,
+		minimumReleaseAgeExclude: void 0
 	};
 };
-/** Read the catalog slice back out of whatever a hook returned, falling back to the prior config. */
+/** A finite number if `value` is one, else the prior threaded value — a garbage age is dropped, not fatal. */
+const finiteNumberOr = (value, fallback) => typeof value === "number" && Number.isFinite(value) ? value : fallback;
+/** A string array if `value` is one, else the prior threaded value — a malformed exclude is dropped, not fatal. */
+const stringArrayOr = (value, fallback) => Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : fallback;
+/**
+* Read the catalog slice and the release-age keys back out of whatever a hook
+* returned, threading the prior config as the fallback.
+*
+* @remarks
+* Tolerant by design, matching this seam's discipline: a hook's returned *data*
+* is normalized, never a typed failure (only a load/replay *mechanism* failure
+* raises `CatalogAssemblyError`). A hook that omits a key, or returns a
+* malformed value for it, leaves the prior threaded value in place; a hook that
+* sets a well-formed key rewrites it — so across hooks the **last well-formed
+* write wins**, exactly as pnpm's single mutable config object behaves.
+*/
 const configOf = (value, fallback) => {
 	if (!isObject(value)) return fallback;
 	return {
 		catalog: isObject(value.catalog) ? value.catalog : fallback.catalog,
-		catalogs: isObject(value.catalogs) ? value.catalogs : fallback.catalogs
+		catalogs: isObject(value.catalogs) ? value.catalogs : fallback.catalogs,
+		minimumReleaseAge: finiteNumberOr(value.minimumReleaseAge, fallback.minimumReleaseAge),
+		minimumReleaseAgeExclude: stringArrayOr(value.minimumReleaseAgeExclude, fallback.minimumReleaseAgeExclude)
 	};
 };
+/**
+* Project the threaded config's release-age keys into a partial gate
+* contribution, omitting a key the hooks never set (never an explicit
+* `undefined` — the fields are `optionalKey`).
+*/
+const releaseAgeOf = (config) => ({
+	...config.minimumReleaseAge !== void 0 ? { ageMinutes: config.minimumReleaseAge } : {},
+	...config.minimumReleaseAgeExclude !== void 0 ? { exclude: config.minimumReleaseAgeExclude } : {}
+});
 /** Fold the hook config back into the normalized `catalog name → dependency → range` record. */
 const configToEntries = (config) => {
 	const raw = { ...config.catalogs };
@@ -89,7 +117,10 @@ var ConfigDependencyHooks = class ConfigDependencyHooks extends Context.Service(
 	* config dependency. The default {@link WorkspaceCatalogs} layer wires this, so
 	* the default catalog path provably executes no config-dependency code.
 	*/
-	static layerNoop = Layer.succeed(ConfigDependencyHooks, { inject: (_root, _configDependencies, seed) => Effect.succeed(seed) });
+	static layerNoop = Layer.succeed(ConfigDependencyHooks, { inject: (_root, _configDependencies, seed) => Effect.succeed({
+		catalogs: seed,
+		releaseAge: {}
+	}) });
 	/**
 	* The live layer: dynamically imports each config dependency's `pnpmfile.cjs`
 	* (in process, no subprocess) and replays its `updateConfig` hook over the
@@ -108,7 +139,10 @@ var ConfigDependencyHooks = class ConfigDependencyHooks extends Context.Service(
 	*/
 	static layerLive = Layer.succeed(ConfigDependencyHooks, { inject: (root, configDependencies, seed) => Effect.gen(function* () {
 		const names = Object.keys(configDependencies);
-		if (names.length === 0) return seed;
+		if (names.length === 0) return {
+			catalogs: seed,
+			releaseAge: {}
+		};
 		let config = seedToConfig(seed);
 		for (const name of names) {
 			if (hasTraversalSegment(name)) return yield* Effect.fail(new CatalogAssemblyError({
@@ -149,7 +183,10 @@ var ConfigDependencyHooks = class ConfigDependencyHooks extends Context.Service(
 				})
 			});
 		}
-		return configToEntries(config);
+		return {
+			catalogs: configToEntries(config),
+			releaseAge: releaseAgeOf(config)
+		};
 	}) });
 };
 

package/README.md

@@ -215,7 +215,7 @@ A name miss in the derived `getPackage` fails with the service's own typed `Pack
 - `WorkspacePackage` — a deliberately tolerant manifest model, so one member with an odd version cannot fail discovery for the whole repo. `manifestRecord` keeps the as-read `package.json` for tolerant access to fields outside the typed slice without a second read; `WorkspacePackage.manifest(pkg)` re-reads and is the opt-in bridge to `@effected/package-json`'s strict `Package`.
 - `DependencyGraph` — a value class over discovered packages: `levels()` for parallel build tiers, the flattened topological order, and `CyclicDependencyError` when there isn't one.
 - `PackageManagerDetector` — npm, pnpm, yarn or bun from lockfiles and the `packageManager` field.
-- `WorkspaceCatalogs` — pnpm catalog assembly and `catalog:` resolution, on pnpm's own catalog packages.
+- `WorkspaceCatalogs` — pnpm catalog assembly and `catalog:` resolution, on pnpm's own catalog packages; `releaseAgeGate()` assembles the effective `@effected/npm` `ReleaseAgeGate` from inline `pnpm-workspace.yaml` release-age keys and replayed hook contributions, strictest-wins, in the same pass as the catalogs.
 - `LockfileReader` — locate and parse the workspace's lockfile through `@effected/lockfiles`.
 - `ChangeDetector` — git-range change detection over `@effected/git`'s `Git` service; swap the layer to mock it with no repository.
 - `PublishabilityDetector` — whether a package publishes and to where, as a `PublishTarget` (registry, directory, access, provenance). The default layer implements npm's semantics; swap the layer if yours differ.

package/WorkspaceCatalogs.js

@@ -3,7 +3,7 @@ import { inlineCatalogs, merge, normalize, rangeOf } from "./internal/catalogs.j
 import { ConfigDependencyHooks } from "./ConfigDependencyHooks.js";
 import { LockfileReader } from "./LockfileReader.js";
 import { Context, Duration, Effect, Exit, FileSystem, Layer, Option, Path, PlatformError, Schema } from "effect";
-import { CatalogAssemblyError, CatalogResolver, DependencyResolutionError } from "@effected/npm";
+import { CatalogAssemblyError, CatalogResolver, DependencyResolutionError, PartialReleaseAgeGate, ReleaseAgeGate } from "@effected/npm";
 import { Yaml } from "@effected/yaml";
 
 //#region src/WorkspaceCatalogs.ts
@@ -179,6 +179,37 @@ const configDependenciesOf = (document) => {
 	for (const [name, spec] of Object.entries(document.configDependencies)) if (typeof spec === "string") out[name] = spec;
 	return out;
 };
+/**
+* The inline release-age gate contribution of a parsed `pnpm-workspace.yaml`
+* document — pnpm's top-level `minimumReleaseAge` (minutes) and
+* `minimumReleaseAgeExclude` (name patterns) keys, mapped onto
+* `@effected/npm`'s `PartialReleaseAgeGate` field names
+* (`ageMinutes` / `exclude`).
+*
+* @remarks
+* **Hard-fail by design**, the same posture as the live catalog-block reader:
+* a present-but-malformed value (a non-numeric `minimumReleaseAge`, a
+* `minimumReleaseAgeExclude` that is not a string array) fails typed as a
+* `CatalogAssemblyError` rather than being silently dropped, because a
+* silently-ignored gate is the "install refuses a too-young version the
+* resolver already picked" bug this vocabulary exists to prevent. An absent or
+* explicitly `null` key contributes nothing; the permissive
+* `PartialReleaseAgeGate` accepts any finite `ageMinutes` (negatives and
+* fractions included) — `ReleaseAgeGate.combine` is the single clamping
+* authority, exactly as on the hook path.
+*/
+const inlineReleaseAge = (document) => {
+	if (!isObject(document)) return Effect.succeed({});
+	const raw = {};
+	if (document.minimumReleaseAge !== void 0 && document.minimumReleaseAge !== null) raw.ageMinutes = document.minimumReleaseAge;
+	if (document.minimumReleaseAgeExclude !== void 0 && document.minimumReleaseAgeExclude !== null) raw.exclude = document.minimumReleaseAgeExclude;
+	if (Object.keys(raw).length === 0) return Effect.succeed({});
+	return Schema.decodeUnknownEffect(PartialReleaseAgeGate)(raw).pipe(Effect.catchTag("SchemaError", (cause) => new CatalogAssemblyError({
+		source: "manifest",
+		path: "pnpm-workspace.yaml",
+		cause
+	})));
+};
 /** A hard-fail catalog-assembly failure naming the malformed part of a `workspaces` field. */
 const malformed = (source, path, detail) => new CatalogAssemblyError({
 	source,
@@ -299,6 +330,8 @@ var WorkspaceCatalogs = class WorkspaceCatalogs extends Context.Service()("@effe
 			const hasPnpmWorkspace = yield* probeExists(workspaceYaml);
 			let inline;
 			let injected;
+			let inlineGate = {};
+			let hookGate = {};
 			if (hasPnpmWorkspace) {
 				const text = yield* fs.readFileString(workspaceYaml).pipe(Effect.mapError((cause) => new CatalogAssemblyError({
 					source: "manifest",
@@ -312,11 +345,16 @@ var WorkspaceCatalogs = class WorkspaceCatalogs extends Context.Service()("@effe
 				})));
 				yield* validatePnpmWorkspaceCatalogs(document);
 				inline = CatalogSet.fromCatalogs(inlineCatalogs(catalogBlocksOf(document)));
-				const injectedEntries = yield* hooks.inject(root, configDependenciesOf(document), inline.entries);
-				injected = CatalogSet.fromCatalogs(injectedEntries);
+				inlineGate = yield* inlineReleaseAge(document);
+				const injection = yield* hooks.inject(root, configDependenciesOf(document), inline.entries);
+				injected = CatalogSet.fromCatalogs(injection.catalogs);
+				hookGate = injection.releaseAge;
 			} else {
 				const manifestPath = path.join(root, "package.json");
-				if (!(yield* probeExists(manifestPath))) return fromLockfile;
+				if (!(yield* probeExists(manifestPath))) return {
+					catalogs: fromLockfile,
+					releaseAgeGate: ReleaseAgeGate.combine()
+				};
 				const text = yield* fs.readFileString(manifestPath).pipe(Effect.mapError((cause) => new CatalogAssemblyError({
 					source: "manifest",
 					path: manifestPath,
@@ -326,20 +364,28 @@ var WorkspaceCatalogs = class WorkspaceCatalogs extends Context.Service()("@effe
 				injected = CatalogSet.empty();
 			}
 			const assembled = CatalogSet.merge(fromLockfile, inline, injected);
+			const releaseAgeGate = ReleaseAgeGate.combine(inlineGate, hookGate);
 			yield* Effect.logDebug("Catalogs assembled").pipe(Effect.annotateLogs({
 				"workspace.root": root,
-				"workspace.catalogs": Object.keys(assembled.entries).join(",")
+				"workspace.catalogs": Object.keys(assembled.entries).join(","),
+				"workspace.releaseAgeMinutes": releaseAgeGate.ageMinutes
 			}));
-			return assembled;
+			return {
+				catalogs: assembled,
+				releaseAgeGate
+			};
 		});
 		const [resolveOnce, invalidate] = yield* Effect.cachedInvalidateWithTTL(assemble, Duration.infinity);
 		const memo = Effect.onExit(resolveOnce, (exit) => Exit.isSuccess(exit) ? Effect.void : invalidate);
 		return {
 			set: Effect.fn("WorkspaceCatalogs.set")(function* () {
-				return yield* memo;
+				return (yield* memo).catalogs;
 			}),
 			resolveSpecifier: Effect.fn("WorkspaceCatalogs.resolveSpecifier")(function* (dependency, specifier) {
-				return (yield* memo).resolveSpecifier(dependency, specifier);
+				return (yield* memo).catalogs.resolveSpecifier(dependency, specifier);
+			}),
+			releaseAgeGate: Effect.fn("WorkspaceCatalogs.releaseAgeGate")(function* () {
+				return (yield* memo).releaseAgeGate;
 			})
 		};
 	});

package/index.d.ts

@@ -1,6 +1,6 @@
 import { Git, GitCommandError, NotARepositoryError, UnknownRefError } from "@effected/git";
 import { Context, Effect, FileSystem, Layer, Option, Path, Schema } from "effect";
-import { CatalogAssemblyError, CatalogResolver, DependencyResolutionError, Manifest, UnresolvedDependencyError, WorkspaceResolver } from "@effected/npm";
+import { CatalogAssemblyError, CatalogResolver, DependencyResolutionError, Manifest, PartialReleaseAgeGate, ReleaseAgeGate, UnresolvedDependencyError, WorkspaceResolver } from "@effected/npm";
 import { GlobPattern } from "@effected/glob";
 import { Lockfile, LockfileFramingError, LockfileIntegrity, LockfileParseError, ResolvedPackage, WorkspaceManifest } from "@effected/lockfiles";
 import { Package } from "@effected/package-json";
@@ -793,22 +793,56 @@ declare class ChangeDetector extends ChangeDetector_base {
 }
 //#endregion
 //#region src/ConfigDependencyHooks.d.ts
+/**
+ * The result of replaying a workspace's `configDependencies` hooks: the catalogs
+ * the hooks yield, and the release-age gate contribution they leave on the
+ * config (pnpm's `minimumReleaseAge` / `minimumReleaseAgeExclude`).
+ *
+ * @remarks
+ * `releaseAge` is a `PartialReleaseAgeGate` — the age, the exclude list,
+ * both, or neither, depending on what the replayed hooks set. It is deliberately
+ * a *partial* contribution: a consumer folds it into an effective gate with
+ * `ReleaseAgeGate.combine` alongside inline `pnpm-workspace.yaml` values. Hooks
+ * that set no release-age keys contribute an empty gate (`{}`).
+ *
+ * @public
+ */
+interface HookInjection {
+  /** The catalogs the replayed hooks yield, as `catalog name → dependency → range`. */
+  readonly catalogs: Readonly<Record<string, Readonly<Record<string, string>>>>;
+  /** The release-age gate contribution the replayed hooks leave on the config. */
+  readonly releaseAge: PartialReleaseAgeGate;
+}
 /**
  * The {@link ConfigDependencyHooks} service shape.
  *
  * @remarks
  * `inject` is given the workspace root, the manifest's `configDependencies`
  * (name → version+integrity), and the inline-catalog seed as a plain
- * `catalog name → dependency name → range` record, and produces the catalogs the
- * replayed hooks yield. The default (no-op) implementation returns the seed
- * unchanged and loads nothing.
+ * `catalog name → dependency name → range` record, and produces a
+ * {@link HookInjection}: the catalogs the replayed hooks yield **and** the
+ * release-age gate contribution they leave on the config. The default (no-op)
+ * implementation returns the seed catalogs unchanged, contributes an empty
+ * release-age gate, and loads nothing.
  *
  * @public
  */
 interface ConfigDependencyHooksShape {
   /**
    * Replay each config dependency's `updateConfig` hook over `seed`, in
-   * declaration order, and return the resulting catalogs.
+   * declaration order, and return both the resulting catalogs and the
+   * release-age gate contribution the hooks leave behind.
+   *
+   * @remarks
+   * The hooks are replayed once over a single threaded config object, exactly
+   * as pnpm does — so catalogs and the release-age keys
+   * (`minimumReleaseAge` / `minimumReleaseAgeExclude`) are both read off that
+   * one final object, and the config-dependency code executes only once. When
+   * two hooks both set a release-age key the **later hook wins** (it rewrites
+   * the threaded value); a hook that returns a malformed value for a key leaves
+   * the prior threaded value in place (tolerant threading, matching the catalog
+   * slice). A hook failing to load or replay fails typed with a
+   * `hooks`-source `CatalogAssemblyError`, never a silent skip.
    *
    * @param root - The workspace root; config dependencies resolve under
    *   `<root>/node_modules/.pnpm-config/<name>`.
@@ -816,7 +850,7 @@ interface ConfigDependencyHooksShape {
    *   version+integrity) declared in `pnpm-workspace.yaml`.
    * @param seed - The inline catalogs, as `catalog name → dependency → range`.
    */
-  readonly inject: (root: string, configDependencies: Readonly<Record<string, string>>, seed: Readonly<Record<string, Readonly<Record<string, string>>>>) => Effect.Effect<Readonly<Record<string, Readonly<Record<string, string>>>>, CatalogAssemblyError>;
+  readonly inject: (root: string, configDependencies: Readonly<Record<string, string>>, seed: Readonly<Record<string, Readonly<Record<string, string>>>>) => Effect.Effect<HookInjection, CatalogAssemblyError>;
 }
 declare const ConfigDependencyHooks_base: Context.ServiceClass<ConfigDependencyHooks, "@effected/workspaces/ConfigDependencyHooks", ConfigDependencyHooksShape>;
 /**
@@ -1407,6 +1441,20 @@ interface WorkspaceCatalogsShape {
   readonly set: () => Effect.Effect<CatalogSet, CatalogAssemblyFailure>;
   /** Resolve one `catalog:` specifier; `Option.none()` when it names nothing. */
   readonly resolveSpecifier: (dependency: string, specifier: string) => Effect.Effect<Option.Option<string>, CatalogAssemblyFailure>;
+  /**
+   * The effective pnpm release-age gate for the workspace, combined
+   * strictest-wins from the inline `pnpm-workspace.yaml` keys
+   * (`minimumReleaseAge` / `minimumReleaseAgeExclude`) and the replayed
+   * config-dependency hooks. Assembled from the same single read and hook
+   * replay as `set`, and memoized with it.
+   *
+   * @remarks
+   * Under the default layer (no-op hooks) only inline values contribute; under
+   * {@link WorkspaceCatalogs.layerWithConfigDependencies} the replayed hooks
+   * contribute too. A workspace with no pnpm-workspace.yaml (a bun/npm
+   * workspace) has no release-age keys, so the gate is the inert zero gate.
+   */
+  readonly releaseAgeGate: () => Effect.Effect<ReleaseAgeGate, CatalogAssemblyFailure>;
 }
 /**
  * Options for the {@link WorkspaceCatalogs} layer.
@@ -1931,5 +1979,5 @@ interface GetWorkspacePackagesSyncOptions extends WorkspacesSyncOptions {
  */
 declare const getWorkspacePackagesSync: (root: string, options: GetWorkspacePackagesSyncOptions) => ReadonlyArray<WorkspacePackage>;
 //#endregion
-export { type CatalogAssemblyFailure, CatalogSet, ChangeDetectionError, type ChangeDetectionFailure, ChangeDetectionOptions, ChangeDetector, type ChangeDetectorShape, ConfigDependencyHooks, type ConfigDependencyHooksShape, CyclicDependencyError, type DependencyDiff, DependencyGraph, DetectedPackageManager, type FindWorkspaceRootOptions, type GetWorkspacePackagesSyncOptions, LockfileReadError, type LockfileReadFailure, LockfileReader, type LockfileReaderOptions, type LockfileReaderShape, PackageManagerDetectionError, type PackageManagerDetectionFailure, PackageManagerDetector, PackageManagerName, PackageNotFoundError, PackageStateSnapshot, PublishConfig, PublishTarget, PublishabilityDetector, type PublishabilityDetectorShape, type SyncFileSystem, type SyncPath, WORKSPACE_MARKERS, WorkspaceCatalogs, type WorkspaceCatalogsOptions, type WorkspaceCatalogsShape, WorkspaceDiscovery, WorkspaceDiscoveryError, type WorkspaceDiscoveryFailure, type WorkspaceDiscoveryOptions, type WorkspaceDiscoveryShape, WorkspaceInfo, type WorkspaceLookupFailure, WorkspaceManifestError, WorkspacePackage, WorkspacePatternError, WorkspaceRoot, WorkspaceRootNotFoundError, type WorkspaceRootShape, type WorkspaceSnapshotAtFailure, type WorkspaceSnapshotWorktreeFailure, WorkspaceSnapshots, type WorkspaceSnapshotsOptions, type WorkspaceSnapshotsShape, WorkspaceStateSnapshot, Workspaces, type WorkspacesOptions, type WorkspacesServices, type WorkspacesSyncOptions, findWorkspaceRootSync, getWorkspacePackagesSync };
+export { type CatalogAssemblyFailure, CatalogSet, ChangeDetectionError, type ChangeDetectionFailure, ChangeDetectionOptions, ChangeDetector, type ChangeDetectorShape, ConfigDependencyHooks, type ConfigDependencyHooksShape, CyclicDependencyError, type DependencyDiff, DependencyGraph, DetectedPackageManager, type FindWorkspaceRootOptions, type GetWorkspacePackagesSyncOptions, type HookInjection, LockfileReadError, type LockfileReadFailure, LockfileReader, type LockfileReaderOptions, type LockfileReaderShape, PackageManagerDetectionError, type PackageManagerDetectionFailure, PackageManagerDetector, PackageManagerName, PackageNotFoundError, PackageStateSnapshot, PublishConfig, PublishTarget, PublishabilityDetector, type PublishabilityDetectorShape, type SyncFileSystem, type SyncPath, WORKSPACE_MARKERS, WorkspaceCatalogs, type WorkspaceCatalogsOptions, type WorkspaceCatalogsShape, WorkspaceDiscovery, WorkspaceDiscoveryError, type WorkspaceDiscoveryFailure, type WorkspaceDiscoveryOptions, type WorkspaceDiscoveryShape, WorkspaceInfo, type WorkspaceLookupFailure, WorkspaceManifestError, WorkspacePackage, WorkspacePatternError, WorkspaceRoot, WorkspaceRootNotFoundError, type WorkspaceRootShape, type WorkspaceSnapshotAtFailure, type WorkspaceSnapshotWorktreeFailure, WorkspaceSnapshots, type WorkspaceSnapshotsOptions, type WorkspaceSnapshotsShape, WorkspaceStateSnapshot, Workspaces, type WorkspacesOptions, type WorkspacesServices, type WorkspacesSyncOptions, findWorkspaceRootSync, getWorkspacePackagesSync };
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/workspaces",
-	"version": "0.5.2",
+	"version": "0.6.0",
 	"private": false,
 	"description": "Monorepo workspace tooling as Effect services — root discovery, package enumeration, the dependency graph, package-manager detection, pnpm catalog resolution, lockfile IO and git-based change detection.",
 	"keywords": [
@@ -48,9 +48,9 @@
 	"dependencies": {
 		"@effected/git": "~0.4.1",
 		"@effected/glob": "~0.2.0",
-		"@effected/lockfiles": "~0.1.8",
-		"@effected/npm": "~0.2.3",
-		"@effected/package-json": "~0.4.1",
+		"@effected/lockfiles": "~0.1.9",
+		"@effected/npm": "~0.3.0",
+		"@effected/package-json": "~0.4.2",
 		"@effected/semver": "~0.2.0",
 		"@effected/walker": "~0.3.1",
 		"@effected/yaml": "~0.5.0",