@savvy-web/silk-effects 0.2.2 → 0.4.0

package/index.d.ts

@@ -18,28 +18,69 @@ 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 { PublishabilityDetector } from 'workspaces-effect';
+import { PublishConfig } from 'workspaces-effect';
+import { PublishTarget } 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 type { WorkspacePackage } from 'workspaces-effect';
 import { WorkspaceRoot } from 'workspaces-effect';
 import { YieldableError } from 'effect/Cause';
 
 /**
- * Authentication strategy used to obtain publish credentials.
+ * A fully analyzed workspace with publish targets, versioning status,
+ * and release group membership.
  *
- * @remarks
- * `"oidc"` relies on GitHub Actions OIDC provenance tokens (no explicit secret needed).
- * `"token"` reads a long-lived token from an environment variable.
- *
- * @since 0.1.0
+ * @since 0.2.0
  */
-export declare const AuthStrategy: Schema.Literal<["oidc", "token"]>;
+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<PublishTarget>;
+    [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;
+}
 
-/** @since 0.1.0 */
-export declare type AuthStrategy = typeof AuthStrategy.Type;
+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$<typeof PublishTarget>;
+    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>>;
+}>;
 
 /**
  * Service that keeps the `$schema` URL in Biome config files in sync with a target version.
@@ -178,28 +219,32 @@ export declare type BiomeSyncResult = typeof BiomeSyncResult.Type;
 export declare function buildSchemaUrl(version: string): string;
 
 /**
- * Standard changesets configuration matching the `@changesets/types` upstream spec.
+ * Accessor service over a workspace root's `.changeset/config.json`.
  *
  * @remarks
- * Represents the parsed `.changeset/config.json` file. All fields are optional
- * to allow partial configs. Use {@link SilkChangesetConfig} when the Silk changelog
- * adapter is detected.
+ * Reads through {@link ChangesetConfigReader} (FileSystem-based) with a per-root cache.
+ * Every accessor is total (error channel `never`): a missing or unreadable config collapses
+ * to `mode: "none"` and empty/false defaults.
  *
- * @since 0.1.0
+ * @since 0.4.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>;
-    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>>;
-}>;
+export declare class ChangesetConfig extends ChangesetConfig_base {
+    /**
+     * The one ignore matcher: exact name match, or `@scope/*` wildcard.
+     *
+     * `"@scope/*"` matches `"@scope/anything"` (prefix kept includes the trailing slash),
+     * but not the bare scope `"@scope"`.
+     */
+    static matches(name: string, pattern: string): boolean;
+}
 
-/** @since 0.1.0 */
-export declare type ChangesetConfig = typeof ChangesetConfig.Type;
+declare const ChangesetConfig_base: Context.TagClass<ChangesetConfig, "@savvy-web/silk-effects/ChangesetConfig", {
+    readonly mode: (root: string) => Effect.Effect<ChangesetMode>;
+    readonly versionPrivate: (root: string) => Effect.Effect<boolean>;
+    readonly ignorePatterns: (root: string) => Effect.Effect<ReadonlyArray<string>>;
+    readonly isIgnored: (name: string, root: string) => Effect.Effect<boolean>;
+    readonly fixed: (root: string) => Effect.Effect<ReadonlyArray<ReadonlyArray<string>>>;
+}>;
 
 /**
  * Raised when the `.changeset/config.json` file cannot be read or decoded.
@@ -221,13 +266,59 @@ declare const ChangesetConfigError_base: new <A extends Record<string, any> = {}
     readonly _tag: "ChangesetConfigError";
 } & Readonly<A>;
 
+/**
+ * Standard changesets configuration matching the `@changesets/config@3.1.1` spec.
+ *
+ * @remarks
+ * Represents the parsed `.changeset/config.json` file. All fields are optional
+ * to allow partial configs. Use {@link SilkChangesetConfigFile} when the Silk changelog
+ * adapter is detected.
+ *
+ * @since 0.1.0
+ */
+export declare const ChangesetConfigFile: 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>;
+    }>>;
+}>;
+
+/** @since 0.1.0 */
+export declare type ChangesetConfigFile = typeof ChangesetConfigFile.Type;
+
+/**
+ * Live {@link ChangesetConfig} reading via {@link ChangesetConfigReader}, cached per root.
+ *
+ * @remarks
+ * Requires `ChangesetConfigReader` (which requires `FileSystem`). Provide
+ * `ChangesetConfigReaderLive` + a platform layer (`NodeContext.layer`).
+ *
+ * @since 0.4.0
+ */
+export declare const ChangesetConfigLive: Layer.Layer<ChangesetConfig, never, ChangesetConfigReader>;
+
 /**
  * Service that reads and decodes the `.changeset/config.json` for a given workspace root.
  *
  * @remarks
  * Automatically detects whether the config uses the Silk changelog adapter
- * (`@savvy-web/changesets`) and decodes as {@link SilkChangesetConfig} or the
- * standard {@link ChangesetConfig} accordingly.
+ * (`@savvy-web/changesets`) and decodes as {@link SilkChangesetConfigFile} or the
+ * standard {@link ChangesetConfigFile} accordingly.
  *
  * @example
  * ```typescript
@@ -256,7 +347,7 @@ declare const ChangesetConfigReader_base: Context.TagClass<ChangesetConfigReader
      *
      * @since 0.1.0
      */
