@savvy-web/silk-effects 0.2.2 → 0.4.0

package/index.js

@@ -1,7 +1,8 @@
-import { Context, Data, Effect, Equal, Function, Hash, Layer, Option, Ref, Schema } from "effect";
+import { Context, Data, Effect, Equal, Function, Hash, Layer, Option, Pretty, Ref, Schema } from "effect";
 import { Command, CommandExecutor, FileSystem } from "@effect/platform";
+import { PackageManagerDetector, PublishConfig, PublishTarget, PublishabilityDetector, PublishabilityDetectorLive, TopologicalSorter, WorkspaceDiscovery, WorkspaceRoot } from "workspaces-effect";
 import { parse } from "jsonc-effect";
-import { PackageManagerDetector, WorkspaceRoot } from "workspaces-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}`;
@@ -67,30 +58,11 @@ class VersioningDetectionError extends Data.TaggedError("VersioningDetectionErro
         return `Failed to detect versioning strategy: ${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 WorkspaceAnalysisError extends Data.TaggedError("WorkspaceAnalysisError") {
+    get message() {
+        return `Workspace analysis failed at ${this.root}: ${this.reason}`;
+    }
+}
 class ToolCommand {
     command;
     constructor(command){
@@ -122,9 +94,26 @@ const ToolSource = Schema.Literal("global", "local");
 const VersionExtractor = Data.taggedEnum();
 const ResolutionPolicy = Data.taggedEnum();
 const SourceRequirement = Data.taggedEnum();
-var _computedKey, _computedKey1;
+function _to_primitive(input, hint) {
+    if ("object" !== _type_of(input) || null === input) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (void 0 !== prim) {
+        var res = prim.call(input, hint || "default");
+        if ("object" !== _type_of(res)) return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === hint ? String : Number)(input);
+}
+function _to_property_key(arg) {
+    var key = _to_primitive(arg, "string");
+    return "symbol" === _type_of(key) ? key : String(key);
+}
+function _type_of(obj) {
+    return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+let _computedKey, _computedKey1;
 const PackageManager = Schema.Literal("npm", "pnpm", "yarn", "bun");
-_computedKey = Equal.symbol, _computedKey1 = Hash.symbol;
+_computedKey = _to_property_key(Equal.symbol), _computedKey1 = _to_property_key(Hash.symbol);
 class ResolvedTool extends Schema.TaggedClass()("ResolvedTool", {
     name: Schema.String,
     source: ToolSource,
@@ -183,8 +172,25 @@ const CommentStyle = Schema.Literal("#", "//");
 const SectionDiff = Data.taggedEnum();
 const SyncResult = Data.taggedEnum();
 const CheckResult = Data.taggedEnum();
-var SectionBlock_computedKey, SectionBlock_computedKey1;
-SectionBlock_computedKey = Equal.symbol, SectionBlock_computedKey1 = Hash.symbol;
+function SectionBlock_to_primitive(input, hint) {
+    if ("object" !== SectionBlock_type_of(input) || null === input) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (void 0 !== prim) {
+        var res = prim.call(input, hint || "default");
+        if ("object" !== SectionBlock_type_of(res)) return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === hint ? String : Number)(input);
+}
+function SectionBlock_to_property_key(arg) {
+    var key = SectionBlock_to_primitive(arg, "string");
+    return "symbol" === SectionBlock_type_of(key) ? key : String(key);
+}
+function SectionBlock_type_of(obj) {
+    return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+let SectionBlock_computedKey, SectionBlock_computedKey1;
+SectionBlock_computedKey = SectionBlock_to_property_key(Equal.symbol), SectionBlock_computedKey1 = SectionBlock_to_property_key(Hash.symbol);
 class SectionBlock extends Schema.TaggedClass()("SectionBlock", {
     toolName: Schema.String,
     commentStyle: CommentStyle,
@@ -239,8 +245,25 @@ class SectionBlock extends Schema.TaggedClass()("SectionBlock", {
         return Hash.cached(this)(Hash.hash(this.normalized));
     }
 }
-var SectionDefinition_computedKey, SectionDefinition_computedKey1;
-SectionDefinition_computedKey = Equal.symbol, SectionDefinition_computedKey1 = Hash.symbol;
+function SectionDefinition_to_primitive(input, hint) {
+    if ("object" !== SectionDefinition_type_of(input) || null === input) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (void 0 !== prim) {
+        var res = prim.call(input, hint || "default");
+        if ("object" !== SectionDefinition_type_of(res)) return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === hint ? String : Number)(input);
+}
+function SectionDefinition_to_property_key(arg) {
+    var key = SectionDefinition_to_primitive(arg, "string");
+    return "symbol" === SectionDefinition_type_of(key) ? key : String(key);
+}
+function SectionDefinition_type_of(obj) {
+    return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+let SectionDefinition_computedKey, SectionDefinition_computedKey1;
+SectionDefinition_computedKey = SectionDefinition_to_property_key(Equal.symbol), SectionDefinition_computedKey1 = SectionDefinition_to_property_key(Hash.symbol);
 class SectionDefinition extends Schema.TaggedClass()("SectionDefinition", {
     toolName: Schema.String,
     commentStyle: Schema.optionalWith(CommentStyle, {
@@ -342,11 +365,28 @@ class ShellSectionDefinition extends Schema.TaggedClass()("ShellSectionDefinitio
         return `# --- END ${this.toolName.toUpperCase()} MANAGED SECTION ---`;
     }
 }
