@savvy-web/silk-effects 0.3.0 → 0.4.0

package/index.js

@@ -1,7 +1,8 @@
 import { Context, Data, Effect, Equal, Function, Hash, Layer, Option, Pretty, Ref, Schema } from "effect";
 import { Command, CommandExecutor, FileSystem } from "@effect/platform";
-import { PackageManagerDetector, PublishConfig, TopologicalSorter, WorkspaceDiscovery, WorkspaceRoot } from "workspaces-effect";
+import { PackageManagerDetector, PublishConfig, PublishTarget, PublishabilityDetector, PublishabilityDetectorLive, TopologicalSorter, WorkspaceDiscovery, WorkspaceRoot } from "workspaces-effect";
 import { parse } from "jsonc-effect";
+import { isAbsolute, join } from "node:path";
 class BiomeSyncError extends Data.TaggedError("BiomeSyncError") {
     get message() {
         return `Failed to sync biome schema in ${this.path}: ${this.reason}`;
@@ -17,11 +18,6 @@ class ConfigNotFoundError extends Data.TaggedError("ConfigNotFoundError") {
         return `Config '${this.name}' not found. Searched: ${this.searchedPaths.join(", ")}`;
     }
 }
-class PublishConfigError extends Data.TaggedError("PublishConfigError") {
-    get message() {
-        return `Invalid publishConfig for ${this.packageName}: ${this.reason}`;
-    }
-}
 class SectionParseError extends Data.TaggedError("SectionParseError") {
     get message() {
         return `Failed to parse section in ${this.path}: ${this.reason}`;
@@ -42,11 +38,6 @@ class TagFormatError extends Data.TaggedError("TagFormatError") {
         return `Failed to format tag for ${this.name}@${this.version}: ${this.reason}`;
     }
 }
-class TargetResolutionError extends Data.TaggedError("TargetResolutionError") {
-    get message() {
-        return `Failed to resolve publish target: ${this.reason}`;
-    }
-}
 class ToolNotFoundError extends Data.TaggedError("ToolNotFoundError") {
     get message() {
         return `Tool not found: ${this.name} — ${this.reason}`;
@@ -72,30 +63,6 @@ class WorkspaceAnalysisError extends Data.TaggedError("WorkspaceAnalysisError")
         return `Workspace analysis failed at ${this.root}: ${this.reason}`;
     }
 }
-const PublishProtocol = Schema.Literal("npm", "jsr");
-const AuthStrategy = Schema.Literal("oidc", "token");
-const PublishTargetObject = Schema.Struct({
-    protocol: Schema.optionalWith(PublishProtocol, {
-        default: ()=>"npm"
-    }),
-    registry: Schema.optional(Schema.String),
-    directory: Schema.optional(Schema.String),
-    access: Schema.optional(Schema.Literal("public", "restricted")),
-    provenance: Schema.optional(Schema.Boolean),
-    tag: Schema.optional(Schema.String)
-});
-const PublishTargetShorthand = Schema.Literal("npm", "github", "jsr");
-const PublishTarget = Schema.Union(PublishTargetShorthand, Schema.String.pipe(Schema.filter((s)=>s.startsWith("https://"))), PublishTargetObject);
-const ResolvedTarget = Schema.Struct({
-    protocol: PublishProtocol,
-    registry: Schema.NullOr(Schema.String),
-    directory: Schema.String,
-    access: Schema.Literal("public", "restricted"),
-    provenance: Schema.Boolean,
-    tag: Schema.String,
-    auth: AuthStrategy,
-    tokenEnv: Schema.NullOr(Schema.String)
-});
 class ToolCommand {
     command;
     constructor(command){
@@ -457,7 +424,7 @@ const SnapshotConfig = Schema.Struct({
     useCalculatedVersion: Schema.optional(Schema.Boolean),
     prereleaseTemplate: Schema.optional(Schema.String)
 });
-const ChangesetConfig = Schema.Struct({
+const ChangesetConfigFile = Schema.Struct({
     changelog: Schema.optional(Schema.Union(Schema.String, Schema.Array(Schema.Unknown), Schema.Literal(false))),
     commit: Schema.optional(Schema.Union(Schema.Boolean, Schema.String, Schema.Array(Schema.Unknown))),
     fixed: Schema.optional(Schema.Array(Schema.Array(Schema.String))),
@@ -472,7 +439,7 @@ const ChangesetConfig = Schema.Struct({
     bumpVersionsWithWorkspaceProtocolOnly: Schema.optional(Schema.Boolean),
     snapshot: Schema.optional(SnapshotConfig)
 });
-const SilkChangesetConfig = Schema.extend(ChangesetConfig, Schema.Struct({
+const SilkChangesetConfigFile = Schema.extend(ChangesetConfigFile, Schema.Struct({
     _isSilk: Schema.optionalWith(Schema.Boolean, {
         default: ()=>true
     })
@@ -501,13 +468,26 @@ function WorkspaceAnalysisSchemas_type_of(obj) {
     return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
 let WorkspaceAnalysisSchemas_computedKey, WorkspaceAnalysisSchemas_computedKey1, _computedKey2, _computedKey3;
+const PublishProtocol = Schema.Literal("npm", "jsr");
+const PublishTargetShorthand = Schema.Literal("npm", "github", "jsr");
+const PublishTargetObject = Schema.Struct({
+    protocol: Schema.optionalWith(PublishProtocol, {
+        default: ()=>"npm"
+    }),
+    registry: Schema.optional(Schema.String),
+    directory: Schema.optional(Schema.String),
+    access: Schema.optional(Schema.Literal("public", "restricted")),
+    provenance: Schema.optional(Schema.Boolean),
+    tag: Schema.optional(Schema.String)
+});
 class SilkPublishConfig extends PublishConfig.extend("SilkPublishConfig")({
     targets: Schema.optional(Schema.Array(Schema.Union(PublishTargetShorthand, PublishTargetObject)))
 }) {
 }
 const KNOWN_REGISTRIES = {
     npm: "https://registry.npmjs.org/",
-    github: "https://npm.pkg.github.com/"
+    github: "https://npm.pkg.github.com/",
+    jsr: "https://jsr.io/"
 };
 const WorkspaceVersion = Schema.Struct({
     current: Schema.String
@@ -520,7 +500,7 @@ class AnalyzedWorkspace extends Schema.TaggedClass()("AnalyzedWorkspace", {
     root: Schema.Boolean,
     publishConfig: Schema.NullOr(SilkPublishConfig),
     publishable: Schema.Boolean,
-    targets: Schema.Array(ResolvedTarget),
+    targets: Schema.Array(PublishTarget),
     versioned: Schema.Boolean,
     tagged: Schema.Boolean,
     released: Schema.Boolean,
@@ -546,7 +526,6 @@ class AnalyzedWorkspace extends Schema.TaggedClass()("AnalyzedWorkspace", {
         return this.targets.some((t)=>t.registry === registry);
     }
     hasTarget(shorthand) {
-        if ("jsr" === shorthand) return this.targets.some((t)=>"jsr" === t.protocol);
         const registry = KNOWN_REGISTRIES[shorthand];
         return void 0 !== registry && this.publishesTo(registry);
     }
@@ -602,7 +581,7 @@ class WorkspaceAnalysis extends Schema.TaggedClass()("WorkspaceAnalysis", {
     runtime: Schema.Literal("node", "bun"),
     packageManager: PackageManagerInfo,
     workspaces: Schema.Array(AnalyzedWorkspace),
-    changesetConfig: Schema.NullOr(Schema.Union(SilkChangesetConfig, ChangesetConfig)),
+    changesetConfig: Schema.NullOr(Schema.Union(SilkChangesetConfigFile, ChangesetConfigFile)),
     versioning: Schema.NullOr(VersioningStrategyResult),
     tagStrategy: Schema.NullOr(TagStrategyType)
 }) {
@@ -754,11 +733,11 @@ const ChangesetConfigReaderLive = Layer.effect(ChangesetConfigReader, Effect.gen
                     })
             });
             const rawConfig = parsed;
-            if (isSilkChangelog(rawConfig.changelog)) return yield* Schema.decodeUnknown(SilkChangesetConfig)(parsed).pipe(Effect.mapError((cause)=>new ChangesetConfigError({
+            if (isSilkChangelog(rawConfig.changelog)) return yield* Schema.decodeUnknown(SilkChangesetConfigFile)(parsed).pipe(Effect.mapError((cause)=>new ChangesetConfigError({
                     path: configPath,
                     reason: `Schema decode failed: ${String(cause)}`
                 })));
-            return yield* Schema.decodeUnknown(ChangesetConfig)(parsed).pipe(Effect.mapError((cause)=>new ChangesetConfigError({
+            return yield* Schema.decodeUnknown(ChangesetConfigFile)(parsed).pipe(Effect.mapError((cause)=>new ChangesetConfigError({
                     path: configPath,
                     reason: `Schema decode failed: ${String(cause)}`
                 })));
@@ -768,6 +747,52 @@ const ChangesetConfigReaderLive = Layer.effect(ChangesetConfigReader, Effect.gen
         read
     };
 }));
+class ChangesetConfig extends Context.Tag("@savvy-web/silk-effects/ChangesetConfig")() {
+    static matches(name, pattern) {
+        if (pattern.endsWith("/*")) {
+            const prefix = pattern.slice(0, -1);
+            return name.startsWith(prefix);
+        }
+        return name === pattern;
+    }
+}
+const isSilk = (cfg)=>"_isSilk" in cfg && true === cfg._isSilk;
+const ChangesetConfigLive = Layer.effect(ChangesetConfig, Effect.gen(function*() {
+    const reader = yield* ChangesetConfigReader;
+    const cache = new Map();
+    const read = (root)=>Effect.gen(function*() {
+            const hit = cache.get(root);
+            if (void 0 !== hit) return hit;
+            const result = yield* reader.read(root).pipe(Effect.option);
+            cache.set(root, result);
+            return result;
+        });
+    return {
+        mode: (root)=>read(root).pipe(Effect.map(Option.match({
+                onNone: ()=>"none",
+                onSome: (cfg)=>isSilk(cfg) ? "silk" : "vanilla"
+            }))),
+        versionPrivate: (root)=>read(root).pipe(Effect.map(Option.match({
+                onNone: ()=>false,
+                onSome: (cfg)=>{
+                    const pp = cfg.privatePackages;
+                    return void 0 !== pp && false !== pp && true === pp.version;
+                }
+            }))),
+        ignorePatterns: (root)=>read(root).pipe(Effect.map(Option.match({
+                onNone: ()=>[],
+                onSome: (cfg)=>cfg.ignore ?? []
+            }))),
+        isIgnored: (name, root)=>read(root).pipe(Effect.map(Option.match({
+                onNone: ()=>false,
+                onSome: (cfg)=>(cfg.ignore ?? []).some((p)=>ChangesetConfig.matches(name, p))
+            }))),
+        fixed: (root)=>read(root).pipe(Effect.map(Option.match({
+                onNone: ()=>[],
+                onSome: (cfg)=>cfg.fixed ?? []
+            })))
+    };
+}));
 class ConfigDiscovery extends Context.Tag("@savvy-web/silk-effects/ConfigDiscovery")() {
 }
 function safeExists(fs, path) {
@@ -919,116 +944,120 @@ const ManagedSectionLive = Layer.effect(ManagedSection, Effect.gen(function*() {
         check
     };
 }));
-class TargetResolver extends Context.Tag("@savvy-web/silk-effects/TargetResolver")() {
-}
-const DEFAULTS = {
-    directory: "dist/npm",
-    access: "public",
-    provenance: false,
-    tag: "latest"
-};
-function deriveTokenEnv(registryUrl) {
-    try {
-        const hostname = new URL(registryUrl).hostname;
-        return `NPM_TOKEN_${hostname.replace(/\./g, "_").toUpperCase()}`;
-    } catch  {
-        return "NPM_TOKEN";
-    }
-}
-function resolveOne(target) {
-    if ("npm" === target) return Effect.succeed({
-        ...DEFAULTS,
-        protocol: "npm",
-        registry: "https://registry.npmjs.org/",
-        auth: "oidc",
-        tokenEnv: null
-    });
-    if ("github" === target) return Effect.succeed({
-        ...DEFAULTS,
-        protocol: "npm",
-        registry: "https://npm.pkg.github.com/",
-        auth: "token",
-        tokenEnv: "GITHUB_TOKEN"
-    });
-    if ("jsr" === target) return Effect.succeed({
-        ...DEFAULTS,
-        protocol: "jsr",
-        registry: null,
-        auth: "oidc",
-        tokenEnv: null
-    });
-    if ("string" == typeof target && target.startsWith("https://")) return Effect.succeed({
-        ...DEFAULTS,
-        protocol: "npm",
-        registry: target,
-        auth: "token",
-        tokenEnv: deriveTokenEnv(target)
-    });
-    if ("object" == typeof target && null !== target && !Array.isArray(target)) {
-        const obj = target;
-        const protocol = obj.protocol ?? "npm";
-        const registry = obj.registry ?? null;
-        const directory = obj.directory ?? DEFAULTS.directory;
-        const access = obj.access ?? DEFAULTS.access;
-        const provenance = obj.provenance ?? DEFAULTS.provenance;
-        const tag = obj.tag ?? DEFAULTS.tag;
-        let auth;
-        let tokenEnv;
-        if (null !== registry) try {
-            const hostname = new URL(registry).hostname;
-            if ("npm.pkg.github.com" === hostname) {
-                auth = "token";
-                tokenEnv = "GITHUB_TOKEN";
-            } else {
-                auth = "oidc";
-                tokenEnv = null;
+const NPM_DEFAULT = "https://registry.npmjs.org/";
+class SilkPublishability {
+    static resolveTargetAccess(target, parentAccess) {
+        if ("string" == typeof target) return parentAccess;
+        return target.access ?? parentAccess;
+    }
+    static expandShorthand(target, parentRegistry) {
+        if ("npm" === target) return NPM_DEFAULT;
+        if ("github" === target) return "https://npm.pkg.github.com/";
+        if ("jsr" === target) return "https://jsr.io/";
+        if (target.startsWith("https://") || target.startsWith("http://")) return target;
+        return parentRegistry ?? NPM_DEFAULT;
+    }
+    static detect(pkgName, raw) {
+        const pc = raw.publishConfig;
+        if (pc?.targets && pc.targets.length > 0) {
+            const results = [];
+            for (const target of pc.targets){
+                const access = SilkPublishability.resolveTargetAccess(target, pc.access);
+                if ("public" !== access && "restricted" !== access) continue;
+                const registry = "string" == typeof target ? SilkPublishability.expandShorthand(target, pc.registry) : target.registry ?? pc.registry ?? NPM_DEFAULT;
+                const directory = "string" == typeof target ? pc.directory ?? "." : target.directory ?? pc.directory ?? ".";
+                const provenance = "string" == typeof target ? void 0 : target.provenance;
+                results.push(new PublishTarget({
+                    name: pkgName,
+                    registry,
+                    directory,
+                    access,
+                    ...void 0 !== provenance ? {
+                        provenance
+                    } : {}
+                }));
             }
-        } catch  {
-            auth = "oidc";
-            tokenEnv = null;
-        }
-        else {
-            auth = "oidc";
-            tokenEnv = null;
+            return results;
         }
-        return Effect.succeed({
-            protocol,
-            registry,
-            directory,
-            access,
-            provenance,
-            tag,
-            auth,
-            tokenEnv
+        if (pc && ("public" === pc.access || "restricted" === pc.access)) return [
+            new PublishTarget({
+                name: pkgName,
+                registry: pc.registry ?? NPM_DEFAULT,
+                directory: pc.directory ?? ".",
+                access: pc.access
+            })
+        ];
+        if (true !== raw.private) return [
+            new PublishTarget({
+                name: pkgName,
+                registry: pc?.registry ?? NPM_DEFAULT,
+                directory: pc?.directory ?? ".",
+                access: pc?.access ?? "public"
+            })
+        ];
+        return [];
+    }
+    static resolveTargets(pkg, root) {
+        return Effect.gen(function*() {
+            const detector = yield* PublishabilityDetector;
+            const fs = yield* FileSystem.FileSystem;
+            const targets = yield* detector.detect(pkg, root);
+            const kept = [];
+            for (const t of targets){
+                const dir = isAbsolute(t.directory) ? t.directory : join(pkg.path, t.directory);
+                if (!(yield* isTargetPrivate(fs, dir))) kept.push(t);
+            }
+            return kept;
         });
     }
-    return Effect.fail(new TargetResolutionError({
-        target,
-        reason: `Unsupported target type: ${typeof target}. Expected "npm", "github", "jsr", an https:// URL, or an object.`
-    }));
-}
-const TargetResolverLive = Layer.succeed(TargetResolver, {
-    resolve: (target)=>{
-        if (Array.isArray(target)) return Effect.all(target.map(resolveOne));
-        return resolveOne(target).pipe(Effect.map((resolved)=>[
-                resolved
-            ]));
+    static listPublishable(root) {
+        return Effect.gen(function*() {
+            const discovery = yield* WorkspaceDiscovery;
+            const detector = yield* PublishabilityDetector;
+            const packages = yield* discovery.listPackages().pipe(Effect.orDie);
+            const out = [];
+            for (const pkg of packages){
+                const targets = yield* detector.detect(pkg, root);
+                if (targets.length > 0) out.push({
+                    name: pkg.name,
+                    version: pkg.version,
+                    path: pkg.path,
+                    targetCount: targets.length
+                });
+            }
+            return out;
+        });
     }
-});
-class SilkPublishabilityPlugin extends Context.Tag("@savvy-web/silk-effects/SilkPublishabilityPlugin")() {
 }
-const SilkPublishabilityPluginLive = Layer.effect(SilkPublishabilityPlugin, Effect.gen(function*() {
-    const resolver = yield* TargetResolver;
+const isTargetPrivate = (fs, targetDir)=>fs.readFileString(join(targetDir, "package.json")).pipe(Effect.flatMap((content)=>Effect["try"]({
+            try: ()=>true === JSON.parse(content).private,
+            catch: ()=>new Error("invalid package.json")
+        })), Effect.orElseSucceed(()=>false));
+const readRaw = (fs, packageJsonPath)=>fs.readFileString(packageJsonPath).pipe(Effect.flatMap((content)=>Effect["try"]({
+            try: ()=>JSON.parse(content),
+            catch: ()=>new Error("invalid package.json")
+        })), Effect.orElseSucceed(()=>null));
+const SilkPublishabilityDetectorLive = Layer.effect(PublishabilityDetector, Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
     return {
-        detect: (pkgJson)=>{
-            const isPrivate = true === pkgJson.private;
-            const publishConfig = pkgJson.publishConfig;
-            if (isPrivate && !publishConfig) return Effect.succeed([]);
-            if (!publishConfig || !publishConfig.access && !publishConfig.targets) return Effect.succeed([]);
-            if (Array.isArray(publishConfig.targets)) return resolver.resolve(publishConfig.targets);
-            if (publishConfig.registry) return resolver.resolve(publishConfig.registry);
-            return resolver.resolve("npm");
-        }
+        detect: (pkg, _root)=>readRaw(fs, pkg.packageJsonPath).pipe(Effect.map((raw)=>raw ? SilkPublishability.detect(pkg.name, raw) : []))
+    };
+}));
+const PublishabilityDetectorAdaptiveLive = Layer.effect(PublishabilityDetector, Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
+    const config = yield* ChangesetConfig;
+    const vanilla = yield* Effect.provide(PublishabilityDetector, PublishabilityDetectorLive);
+    return {
+        detect: (pkg, root)=>Effect.gen(function*() {
+                if (yield* config.isIgnored(pkg.name, root)) return [];
+                const mode = yield* config.mode(root);
+                if ("none" === mode) return [];
+                if ("silk" === mode) {
+                    const raw = yield* readRaw(fs, pkg.packageJsonPath);
+                    return raw ? SilkPublishability.detect(pkg.name, raw) : [];
+                }
+                return yield* vanilla.detect(pkg, root);
+            })
     };
 }));
 class TagStrategy extends Context.Tag("@savvy-web/silk-effects/TagStrategy")() {
@@ -1101,7 +1130,7 @@ function computeReleaseStatus(pkgName, isPrivate, isPublishable, config) {
         tagged: false,
         released: false
     };
-    if (config.ignore?.includes(pkgName)) return {
+    if ((config.ignore ?? []).some((p)=>ChangesetConfig.matches(pkgName, p))) return {
         versioned: false,
         tagged: false,
         released: false
@@ -1136,7 +1165,6 @@ const SilkWorkspaceAnalyzerLive = Layer.effect(SilkWorkspaceAnalyzer, Effect.gen
     const discovery = yield* WorkspaceDiscovery;
     const sorter = yield* TopologicalSorter;
     const pmDetector = yield* PackageManagerDetector;
-    const publishability = yield* SilkPublishabilityPlugin;
     const configReader = yield* ChangesetConfigReader;
     const versioningStrategy = yield* VersioningStrategy;
     const tagStrategy = yield* TagStrategy;
@@ -1168,10 +1196,7 @@ const SilkWorkspaceAnalyzerLive = Layer.effect(SilkWorkspaceAnalyzer, Effect.gen
             const analyzedWorkspaces = [];
             for (const pkg of sortedPackages){
                 const pkgJson = yield* readRawPkgJson(fs, pkg.packageJsonPath);
-                const targets = yield* publishability.detect(pkgJson).pipe(Effect.mapError((err)=>new WorkspaceAnalysisError({
-                        root,
-                        reason: `Publishability detection failed for ${pkg.name}: ${String(err)}`
-                    })));
+                const targets = SilkPublishability.detect(pkg.name, pkgJson);
                 const isPublishable = targets.length > 0;
                 const isRoot = "." === pkg.relativePath;
                 const { versioned, tagged, released } = computeReleaseStatus(pkg.name, pkg.private, isPublishable, changesetConfig);
@@ -1429,4 +1454,4 @@ const ToolDiscoveryLive = Layer.effect(ToolDiscovery, Effect.gen(function*() {
         clearCache
     };
 }));
-export { AnalyzedWorkspace, BiomeSchemaSync, BiomeSchemaSyncLive, BiomeSyncError, ChangesetConfigError, ChangesetConfigReader, ChangesetConfigReaderLive, CheckResult, ConfigDiscovery, ConfigDiscoveryLive, ConfigNotFoundError, ManagedSection, ManagedSectionLive, PublishConfigError, PublishTarget as PublishTargetSchema, PublishTargetShorthand as PublishTargetShorthandSchema, ResolutionPolicy, ResolvedTarget as ResolvedTargetSchema, ResolvedTool, SectionBlock, SectionDefinition, SectionDiff, SectionParseError, SectionValidationError, SectionWriteError, ShellSectionDefinition, SilkPublishConfig, SilkPublishabilityPlugin, SilkPublishabilityPluginLive, SilkWorkspaceAnalyzer, SilkWorkspaceAnalyzerLive, SourceRequirement, SyncResult, TagFormatError, TagStrategy, TagStrategyLive, TargetResolutionError, TargetResolver, TargetResolverLive, ToolCommand, ToolDefinition, ToolDiscovery, ToolDiscoveryLive, ToolNotFoundError, ToolResolutionError, ToolSource, ToolVersionMismatchError, VersionExtractor, VersioningDetectionError, VersioningStrategy, VersioningStrategyLive, WorkspaceAnalysis, WorkspaceAnalysisError, buildSchemaUrl, extractSemver };
+export { AnalyzedWorkspace, BiomeSchemaSync, BiomeSchemaSyncLive, BiomeSyncError, ChangesetConfig, ChangesetConfigError, ChangesetConfigLive, ChangesetConfigReader, ChangesetConfigReaderLive, CheckResult, ConfigDiscovery, ConfigDiscoveryLive, ConfigNotFoundError, ManagedSection, ManagedSectionLive, PublishabilityDetectorAdaptiveLive, ResolutionPolicy, ResolvedTool, SectionBlock, SectionDefinition, SectionDiff, SectionParseError, SectionValidationError, SectionWriteError, ShellSectionDefinition, SilkPublishConfig, SilkPublishability, SilkPublishabilityDetectorLive, SilkWorkspaceAnalyzer, SilkWorkspaceAnalyzerLive, SourceRequirement, SyncResult, TagFormatError, TagStrategy, TagStrategyLive, ToolCommand, ToolDefinition, ToolDiscovery, ToolDiscoveryLive, ToolNotFoundError, ToolResolutionError, ToolSource, ToolVersionMismatchError, VersionExtractor, VersioningDetectionError, VersioningStrategy, VersioningStrategyLive, WorkspaceAnalysis, WorkspaceAnalysisError, buildSchemaUrl, extractSemver };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@savvy-web/silk-effects",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "private": false,
   "description": "Shared Effect library for Silk Suite conventions",
   "homepage": "https://github.com/savvy-web/systems/tree/main/packages/silk-effects",
@@ -29,8 +29,8 @@
   "dependencies": {
     "jsonc-effect": "^0.2.1",
     "semver-effect": "^0.2.1",
-    "workspaces-effect": "^0.4.1",
-    "yaml-effect": "^0.2.3"
+    "workspaces-effect": "^1.0.0",
+    "yaml-effect": "^0.6.0"
   },
   "peerDependencies": {
     "@effect/platform": ">=0.96.0",

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.2"
+      "packageVersion": "7.58.7"
     }
   ]
 }