-    readonly read: (root: string) => Effect.Effect<ChangesetConfig | SilkChangesetConfig, ChangesetConfigError>;
+    readonly read: (root: string) => Effect.Effect<ChangesetConfigFile | SilkChangesetConfigFile, ChangesetConfigError>;
 }>;
 
 /**
@@ -270,6 +361,9 @@ declare const ChangesetConfigReader_base: Context.TagClass<ChangesetConfigReader
  */
 export declare const ChangesetConfigReaderLive: Layer.Layer<ChangesetConfigReader, never, FileSystem.FileSystem>;
 
+/** Changeset operating mode for a workspace root. */
+export declare type ChangesetMode = "silk" | "vanilla" | "none";
+
 /** @since 0.2.0 */
 export declare type CheckResult = Data.TaggedEnum<CheckResultDefinition>;
 
@@ -546,104 +640,48 @@ declare const ManagedSection_base: Context.TagClass<ManagedSection, "@savvy-web/
 export declare const ManagedSectionLive: Layer.Layer<ManagedSection, never, FileSystem.FileSystem>;
 
 /**
- * Raised when the `publishConfig` field in a `package.json` is present but invalid.
+ * Ignore-aware override of {@link PublishabilityDetector}. `detect` short-circuits to `[]`
+ * for changeset-ignored packages, then dispatches on {@link ChangesetConfig.mode}:
+ * `none` → `[]`; `silk` → {@link SilkPublishability.detect}; `vanilla` → the library default.
  *
- * @remarks
- * Returned by {@link SilkPublishabilityPlugin.detect} when `publishConfig` exists
- * but cannot be mapped to a valid set of publish targets.
+ * @remarks Requires `FileSystem` + {@link ChangesetConfig} at build.
  *
- * @since 0.1.0
+ * @since 0.4.0
  */
-export declare class PublishConfigError extends PublishConfigError_base<{
-    readonly packageName: string;
-    readonly reason: string;
-}> {
-    get message(): string;
-}
-
-declare const PublishConfigError_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: "PublishConfigError";
-} & Readonly<A>;
-
-/**
- * The publish protocol used when pushing a package to a registry.
- *
- * @remarks
- * `"npm"` covers all npm-compatible registries (npmjs.org, GitHub Packages, custom).
- * `"jsr"` targets the JSR registry via its own publish tool.
- *
- * @since 0.1.0
- */
-export declare const PublishProtocol: Schema.Literal<["npm", "jsr"]>;
-
-/** @since 0.1.0 */
-export declare type PublishProtocol = typeof PublishProtocol.Type;
-
-/**
- * Union of all accepted publish-target representations.
- *
- * @remarks
- * Accepts a {@link PublishTargetShorthand} string (`"npm"`, `"github"`, `"jsr"`),
- * an `https://` URL pointing to a custom npm-compatible registry, or a full
- * {@link PublishTargetObject} with explicit field overrides.
- *
- * @since 0.1.0
- */
-declare const PublishTarget: Schema.Union<[Schema.Literal<["npm", "github", "jsr"]>, Schema.filter<typeof Schema.String>, 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>;
-}>]>;
-
-/** @since 0.1.0 */
-declare type PublishTarget = typeof PublishTarget.Type;
-export { PublishTarget }
-export { PublishTarget as PublishTargetSchema }
+export declare const PublishabilityDetectorAdaptiveLive: Layer.Layer<PublishabilityDetector, never, FileSystem.FileSystem | ChangesetConfig>;
 
