@savvy-web/silk-effects 0.2.2 → 0.3.0

package/index.d.ts

@@ -18,15 +18,76 @@ import { Equal } from 'effect';
 import { FileSystem } from '@effect/platform';
 import { Hash } from 'effect';
 import { Layer } from 'effect';
+import { Option } from 'effect';
 import { PackageManagerDetector } from 'workspaces-effect';
 import type { PlatformError } from '@effect/platform/Error';
+import { PublishConfig } from 'workspaces-effect';
 import { Schema } from 'effect';
 import type { Stream } from 'effect';
+import { TopologicalSorter } from 'workspaces-effect';
 import { Unify } from 'effect/Unify';
 import { VoidIfEmpty } from 'effect/Types';
+import { WorkspaceDiscovery } from 'workspaces-effect';
 import { WorkspaceRoot } from 'workspaces-effect';
 import { YieldableError } from 'effect/Cause';
 
+/**
+ * A fully analyzed workspace with publish targets, versioning status,
+ * and release group membership.
+ *
+ * @since 0.2.0
+ */
+export declare class AnalyzedWorkspace extends AnalyzedWorkspace_base {
+    get isRoot(): boolean;
+    get isPublishable(): boolean;
+    get isReleasable(): boolean;
+    get isFixed(): boolean;
+    get isLinked(): boolean;
+    publishesTo(registry: string): boolean;
+    hasTarget(shorthand: "npm" | "github" | "jsr"): boolean;
+    targetFor(registry: string): Option.Option<ResolvedTarget>;
+    [Equal.symbol](that: Equal.Equal): boolean;
+    [Hash.symbol](): number;
+    toString(): string;
+    toJSON(): unknown;
+    static publishable(workspaces: ReadonlyArray<AnalyzedWorkspace>): ReadonlyArray<AnalyzedWorkspace>;
+    static releasable(workspaces: ReadonlyArray<AnalyzedWorkspace>): ReadonlyArray<AnalyzedWorkspace>;
+    static findByName: {
+        (name: string): (workspaces: ReadonlyArray<AnalyzedWorkspace>) => Option.Option<AnalyzedWorkspace>;
+        (workspaces: ReadonlyArray<AnalyzedWorkspace>, name: string): Option.Option<AnalyzedWorkspace>;
+    };
+    /** Pretty-print an AnalyzedWorkspace instance. */
+    static pretty: (self: AnalyzedWorkspace) => string;
+}
+
+declare const AnalyzedWorkspace_base: Schema.TaggedClass<AnalyzedWorkspace, "AnalyzedWorkspace", {
+    readonly _tag: Schema.tag<"AnalyzedWorkspace">;
+} & {
+    name: typeof Schema.String;
+    version: Schema.Struct<{
+        current: typeof Schema.String;
+    }>;
+    path: typeof Schema.String;
+    root: typeof Schema.Boolean;
+    publishConfig: Schema.NullOr<typeof SilkPublishConfig>;
+    publishable: typeof Schema.Boolean;
+    targets: Schema.Array$<Schema.Struct<{
+        protocol: Schema.Literal<["npm", "jsr"]>;
+        registry: Schema.NullOr<typeof Schema.String>;
+        directory: typeof Schema.String;
+        access: Schema.Literal<["public", "restricted"]>;
+        provenance: typeof Schema.Boolean;
+        tag: typeof Schema.String;
+        auth: Schema.Literal<["oidc", "token"]>;
+        tokenEnv: Schema.NullOr<typeof Schema.String>;
+    }>>;
+    versioned: typeof Schema.Boolean;
+    tagged: typeof Schema.Boolean;
+    released: typeof Schema.Boolean;
+    linked: Schema.Array$<Schema.suspend<unknown, unknown, unknown>>;
+    fixed: Schema.Array$<Schema.suspend<unknown, unknown, unknown>>;
+}>;
+
 /**
  * Authentication strategy used to obtain publish credentials.
  *
@@ -178,7 +239,7 @@ export declare type BiomeSyncResult = typeof BiomeSyncResult.Type;
 export declare function buildSchemaUrl(version: string): string;
 
 /**
- * Standard changesets configuration matching the `@changesets/types` upstream spec.
+ * Standard changesets configuration matching the `@changesets/config@3.1.1` spec.
  *
  * @remarks
  * Represents the parsed `.changeset/config.json` file. All fields are optional
@@ -188,14 +249,25 @@ export declare function buildSchemaUrl(version: string): string;
  * @since 0.1.0
  */
 export declare const ChangesetConfig: Schema.Struct<{
-    changelog: Schema.optional<Schema.Union<[typeof Schema.String, Schema.Array$<typeof Schema.Unknown>]>>;
-    commit: Schema.optional<typeof Schema.Boolean>;
+    changelog: Schema.optional<Schema.Union<[typeof Schema.String, Schema.Array$<typeof Schema.Unknown>, Schema.Literal<[false]>]>>;
+    commit: Schema.optional<Schema.Union<[typeof Schema.Boolean, typeof Schema.String, Schema.Array$<typeof Schema.Unknown>]>>;
     fixed: Schema.optional<Schema.Array$<Schema.Array$<typeof Schema.String>>>;
     linked: Schema.optional<Schema.Array$<Schema.Array$<typeof Schema.String>>>;
     access: Schema.optional<Schema.Literal<["public", "restricted"]>>;
     baseBranch: Schema.optional<typeof Schema.String>;
     updateInternalDependencies: Schema.optional<Schema.Literal<["patch", "minor", "major"]>>;
     ignore: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    privatePackages: Schema.optional<Schema.Union<[Schema.Struct<{
+        tag: Schema.optional<typeof Schema.Boolean>;
+        version: Schema.optional<typeof Schema.Boolean>;
+    }>, Schema.Literal<[false]>]>>;
+    prettier: Schema.optional<typeof Schema.Boolean>;
+    changedFilePatterns: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    bumpVersionsWithWorkspaceProtocolOnly: Schema.optional<typeof Schema.Boolean>;
+    snapshot: Schema.optional<Schema.Struct<{
+        useCalculatedVersion: Schema.optional<typeof Schema.Boolean>;
+        prereleaseTemplate: Schema.optional<typeof Schema.String>;
+    }>>;
 }>;
 
 /** @since 0.1.0 */