-var ToolDefinition_computedKey, ToolDefinition_computedKey1;
+function ToolDefinition_to_primitive(input, hint) {
+    if ("object" !== ToolDefinition_type_of(input) || null === input) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (void 0 !== prim) {
+        var res = prim.call(input, hint || "default");
+        if ("object" !== ToolDefinition_type_of(res)) return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === hint ? String : Number)(input);
+}
+function ToolDefinition_to_property_key(arg) {
+    var key = ToolDefinition_to_primitive(arg, "string");
+    return "symbol" === ToolDefinition_type_of(key) ? key : String(key);
+}
+function ToolDefinition_type_of(obj) {
+    return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+let ToolDefinition_computedKey, ToolDefinition_computedKey1;
 const NameSchema = Schema.Struct({
     name: Schema.String
 });
-ToolDefinition_computedKey = Equal.symbol, ToolDefinition_computedKey1 = Hash.symbol;
+ToolDefinition_computedKey = ToolDefinition_to_property_key(Equal.symbol), ToolDefinition_computedKey1 = ToolDefinition_to_property_key(Hash.symbol);
 class ToolDefinition {
     _tag = "ToolDefinition";
     name;
@@ -375,6 +415,216 @@ class ToolDefinition {
         return Hash.cached(this)(Hash.hash(this.name));
     }
 }
+const TagStrategyType = Schema.Literal("single", "scoped");
+const PrivatePackagesConfig = Schema.Union(Schema.Struct({
+    tag: Schema.optional(Schema.Boolean),
+    version: Schema.optional(Schema.Boolean)
+}), Schema.Literal(false));
+const SnapshotConfig = Schema.Struct({
+    useCalculatedVersion: Schema.optional(Schema.Boolean),
+    prereleaseTemplate: Schema.optional(Schema.String)
+});
+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))),
+    linked: Schema.optional(Schema.Array(Schema.Array(Schema.String))),
+    access: Schema.optional(Schema.Literal("public", "restricted")),
+    baseBranch: Schema.optional(Schema.String),
+    updateInternalDependencies: Schema.optional(Schema.Literal("patch", "minor", "major")),
+    ignore: Schema.optional(Schema.Array(Schema.String)),
+    privatePackages: Schema.optional(PrivatePackagesConfig),
+    prettier: Schema.optional(Schema.Boolean),
+    changedFilePatterns: Schema.optional(Schema.Array(Schema.String)),
+    bumpVersionsWithWorkspaceProtocolOnly: Schema.optional(Schema.Boolean),
+    snapshot: Schema.optional(SnapshotConfig)
+});
+const SilkChangesetConfigFile = Schema.extend(ChangesetConfigFile, Schema.Struct({
+    _isSilk: Schema.optionalWith(Schema.Boolean, {
+        default: ()=>true
+    })
+}));
+const VersioningStrategyType = Schema.Literal("single", "fixed-group", "independent");
+const VersioningStrategyResult = Schema.Struct({
+    type: VersioningStrategyType,
+    fixedGroups: Schema.Array(Schema.Array(Schema.String)),
+    publishablePackages: Schema.Array(Schema.String)
+});
+function WorkspaceAnalysisSchemas_to_primitive(input, hint) {
+    if ("object" !== WorkspaceAnalysisSchemas_type_of(input) || null === input) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (void 0 !== prim) {
+        var res = prim.call(input, hint || "default");
+        if ("object" !== WorkspaceAnalysisSchemas_type_of(res)) return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === hint ? String : Number)(input);
+}
+function WorkspaceAnalysisSchemas_to_property_key(arg) {
+    var key = WorkspaceAnalysisSchemas_to_primitive(arg, "string");
+    return "symbol" === WorkspaceAnalysisSchemas_type_of(key) ? key : String(key);
+}
+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/",
+    jsr: "https://jsr.io/"
+};
+const WorkspaceVersion = Schema.Struct({
+    current: Schema.String
+});
+WorkspaceAnalysisSchemas_computedKey = WorkspaceAnalysisSchemas_to_property_key(Equal.symbol), WorkspaceAnalysisSchemas_computedKey1 = WorkspaceAnalysisSchemas_to_property_key(Hash.symbol);
+class AnalyzedWorkspace extends Schema.TaggedClass()("AnalyzedWorkspace", {
+    name: Schema.String,
+    version: WorkspaceVersion,
+    path: Schema.String,
+    root: Schema.Boolean,
+    publishConfig: Schema.NullOr(SilkPublishConfig),
+    publishable: Schema.Boolean,
+    targets: Schema.Array(PublishTarget),
+    versioned: Schema.Boolean,
+    tagged: Schema.Boolean,
+    released: Schema.Boolean,
+    linked: Schema.Array(Schema.suspend(()=>AnalyzedWorkspace)),
+    fixed: Schema.Array(Schema.suspend(()=>AnalyzedWorkspace))
+}) {
+    get isRoot() {
+        return this.root;
+    }
+    get isPublishable() {
+        return this.publishable;
+    }
+    get isReleasable() {
+        return this.released;
+    }
+    get isFixed() {
+        return this.fixed.length > 0;
+    }
+    get isLinked() {
+        return this.linked.length > 0;
+    }
+    publishesTo(registry) {
+        return this.targets.some((t)=>t.registry === registry);
+    }
+    hasTarget(shorthand) {
+        const registry = KNOWN_REGISTRIES[shorthand];
+        return void 0 !== registry && this.publishesTo(registry);
+    }
+    targetFor(registry) {
+        const found = this.targets.find((t)=>t.registry === registry);
+        return found ? Option.some(found) : Option.none();
+    }
+    [WorkspaceAnalysisSchemas_computedKey](that) {
+        if (!(that instanceof AnalyzedWorkspace)) return false;
+        return this.name === that.name && this.path === that.path;
+    }
+    [WorkspaceAnalysisSchemas_computedKey1]() {
+        return Hash.cached(this)(Hash.combine(Hash.hash(this.name))(Hash.hash(this.path)));
+    }
+    toString() {
+        return `${this.name}@${this.version.current}`;
+    }
+    toJSON() {
+        return {
+            _tag: "AnalyzedWorkspace",
+            name: this.name,
+            version: this.version,
+            path: this.path,
+            root: this.root,
+            publishable: this.publishable,
+            targets: this.targets,
+            versioned: this.versioned,
+            tagged: this.tagged,
+            released: this.released
+        };
+    }
+    static publishable(workspaces) {
+        return workspaces.filter((w)=>w.publishable);
+    }
+    static releasable(workspaces) {
+        return workspaces.filter((w)=>w.released);
+    }
+    static findByName;
+    static pretty;
+}
+AnalyzedWorkspace.findByName = Function.dual(2, (workspaces, name)=>{
+    const found = workspaces.find((w)=>w.name === name);
+    return found ? Option.some(found) : Option.none();
+});
+AnalyzedWorkspace.pretty = Pretty.make(AnalyzedWorkspace);
+const PackageManagerInfo = Schema.Struct({
+    type: Schema.Literal("npm", "pnpm", "yarn", "bun"),
+    version: Schema.optional(Schema.String)
+});
+_computedKey2 = WorkspaceAnalysisSchemas_to_property_key(Equal.symbol), _computedKey3 = WorkspaceAnalysisSchemas_to_property_key(Hash.symbol);
+class WorkspaceAnalysis extends Schema.TaggedClass()("WorkspaceAnalysis", {
+    root: Schema.String,
+    runtime: Schema.Literal("node", "bun"),
+    packageManager: PackageManagerInfo,
+    workspaces: Schema.Array(AnalyzedWorkspace),
+    changesetConfig: Schema.NullOr(Schema.Union(SilkChangesetConfigFile, ChangesetConfigFile)),
+    versioning: Schema.NullOr(VersioningStrategyResult),
+    tagStrategy: Schema.NullOr(TagStrategyType)
+}) {
+    findWorkspace(name) {
+        const found = this.workspaces.find((w)=>w.name === name);
+        return found ? Option.some(found) : Option.none();
+    }
+    get rootWorkspace() {
+        const root = this.workspaces.find((w)=>w.root);
+        return root ? Option.some(root) : Option.none();
+    }
+    get publishableWorkspaces() {
+        return this.workspaces.filter((w)=>w.publishable);
+    }
+    get versionedWorkspaces() {
+        return this.workspaces.filter((w)=>w.versioned);
+    }
+    get taggedWorkspaces() {
+        return this.workspaces.filter((w)=>w.tagged);
+    }
+    get releasableWorkspaces() {
+        return this.workspaces.filter((w)=>w.released);
+    }
+    get isSilk() {
+        if (null == this.changesetConfig) return false;
+        return "_isSilk" in this.changesetConfig && true === this.changesetConfig._isSilk;
+    }
+    get hasChangesets() {
+        return null != this.changesetConfig;
+    }
+    [_computedKey2](that) {
+        if (!(that instanceof WorkspaceAnalysis)) return false;
+        return this.root === that.root;
+    }
+    [_computedKey3]() {
+        return Hash.cached(this)(Hash.hash(this.root));
+    }
+    toString() {
+        return `WorkspaceAnalysis(${this.root}, ${this.workspaces.length} workspaces)`;
+    }
+    static pretty;
+}
+WorkspaceAnalysis.pretty = Pretty.make(WorkspaceAnalysis);
 function extractSemver(version) {
     return version.replace(/^[\^~>=<v]+/, "");
 }