-/**
- * Full publish-target configuration expressed as a structured object.
- *
- * @remarks
- * All fields are optional and fall back to sensible defaults when omitted.
- * `protocol` defaults to `"npm"`. `access` defaults to the registry default.
- *
- * @since 0.1.0
- */
-export declare const PublishTargetObject: 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>;
-}>;
+/** A publishable workspace package and the count of its resolved publish targets. */
+export declare interface PublishablePackage {
+    readonly name: string;
+    readonly version: string;
+    readonly path: string;
+    readonly targetCount: number;
+}
 
-/** @since 0.1.0 */
-export declare type PublishTargetObject = typeof PublishTargetObject.Type;
+/** Raw `package.json` shape consumed by {@link SilkPublishability.detect}. */
+export declare interface RawPackageJson {
+    readonly name?: string;
+    readonly version?: string;
+    readonly private?: boolean;
+    readonly publishConfig?: RawPublishConfig;
+}
 
-/**
- * Shorthand string identifiers for common publish destinations.
- *
- * @remarks
- * - `"npm"` — the public npm registry, authenticated via OIDC.
- * - `"github"` — GitHub Packages, authenticated via `GITHUB_TOKEN`.
- * - `"jsr"` — the JSR registry, authenticated via OIDC.
- *
- * @since 0.1.0
- */
-declare const PublishTargetShorthand: Schema.Literal<["npm", "github", "jsr"]>;
+/** Raw `publishConfig` shape (the unschematized fields silk rules consult). */
+export declare interface RawPublishConfig {
+    readonly access?: "public" | "restricted";
+    readonly registry?: string;
+    readonly directory?: string;
+    readonly targets?: ReadonlyArray<RawTargetSpec>;
+}
 
-/** @since 0.1.0 */
-declare type PublishTargetShorthand = typeof PublishTargetShorthand.Type;
-export { PublishTargetShorthand }
-export { PublishTargetShorthand as PublishTargetShorthandSchema }
+/** A single declared publish target in a raw `publishConfig.targets` array. */
+export declare type RawTargetSpec = string | {
+    readonly access?: "public" | "restricted";
+    readonly protocol?: string;
+    readonly registry?: string;
+    readonly directory?: string;
+    readonly provenance?: boolean;
+};
 
 /** @since 0.2.0 */
 export declare type ResolutionPolicy = Data.TaggedEnum<ResolutionPolicyDefinition>;
@@ -729,32 +767,6 @@ export declare type ResolutionPolicyDefinition = {
     readonly RequireMatch: {};
 };
 
-/**
- * Fully resolved publish target with all fields populated and defaults applied.
- *
- * @remarks
- * Produced by {@link TargetResolver.resolve} from any {@link PublishTarget} input.
- * All optional fields from {@link PublishTargetObject} become required here,
- * and `auth` / `tokenEnv` are derived from the registry URL.
- *
- * @since 0.1.0
- */
-declare const ResolvedTarget: 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>;
-}>;
-
-/** @since 0.1.0 */
-declare type ResolvedTarget = typeof ResolvedTarget.Type;
-export { ResolvedTarget }
-export { ResolvedTarget as ResolvedTargetSchema }
-
 /**
  * Result of resolving a {@link ToolDefinition}.
  *
@@ -1018,21 +1030,32 @@ declare const ShellSectionDefinition_base: Schema.TaggedClass<ShellSectionDefini
  * Extended changeset config for repos using the `@savvy-web/changesets` changelog adapter.
  *
  * @remarks
- * Extends {@link ChangesetConfig} with a `_isSilk` marker flag that is automatically
+ * Extends {@link ChangesetConfigFile} with a `_isSilk` marker flag that is automatically
  * set to `true`. Detected by {@link ChangesetConfigReader} when the `changelog` field
  * references `@savvy-web/changesets`.
  *
  * @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>;
+export declare const SilkChangesetConfigFile: 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;
@@ -1040,59 +1063,180 @@ export declare const SilkChangesetConfig: Schema.extend<Schema.Struct<{
 }>>;
 
 /** @since 0.1.0 */