@@ -1025,14 +1097,25 @@ declare const ShellSectionDefinition_base: Schema.TaggedClass<ShellSectionDefini
  * @since 0.1.0
  */
 export declare const SilkChangesetConfig: Schema.extend<Schema.Struct<{
-    changelog: Schema.optional<Schema.Union<[typeof Schema.String, Schema.Array$<typeof Schema.Unknown>]>>;
-    commit: Schema.optional<typeof Schema.Boolean>;
+    changelog: Schema.optional<Schema.Union<[typeof Schema.String, Schema.Array$<typeof Schema.Unknown>, Schema.Literal<[false]>]>>;
+    commit: Schema.optional<Schema.Union<[typeof Schema.Boolean, typeof Schema.String, Schema.Array$<typeof Schema.Unknown>]>>;
     fixed: Schema.optional<Schema.Array$<Schema.Array$<typeof Schema.String>>>;
     linked: Schema.optional<Schema.Array$<Schema.Array$<typeof Schema.String>>>;
     access: Schema.optional<Schema.Literal<["public", "restricted"]>>;
     baseBranch: Schema.optional<typeof Schema.String>;
     updateInternalDependencies: Schema.optional<Schema.Literal<["patch", "minor", "major"]>>;
     ignore: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    privatePackages: Schema.optional<Schema.Union<[Schema.Struct<{
+        tag: Schema.optional<typeof Schema.Boolean>;
+        version: Schema.optional<typeof Schema.Boolean>;
+    }>, Schema.Literal<[false]>]>>;
+    prettier: Schema.optional<typeof Schema.Boolean>;
+    changedFilePatterns: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    bumpVersionsWithWorkspaceProtocolOnly: Schema.optional<typeof Schema.Boolean>;
+    snapshot: Schema.optional<Schema.Struct<{
+        useCalculatedVersion: Schema.optional<typeof Schema.Boolean>;
+        prereleaseTemplate: Schema.optional<typeof Schema.String>;
+    }>>;
 }>, Schema.Struct<{
     _isSilk: Schema.optionalWith<typeof Schema.Boolean, {
         default: () => true;
@@ -1094,6 +1177,128 @@ declare const SilkPublishabilityPlugin_base: Context.TagClass<SilkPublishability
  */
 export declare const SilkPublishabilityPluginLive: Layer.Layer<SilkPublishabilityPlugin, never, TargetResolver>;
 
+/**
+ * Silk-extended publishConfig schema.
+ *
+ * @remarks
+ * Extends the base PublishConfig from workspaces-effect (which covers npm
+ * standard fields: access, registry, directory, tag, linkDirectory) with the
+ * Silk `targets` extension for multi-registry publishing.
+ *
+ * @since 0.2.0
+ */
+export declare class SilkPublishConfig extends SilkPublishConfig_base {
+}
+
+declare const SilkPublishConfig_base: Schema.Class<SilkPublishConfig, {
+    access: Schema.optional<Schema.Literal<["public", "restricted"]>>;
+    registry: Schema.optional<typeof Schema.String>;
+    directory: Schema.optional<typeof Schema.String>;
+    tag: Schema.optional<typeof Schema.String>;
+    linkDirectory: Schema.optional<typeof Schema.Boolean>;
+} & {
+    targets: Schema.optional<Schema.Array$<Schema.Union<[Schema.Literal<["npm", "github", "jsr"]>, Schema.Struct<{
+        protocol: Schema.optionalWith<Schema.Literal<["npm", "jsr"]>, {
+            default: () => "npm";
+        }>;
+        registry: Schema.optional<typeof Schema.String>;
+        directory: Schema.optional<typeof Schema.String>;
+        access: Schema.optional<Schema.Literal<["public", "restricted"]>>;
+        provenance: Schema.optional<typeof Schema.Boolean>;
+        tag: Schema.optional<typeof Schema.String>;
+    }>]>>>;
+}, {} & {
+    readonly access?: "public" | "restricted" | undefined;
+    readonly directory?: string | undefined;
+    readonly linkDirectory?: boolean | undefined;
+    readonly registry?: string | undefined;
+    readonly tag?: string | undefined;
+} & {} & {
+    readonly targets?: readonly ("github" | "jsr" | "npm" | {
+        readonly access?: "public" | "restricted" | undefined;
+        readonly directory?: string | undefined;
+        readonly protocol?: "jsr" | "npm" | undefined;
+        readonly provenance?: boolean | undefined;
+        readonly registry?: string | undefined;
+        readonly tag?: string | undefined;
+    })[] | undefined;
+}, never, {
+    readonly access?: "public" | "restricted" | undefined;
+} & {
+    readonly directory?: string | undefined;
+} & {
+    readonly linkDirectory?: boolean | undefined;
+} & {
+    readonly registry?: string | undefined;
+} & {
+    readonly tag?: string | undefined;
+} & {
+    readonly targets?: readonly ("github" | "jsr" | "npm" | {
+        readonly protocol: "jsr" | "npm";
+        readonly registry?: string | undefined;
+        readonly directory?: string | undefined;
+        readonly access?: "public" | "restricted" | undefined;
+        readonly provenance?: boolean | undefined;
+        readonly tag?: string | undefined;
+    })[] | undefined;
+}, PublishConfig, {}>;
+
+/**
+ * Service that performs a full workspace analysis — discovering packages,
+ * detecting publishability, computing versioning/tag strategies, and
+ * wiring up fixed/linked release groups.
+ *
+ * @remarks
+ * Orchestrates {@link WorkspaceDiscovery}, {@link PackageManagerDetector},
+ * {@link SilkPublishabilityPlugin}, {@link ChangesetConfigReader},
+ * {@link VersioningStrategy}, and {@link TagStrategy} to produce a
+ * complete {@link WorkspaceAnalysis} for a given workspace root.
+ *
+ * @example
+ * ```typescript
+ * const result = await Effect.runPromise(
+ *   Effect.gen(function* () {
+ *     const analyzer = yield* SilkWorkspaceAnalyzer;
+ *     return yield* analyzer.analyze("/path/to/monorepo");
+ *   }).pipe(
+ *     Effect.provide(SilkWorkspaceAnalyzerLive),
+ *     // ... provide all transitive layers
+ *   )
+ * );
+ * ```
+ *
+ * @since 0.2.0
+ */
+export declare class SilkWorkspaceAnalyzer extends SilkWorkspaceAnalyzer_base {
+}
+
+declare const SilkWorkspaceAnalyzer_base: Context.TagClass<SilkWorkspaceAnalyzer, "@savvy-web/silk-effects/SilkWorkspaceAnalyzer", {
+    /**
+     * Analyze a workspace root and produce a full {@link WorkspaceAnalysis}.
+     *
+     * @param root - Absolute path to the workspace root directory. Must match
+     *   the root that the `WorkspaceRoot` layer was initialised with. The analyzer
+     *   is single-root by design — build a fresh layer per workspace root.
+     * @returns An `Effect` that succeeds with a {@link WorkspaceAnalysis}, or
+     *   fails with {@link WorkspaceAnalysisError}.
+     *
+     * @since 0.2.0
+     */
+    readonly analyze: (root: string) => Effect.Effect<WorkspaceAnalysis, WorkspaceAnalysisError>;
+}>;
+
+/**
+ * Live implementation of {@link SilkWorkspaceAnalyzer}.
+ *
+ * @remarks
+ * Requires {@link WorkspaceDiscovery}, {@link PackageManagerDetector},
+ * {@link SilkPublishabilityPlugin}, {@link ChangesetConfigReader},
+ * {@link VersioningStrategy}, and {@link TagStrategy}.
+ *
+ * @since 0.2.0
+ */
+export declare const SilkWorkspaceAnalyzerLive: Layer.Layer<SilkWorkspaceAnalyzer, never, FileSystem.FileSystem | WorkspaceDiscovery | TopologicalSorter | PackageManagerDetector | SilkPublishabilityPlugin | ChangesetConfigReader | VersioningStrategy | TagStrategy>;
+
 /** @since 0.2.0 */
 export declare type SourceRequirement = Data.TaggedEnum<SourceRequirementDefinition>;
 
@@ -1782,4 +1987,110 @@ export declare const VersioningStrategyType: Schema.Literal<["single", "fixed-gr
 /** @since 0.1.0 */
 export declare type VersioningStrategyType = typeof VersioningStrategyType.Type;
 
+/**
+ * Full workspace analysis result containing all analyzed workspaces
+ * and project-level configuration.
+ *
+ * @since 0.2.0
+ */
+export declare class WorkspaceAnalysis extends WorkspaceAnalysis_base {
+    findWorkspace(name: string): Option.Option<AnalyzedWorkspace>;
+    get rootWorkspace(): Option.Option<AnalyzedWorkspace>;
+    get publishableWorkspaces(): ReadonlyArray<AnalyzedWorkspace>;
+    get versionedWorkspaces(): ReadonlyArray<AnalyzedWorkspace>;
+    get taggedWorkspaces(): ReadonlyArray<AnalyzedWorkspace>;
+    get releasableWorkspaces(): ReadonlyArray<AnalyzedWorkspace>;
+    get isSilk(): boolean;
+    get hasChangesets(): boolean;
+    [Equal.symbol](that: Equal.Equal): boolean;
+    [Hash.symbol](): number;
+    toString(): string;
+    /** Pretty-print a WorkspaceAnalysis instance. */
+    static pretty: (self: WorkspaceAnalysis) => string;
+}
+
+declare const WorkspaceAnalysis_base: Schema.TaggedClass<WorkspaceAnalysis, "WorkspaceAnalysis", {
+    readonly _tag: Schema.tag<"WorkspaceAnalysis">;
+} & {
+    root: typeof Schema.String;
+    runtime: Schema.Literal<["node", "bun"]>;
+    packageManager: Schema.Struct<{
+        type: Schema.Literal<["npm", "pnpm", "yarn", "bun"]>;
+        version: Schema.optional<typeof Schema.String>;
+    }>;
+    workspaces: Schema.Array$<typeof AnalyzedWorkspace>;
+    changesetConfig: Schema.NullOr<Schema.Union<[Schema.extend<Schema.Struct<{
+        changelog: Schema.optional<Schema.Union<[typeof Schema.String, Schema.Array$<typeof Schema.Unknown>, Schema.Literal<[false]>]>>;
+        commit: Schema.optional<Schema.Union<[typeof Schema.Boolean, typeof Schema.String, Schema.Array$<typeof Schema.Unknown>]>>;
+        fixed: Schema.optional<Schema.Array$<Schema.Array$<typeof Schema.String>>>;
+        linked: Schema.optional<Schema.Array$<Schema.Array$<typeof Schema.String>>>;
+        access: Schema.optional<Schema.Literal<["public", "restricted"]>>;
+        baseBranch: Schema.optional<typeof Schema.String>;
+        updateInternalDependencies: Schema.optional<Schema.Literal<["patch", "minor", "major"]>>;
+        ignore: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        privatePackages: Schema.optional<Schema.Union<[Schema.Struct<{
+            tag: Schema.optional<typeof Schema.Boolean>;
+            version: Schema.optional<typeof Schema.Boolean>;
+        }>, Schema.Literal<[false]>]>>;
+        prettier: Schema.optional<typeof Schema.Boolean>;
+        changedFilePatterns: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        bumpVersionsWithWorkspaceProtocolOnly: Schema.optional<typeof Schema.Boolean>;
+        snapshot: Schema.optional<Schema.Struct<{
+            useCalculatedVersion: Schema.optional<typeof Schema.Boolean>;
+            prereleaseTemplate: Schema.optional<typeof Schema.String>;
+        }>>;
+    }>, Schema.Struct<{
+        _isSilk: Schema.optionalWith<typeof Schema.Boolean, {
+            default: () => true;
+        }>;
+    }>>, Schema.Struct<{
+        changelog: Schema.optional<Schema.Union<[typeof Schema.String, Schema.Array$<typeof Schema.Unknown>, Schema.Literal<[false]>]>>;
+        commit: Schema.optional<Schema.Union<[typeof Schema.Boolean, typeof Schema.String, Schema.Array$<typeof Schema.Unknown>]>>;
+        fixed: Schema.optional<Schema.Array$<Schema.Array$<typeof Schema.String>>>;
+        linked: Schema.optional<Schema.Array$<Schema.Array$<typeof Schema.String>>>;
+        access: Schema.optional<Schema.Literal<["public", "restricted"]>>;
+        baseBranch: Schema.optional<typeof Schema.String>;
+        updateInternalDependencies: Schema.optional<Schema.Literal<["patch", "minor", "major"]>>;
+        ignore: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        privatePackages: Schema.optional<Schema.Union<[Schema.Struct<{
+            tag: Schema.optional<typeof Schema.Boolean>;
+            version: Schema.optional<typeof Schema.Boolean>;
+        }>, Schema.Literal<[false]>]>>;
+        prettier: Schema.optional<typeof Schema.Boolean>;
+        changedFilePatterns: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        bumpVersionsWithWorkspaceProtocolOnly: Schema.optional<typeof Schema.Boolean>;
+        snapshot: Schema.optional<Schema.Struct<{
+            useCalculatedVersion: Schema.optional<typeof Schema.Boolean>;
+            prereleaseTemplate: Schema.optional<typeof Schema.String>;
+        }>>;
+    }>]>>;
+    versioning: Schema.NullOr<Schema.Struct<{
+        type: Schema.Literal<["single", "fixed-group", "independent"]>;
+        fixedGroups: Schema.Array$<Schema.Array$<typeof Schema.String>>;
+        publishablePackages: Schema.Array$<typeof Schema.String>;
+    }>>;
+    tagStrategy: Schema.NullOr<Schema.Literal<["single", "scoped"]>>;
+}>;
+
+/**
+ * Raised when workspace analysis fails for a given root directory.
+ *
+ * @remarks
+ * Returned by {@link SilkWorkspaceAnalyzer.analyze} when the analysis pipeline
+ * encounters an unrecoverable error — e.g. workspace discovery failure,
+ * package manager detection failure, or publishability detection errors.
+ *
+ * @since 0.2.0
+ */
+export declare class WorkspaceAnalysisError extends WorkspaceAnalysisError_base<{
+    readonly root: string;
+    readonly reason: string;
+}> {
+    get message(): string;
+}
+
+declare const WorkspaceAnalysisError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
+    readonly _tag: "WorkspaceAnalysisError";
+} & Readonly<A>;
+
 export { }

package/index.js

@@ -1,7 +1,7 @@
-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, TopologicalSorter, WorkspaceDiscovery, WorkspaceRoot } from "workspaces-effect";
 import { parse } from "jsonc-effect";
-import { PackageManagerDetector, WorkspaceRoot } from "workspaces-effect";
 class BiomeSyncError extends Data.TaggedError("BiomeSyncError") {
     get message() {
         return `Failed to sync biome schema in ${this.path}: ${this.reason}`;
@@ -67,6 +67,11 @@ class VersioningDetectionError extends Data.TaggedError("VersioningDetectionErro
         return `Failed to detect versioning strategy: ${this.reason}`;
     }
 }
+class WorkspaceAnalysisError extends Data.TaggedError("WorkspaceAnalysisError") {
+    get message() {
+        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({
@@ -122,9 +127,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 +205,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 +278,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 +398,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 +448,204 @@ 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 ChangesetConfig = 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 SilkChangesetConfig = Schema.extend(ChangesetConfig, 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;
+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/"
+};
+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(ResolvedTarget),
+    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) {
+        if ("jsr" === shorthand) return this.targets.some((t)=>"jsr" === t.protocol);
+        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(SilkChangesetConfig, ChangesetConfig)),
+    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 +721,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);
@@ -799,6 +1049,199 @@ 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?.includes(pkgName)) 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 publishability = yield* SilkPublishabilityPlugin;
+    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 = yield* publishability.detect(pkgJson).pipe(Effect.mapError((err)=>new WorkspaceAnalysisError({
+                        root,
+                        reason: `Publishability detection failed for ${pkg.name}: ${String(err)}`
+                    })));
+                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 +1429,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, 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 };

package/package.json

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

package/tsdoc-metadata.json

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