@@ -450,27 +700,6 @@ const BiomeSchemaSyncLive = Layer.effect(BiomeSchemaSync, Effect.gen(function*()
         check: (version, options)=>run(version, options, false)
     };
 }));
-const ChangesetConfig = Schema.Struct({
-    changelog: Schema.optional(Schema.Union(Schema.String, Schema.Array(Schema.Unknown))),
-    commit: Schema.optional(Schema.Boolean),
-    fixed: Schema.optional(Schema.Array(Schema.Array(Schema.String))),
-    linked: Schema.optional(Schema.Array(Schema.Array(Schema.String))),
-    access: Schema.optional(Schema.Literal("public", "restricted")),
-    baseBranch: Schema.optional(Schema.String),
-    updateInternalDependencies: Schema.optional(Schema.Literal("patch", "minor", "major")),
-    ignore: Schema.optional(Schema.Array(Schema.String))
-});
-const SilkChangesetConfig = Schema.extend(ChangesetConfig, Schema.Struct({
-    _isSilk: Schema.optionalWith(Schema.Boolean, {
-        default: ()=>true
-    })
-}));
-const VersioningStrategyType = Schema.Literal("single", "fixed-group", "independent");
-Schema.Struct({
-    type: VersioningStrategyType,
-    fixedGroups: Schema.Array(Schema.Array(Schema.String)),
-    publishablePackages: Schema.Array(Schema.String)
-});
 const SILK_CHANGELOG_MARKER = "@savvy-web/changesets";
 function isSilkChangelog(changelog) {
     if ("string" == typeof changelog) return changelog.includes(SILK_CHANGELOG_MARKER);
@@ -504,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)}`
                 })));
@@ -518,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) {
@@ -669,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";
+const NPM_DEFAULT = "https://registry.npmjs.org/";
+class SilkPublishability {
+    static resolveTargetAccess(target, parentAccess) {
+        if ("string" == typeof target) return parentAccess;
+        return target.access ?? parentAccess;
     }
-}
-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;
+    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")() {
@@ -799,6 +1078,195 @@ const TagStrategyLive = Layer.succeed(TagStrategy, TagStrategy.of({
         return Effect.succeed(`${name}@${version}`);
     }
 }));
+class VersioningStrategy extends Context.Tag("@savvy-web/silk-effects/VersioningStrategy")() {
+}
+const VersioningStrategyLive = Layer.effect(VersioningStrategy, Effect.gen(function*() {
+    const configReader = yield* ChangesetConfigReader;
+    const detect = (publishablePackages, root)=>Effect.gen(function*() {
+            const config = yield* configReader.read(root).pipe(Effect.orElseSucceed(()=>({
+                    fixed: [],
+                    linked: []
+                })));
+            const fixed = config.fixed ?? [];
+            const packages = [
+                ...publishablePackages
+            ];
+            if (packages.length <= 1) return {
+                type: "single",
+                fixedGroups: fixed,
+                publishablePackages: packages
+            };
+            const containingGroup = fixed.find((group)=>packages.every((pkg)=>group.includes(pkg)));
+            if (void 0 !== containingGroup) return {
+                type: "fixed-group",
+                fixedGroups: fixed,
+                publishablePackages: packages
+            };
+            return {
+                type: "independent",
+                fixedGroups: fixed,
+                publishablePackages: packages
+            };
+        });
+    return {
+        detect
+    };
+}));
+class SilkWorkspaceAnalyzer extends Context.Tag("@savvy-web/silk-effects/SilkWorkspaceAnalyzer")() {
+}
+const readRawPkgJson = (fs, packageJsonPath)=>fs.readFileString(packageJsonPath).pipe(Effect.flatMap((content)=>Effect["try"]({
+            try: ()=>JSON.parse(content),
+            catch: ()=>new WorkspaceAnalysisError({
+                    root: packageJsonPath,
+                    reason: "Invalid JSON in package.json"
+                })
+        })), Effect.mapError((err)=>err instanceof WorkspaceAnalysisError ? err : new WorkspaceAnalysisError({
+            root: packageJsonPath,
+            reason: `Failed to read package.json: ${String(err)}`
+        })));
+function computeReleaseStatus(pkgName, isPrivate, isPublishable, config) {
+    if (null == config) return {
+        versioned: false,
+        tagged: false,
+        released: false
+    };
+    if ((config.ignore ?? []).some((p)=>ChangesetConfig.matches(pkgName, p))) return {
+        versioned: false,
+        tagged: false,
+        released: false
+    };
+    if (!isPrivate || isPublishable) return {
+        versioned: true,
+        tagged: true,
+        released: true
+    };
+    const pp = config.privatePackages;
+    if (void 0 === pp) return {
+        versioned: false,
+        tagged: false,
+        released: false
+    };
+    if (false === pp) return {
+        versioned: false,
+        tagged: false,
+        released: false
+    };
+    const versioned = true === pp.version;
+    const tagged = true === pp.tag;
+    const released = versioned && tagged;
+    return {
+        versioned,
+        tagged,
+        released
+    };
+}
+const SilkWorkspaceAnalyzerLive = Layer.effect(SilkWorkspaceAnalyzer, Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
+    const discovery = yield* WorkspaceDiscovery;
+    const sorter = yield* TopologicalSorter;
+    const pmDetector = yield* PackageManagerDetector;
+    const configReader = yield* ChangesetConfigReader;
+    const versioningStrategy = yield* VersioningStrategy;
+    const tagStrategy = yield* TagStrategy;
+    const analyze = (root)=>Effect.gen(function*() {
+            const pm = yield* pmDetector.detect(root).pipe(Effect.mapError((err)=>new WorkspaceAnalysisError({
+                    root,
+                    reason: `Package manager detection failed: ${String(err)}`
+                })));
+            const packages = yield* discovery.listPackages().pipe(Effect.mapError((err)=>new WorkspaceAnalysisError({
+                    root,
+                    reason: `Workspace discovery failed: ${String(err)}`
+                })));
+            const topoOrder = yield* sorter.sort().pipe(Effect.mapError((err)=>new WorkspaceAnalysisError({
+                    root,
+                    reason: `Cyclic dependency detected: ${String(err)}`
+                })));
+            const packagesByName = new Map(packages.map((p)=>[
+                    p.name,
+                    p
+                ]));
+            const sortedPackages = topoOrder.flatMap((name)=>{
+                const pkg = packagesByName.get(name);
+                return pkg ? [
+                    pkg
+                ] : [];
+            });
+            const changesetConfigOption = yield* configReader.read(root).pipe(Effect.option);
+            const changesetConfig = Option.getOrNull(changesetConfigOption);
+            const analyzedWorkspaces = [];
+            for (const pkg of sortedPackages){
+                const pkgJson = yield* readRawPkgJson(fs, pkg.packageJsonPath);
+                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);
+                const analyzed = new AnalyzedWorkspace({
+                    name: pkg.name,
+                    version: {
+                        current: pkg.version
+                    },
+                    path: pkg.path,
+                    root: isRoot,
+                    publishConfig: null,
+                    publishable: isPublishable,
+                    targets: [
+                        ...targets
+                    ],
+                    versioned,
+                    tagged,
+                    released,
+                    linked: [],
+                    fixed: []
+                });
+                analyzedWorkspaces.push(analyzed);
+            }
+            if (changesetConfig) {
+                const fixedGroups = changesetConfig.fixed ?? [];
+                const linkedGroups = changesetConfig.linked ?? [];
+                const fixedByName = new Map();
+                for (const group of fixedGroups){
+                    const members = analyzedWorkspaces.filter((w)=>group.includes(w.name));
+                    for (const member of members)fixedByName.set(member.name, members.filter((m)=>m !== member));
+                }
+                const linkedByName = new Map();
+                for (const group of linkedGroups){
+                    const members = analyzedWorkspaces.filter((w)=>group.includes(w.name));
+                    for (const member of members)linkedByName.set(member.name, members.filter((m)=>m !== member));
+                }
+                for(let i = 0; i < analyzedWorkspaces.length; i++){
+                    const ws = analyzedWorkspaces[i];
+                    const fixedRefs = fixedByName.get(ws.name) ?? [];
+                    const linkedRefs = linkedByName.get(ws.name) ?? [];
+                    if (fixedRefs.length > 0 || linkedRefs.length > 0) analyzedWorkspaces[i] = new AnalyzedWorkspace({
+                        ...ws,
+                        fixed: fixedRefs,
+                        linked: linkedRefs
+                    });
+                }
+            }
+            const publishableNames = analyzedWorkspaces.filter((w)=>w.publishable).map((w)=>w.name);
+            const versioning = yield* versioningStrategy.detect(publishableNames, root).pipe(Effect.mapError((err)=>new WorkspaceAnalysisError({
+                    root,
+                    reason: `Versioning strategy detection failed: ${String(err)}`
+                })));
+            const tagStrategyType = yield* tagStrategy.determine(versioning);
+            return new WorkspaceAnalysis({
+                root,
+                runtime: pm.runtime,
+                packageManager: {
+                    type: pm.type,
+                    version: pm.version
+                },
+                workspaces: analyzedWorkspaces,
+                changesetConfig,
+                versioning,
+                tagStrategy: tagStrategyType
+            });
+        });
+    return {
+        analyze
+    };
+}));
 class ToolDiscovery extends Context.Tag("@savvy-web/silk-effects/ToolDiscovery")() {
 }
 function pmExecArgs(pmType, name) {
@@ -986,38 +1454,4 @@ const ToolDiscoveryLive = Layer.effect(ToolDiscovery, Effect.gen(function*() {
         clearCache
     };
 }));
-class VersioningStrategy extends Context.Tag("@savvy-web/silk-effects/VersioningStrategy")() {
-}
-const VersioningStrategyLive = Layer.effect(VersioningStrategy, Effect.gen(function*() {
-    const configReader = yield* ChangesetConfigReader;
-    const detect = (publishablePackages, root)=>Effect.gen(function*() {
-            const config = yield* configReader.read(root).pipe(Effect.orElseSucceed(()=>({
-                    fixed: [],
-                    linked: []
-                })));
-            const fixed = config.fixed ?? [];
-            const packages = [
-                ...publishablePackages
-            ];
-            if (packages.length <= 1) return {
-                type: "single",
-                fixedGroups: fixed,
-                publishablePackages: packages
-            };
-            const containingGroup = fixed.find((group)=>packages.every((pkg)=>group.includes(pkg)));
-            if (void 0 !== containingGroup) return {
-                type: "fixed-group",
-                fixedGroups: fixed,
-                publishablePackages: packages
-            };
-            return {
-                type: "independent",
-                fixedGroups: fixed,
-                publishablePackages: packages
-            };
-        });
-    return {
-        detect
-    };
-}));
-export { 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, SilkPublishabilityPlugin, SilkPublishabilityPluginLive, SourceRequirement, SyncResult, TagFormatError, TagStrategy, TagStrategyLive, TargetResolutionError, TargetResolver, TargetResolverLive, ToolCommand, ToolDefinition, ToolDiscovery, ToolDiscoveryLive, ToolNotFoundError, ToolResolutionError, ToolSource, ToolVersionMismatchError, VersionExtractor, VersioningDetectionError, VersioningStrategy, VersioningStrategyLive, 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 };