-export declare type SilkChangesetConfig = typeof SilkChangesetConfig.Type;
+export declare type SilkChangesetConfigFile = typeof SilkChangesetConfigFile.Type;
+
+/**
+ * Silk publishability rules over `workspaces-effect`'s {@link PublishTarget}.
+ *
+ * @remarks
+ * In silk mode `private: true` is the norm on workspace `package.json`; publishability is
+ * derived from `publishConfig`, with the `private` flag consulted only as a last-resort
+ * default. All helpers are static so a consumer sees the full rule surface in one place.
+ *
+ * @since 0.4.0
+ */
+export declare class SilkPublishability {
+    /**
+     * Resolve the access for one target spec. String targets always inherit the parent
+     * `publishConfig.access`; object targets use their own `.access` else the parent's.
+     */
+    static resolveTargetAccess(target: RawTargetSpec, parentAccess: "public" | "restricted" | undefined): "public" | "restricted" | undefined;
+    /**
+     * Expand a shorthand string target to a registry URL. `"npm"`/`"github"`/`"jsr"` map to
+     * canonical registries; `http(s)://…` is verbatim; anything else falls back to the parent
+     * `publishConfig.registry` (or the npm default).
+     */
+    static expandShorthand(target: string, parentRegistry: string | undefined): string;
+    /**
+     * Apply silk publishability rules to a raw `package.json`. Targets-first precedence:
+     * `publishConfig.targets` → one PublishTarget per surviving target (regardless of
+     * `private`); else `publishConfig.access` → one target; else `private !== true` → one
+     * default target; else `[]`.
+     */
+    static detect(pkgName: string, raw: RawPackageJson): ReadonlyArray<PublishTarget>;
+    /**
+     * Resolve a package's publish targets via {@link PublishabilityDetector}, then drop any
+     * whose built `directory` package.json is `private: true`. Returned targets keep the
+     * detector's original (possibly package-relative) `directory`.
+     */
+    static resolveTargets(pkg: WorkspacePackage, root: string): Effect.Effect<ReadonlyArray<PublishTarget>, never, PublishabilityDetector | FileSystem.FileSystem>;
+    /**
+     * The publishable, non-ignored packages, resolved through the single
+     * {@link PublishabilityDetector} (which already honors changeset ignore in adaptive mode).
+     */
+    static listPublishable(root: string): Effect.Effect<ReadonlyArray<PublishablePackage>, never, WorkspaceDiscovery | PublishabilityDetector>;
+}
 
 /**
- * Service that determines whether a package is publishable and resolves its targets.
+ * Override of `workspaces-effect`'s {@link PublishabilityDetector} Tag with pure silk rules.
+ *
+ * @remarks Requires `FileSystem` (captured at layer build); `detect` reads the raw
+ * `package.json` from `pkg.packageJsonPath` and applies {@link SilkPublishability.detect}.
+ *
+ * @since 0.4.0
+ */
+export declare const SilkPublishabilityDetectorLive: Layer.Layer<PublishabilityDetector, never, FileSystem.FileSystem>;
+
+/**
+ * Silk-extended publishConfig schema.
  *
  * @remarks
- * Inspects the `package.json` object using the Silk publishability rules:
- * - `private: true` with no `publishConfig` → not publishable (empty array).
- * - `publishConfig` without `access` or `targets` → not publishable.
- * - `publishConfig.targets` (array) → resolved via {@link TargetResolver}.
- * - `publishConfig.registry` → resolved as a single registry target.
- * - Default → resolved as `"npm"`.
+ * 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 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 plugin = yield* SilkPublishabilityPlugin;
- *     return yield* plugin.detect({ publishConfig: { access: "public" } });
+ *     const analyzer = yield* SilkWorkspaceAnalyzer;
+ *     return yield* analyzer.analyze("/path/to/monorepo");
  *   }).pipe(
- *     Effect.provide(SilkPublishabilityPluginLive),
- *     Effect.provide(TargetResolverLive),
+ *     Effect.provide(SilkWorkspaceAnalyzerLive),
+ *     // ... provide all transitive layers
  *   )
  * );
  * ```
  *
- * @since 0.1.0
+ * @since 0.2.0
  */
-export declare class SilkPublishabilityPlugin extends SilkPublishabilityPlugin_base {
+export declare class SilkWorkspaceAnalyzer extends SilkWorkspaceAnalyzer_base {
 }
 
-declare const SilkPublishabilityPlugin_base: Context.TagClass<SilkPublishabilityPlugin, "@savvy-web/silk-effects/SilkPublishabilityPlugin", {
+declare const SilkWorkspaceAnalyzer_base: Context.TagClass<SilkWorkspaceAnalyzer, "@savvy-web/silk-effects/SilkWorkspaceAnalyzer", {
     /**
-     * Inspect a parsed `package.json` object and return the resolved publish targets.
+     * Analyze a workspace root and produce a full {@link WorkspaceAnalysis}.
      *
-     * @param pkgJson - The parsed `package.json` contents.
-     * @returns An `Effect` that succeeds with an array of {@link ResolvedTarget} records
-     *   (empty when the package is not publishable), or fails with {@link TargetResolutionError}.
+     * @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.1.0
+     * @since 0.2.0
      */
-    readonly detect: (pkgJson: Record<string, unknown>) => Effect.Effect<ReadonlyArray<ResolvedTarget>, TargetResolutionError>;
+    readonly analyze: (root: string) => Effect.Effect<WorkspaceAnalysis, WorkspaceAnalysisError>;
 }>;
 
 /**
- * Live implementation of {@link SilkPublishabilityPlugin}.
+ * Live implementation of {@link SilkWorkspaceAnalyzer}.
  *
  * @remarks
- * Requires {@link TargetResolver} to resolve target strings and objects.
+ * Requires {@link WorkspaceDiscovery}, {@link PackageManagerDetector},
+ * {@link ChangesetConfigReader}, {@link VersioningStrategy}, and {@link TagStrategy}.
  *
- * @since 0.1.0
+ * @since 0.2.0
  */
-export declare const SilkPublishabilityPluginLive: Layer.Layer<SilkPublishabilityPlugin, never, TargetResolver>;
+export declare const SilkWorkspaceAnalyzerLive: Layer.Layer<SilkWorkspaceAnalyzer, never, FileSystem.FileSystem | WorkspaceDiscovery | TopologicalSorter | PackageManagerDetector | ChangesetConfigReader | VersioningStrategy | TagStrategy>;
 
 /** @since 0.2.0 */
 export declare type SourceRequirement = Data.TaggedEnum<SourceRequirementDefinition>;
@@ -1354,72 +1498,6 @@ export declare const TagStrategyType: Schema.Literal<["single", "scoped"]>;
 /** @since 0.1.0 */
 export declare type TagStrategyType = typeof TagStrategyType.Type;
 
-/**
- * Raised when a publish target value cannot be resolved into a {@link ResolvedTarget}.
- *
- * @remarks
- * Returned by {@link TargetResolver.resolve} when the input is not a recognised shorthand,
- * a valid `https://` URL, or a well-formed object target.
- *
- * @since 0.1.0
- */
-export declare class TargetResolutionError extends TargetResolutionError_base<{
-    readonly target: unknown;
-    readonly reason: string;
-}> {
-    get message(): string;
-}
-
-declare const TargetResolutionError_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: "TargetResolutionError";
-} & Readonly<A>;
-
-/**
- * Service that resolves raw publish-target values into fully-normalised {@link ResolvedTarget} records.
- *
- * @remarks
- * Accepts a single target or an array of targets. Each item may be a
- * {@link PublishTargetShorthand} string, an `https://` registry URL, or a
- * {@link PublishTargetObject}. Unknown values produce a {@link TargetResolutionError}.
- *
- * @example
- * ```typescript
- * const result = await Effect.runPromise(
- *   Effect.gen(function* () {
- *     const resolver = yield* TargetResolver;
- *     return yield* resolver.resolve("npm");
- *   }).pipe(Effect.provide(TargetResolverLive))
- * );
- * ```
- *
- * @since 0.1.0
- */
-export declare class TargetResolver extends TargetResolver_base {
-}
-
-declare const TargetResolver_base: Context.TagClass<TargetResolver, "@savvy-web/silk-effects/TargetResolver", {
-    /**
-     * Resolve one target (or an array of targets) into an array of {@link ResolvedTarget} records.
-     *
-     * @param target - A single publish-target value or an array of them.
-     * @returns An `Effect` that succeeds with the resolved targets or fails with {@link TargetResolutionError}.
-     *
-     * @since 0.1.0
-     */
-    readonly resolve: (target: unknown) => Effect.Effect<ReadonlyArray<ResolvedTarget>, TargetResolutionError>;
-}>;
-
-/**
- * Live implementation of {@link TargetResolver} with no external dependencies.
- *
- * @remarks
- * All resolution logic is pure: shorthand strings, `https://` URLs, and object targets
- * are mapped to {@link ResolvedTarget} records without any I/O.
- *
- * @since 0.1.0
- */
-export declare const TargetResolverLive: Layer.Layer<TargetResolver, never, never>;
-
 /**
  * Wraps `@effect/platform` {@link Command.Command} with instance method ergonomics.
  *
@@ -1782,4 +1860,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 { }