@savvy-web/silk-effects 0.3.0 → 0.4.1

package/index.d.ts

@@ -21,13 +21,16 @@ 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';
 
@@ -45,7 +48,7 @@ export declare class AnalyzedWorkspace extends AnalyzedWorkspace_base {
     get isLinked(): boolean;
     publishesTo(registry: string): boolean;
     hasTarget(shorthand: "npm" | "github" | "jsr"): boolean;
-    targetFor(registry: string): Option.Option<ResolvedTarget>;
+    targetFor(registry: string): Option.Option<PublishTarget>;
     [Equal.symbol](that: Equal.Equal): boolean;
     [Hash.symbol](): number;
     toString(): string;
@@ -71,16 +74,7 @@ declare const AnalyzedWorkspace_base: Schema.TaggedClass<AnalyzedWorkspace, "Ana
     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>;
-    }>>;
+    targets: Schema.Array$<typeof PublishTarget>;
     versioned: typeof Schema.Boolean;
     tagged: typeof Schema.Boolean;
     released: typeof Schema.Boolean;
@@ -88,20 +82,6 @@ declare const AnalyzedWorkspace_base: Schema.TaggedClass<AnalyzedWorkspace, "Ana
     fixed: Schema.Array$<Schema.suspend<unknown, unknown, unknown>>;
 }>;
 
-/**
- * Authentication strategy used to obtain publish credentials.
- *
- * @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
- */
-export declare const AuthStrategy: Schema.Literal<["oidc", "token"]>;
-
-/** @since 0.1.0 */
-export declare type AuthStrategy = typeof AuthStrategy.Type;
-
 /**
  * Service that keeps the `$schema` URL in Biome config files in sync with a target version.
  *
@@ -238,17 +218,65 @@ export declare type BiomeSyncResult = typeof BiomeSyncResult.Type;
  */
 export declare function buildSchemaUrl(version: string): string;
 
+/**
+ * Accessor service over a workspace root's `.changeset/config.json`.
+ *
+ * @remarks
+ * 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.4.0
+ */
+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;
+}
+
+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.
+ *
+ * @remarks
+ * Returned by {@link ChangesetConfigReader.read} when the file is missing,
+ * contains invalid JSON, or fails Effect Schema validation.
+ *
+ * @since 0.1.0
+ */
+export declare class ChangesetConfigError extends ChangesetConfigError_base<{
+    readonly path: string;
+    readonly reason: string;
+}> {
+    get message(): string;
+}
+
+declare const ChangesetConfigError_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: "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 SilkChangesetConfig} when the Silk changelog
+ * to allow partial configs. Use {@link SilkChangesetConfigFile} when the Silk changelog
  * adapter is detected.
  *
  * @since 0.1.0
  */
-export declare const ChangesetConfig: Schema.Struct<{
+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>>>;
@@ -271,35 +299,26 @@ export declare const ChangesetConfig: Schema.Struct<{
 }>;
 
 /** @since 0.1.0 */
-export declare type ChangesetConfig = typeof ChangesetConfig.Type;
+export declare type ChangesetConfigFile = typeof ChangesetConfigFile.Type;
 
 /**
- * Raised when the `.changeset/config.json` file cannot be read or decoded.
+ * Live {@link ChangesetConfig} reading via {@link ChangesetConfigReader}, cached per root.
  *
  * @remarks
- * Returned by {@link ChangesetConfigReader.read} when the file is missing,
- * contains invalid JSON, or fails Effect Schema validation.
+ * Requires `ChangesetConfigReader` (which requires `FileSystem`). Provide
+ * `ChangesetConfigReaderLive` + a platform layer (`NodeContext.layer`).
  *
- * @since 0.1.0
+ * @since 0.4.0
  */
-export declare class ChangesetConfigError extends ChangesetConfigError_base<{
-    readonly path: string;
-    readonly reason: string;
-}> {
-    get message(): string;
-}
-
-declare const ChangesetConfigError_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: "ChangesetConfigError";
-} & Readonly<A>;
+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
@@ -328,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>;
 }>;
 
 /**
@@ -342,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>;
 
@@ -618,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.
- *
- * @remarks
- * Returned by {@link SilkPublishabilityPlugin.detect} when `publishConfig` exists
- * but cannot be mapped to a valid set of publish targets.
- *
- * @since 0.1.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.
+ * 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
- * 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.
+ * @remarks Requires `FileSystem` + {@link ChangesetConfig} at build.
  *
- * @since 0.1.0
+ * @since 0.4.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>;
@@ -801,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}.
  *
@@ -1090,13 +1030,13 @@ 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<{
+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>>>;
@@ -1123,59 +1063,59 @@ 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;
 
 /**
- * Service that determines whether a package is publishable and resolves its targets.
+ * Silk publishability rules over `workspaces-effect`'s {@link PublishTarget}.
  *
  * @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"`.
- *
- * @example
- * ```typescript
- * const result = await Effect.runPromise(
- *   Effect.gen(function* () {
- *     const plugin = yield* SilkPublishabilityPlugin;
- *     return yield* plugin.detect({ publishConfig: { access: "public" } });
- *   }).pipe(
- *     Effect.provide(SilkPublishabilityPluginLive),
- *     Effect.provide(TargetResolverLive),
- *   )
- * );
- * ```
+ * 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.1.0
+ * @since 0.4.0
  */
-export declare class SilkPublishabilityPlugin extends SilkPublishabilityPlugin_base {
-}
-
-declare const SilkPublishabilityPlugin_base: Context.TagClass<SilkPublishabilityPlugin, "@savvy-web/silk-effects/SilkPublishabilityPlugin", {
+export declare class SilkPublishability {
     /**
-     * Inspect a parsed `package.json` object and return the resolved publish targets.
-     *
-     * @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}.
-     *
-     * @since 0.1.0
+     * 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.
      */
-    readonly detect: (pkgJson: Record<string, unknown>) => Effect.Effect<ReadonlyArray<ResolvedTarget>, TargetResolutionError>;
-}>;
+    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>;
+}
 
 /**
- * Live implementation of {@link SilkPublishabilityPlugin}.
+ * Override of `workspaces-effect`'s {@link PublishabilityDetector} Tag with pure silk rules.
  *
- * @remarks
- * Requires {@link TargetResolver} to resolve target strings and objects.
+ * @remarks Requires `FileSystem` (captured at layer build); `detect` reads the raw
+ * `package.json` from `pkg.packageJsonPath` and applies {@link SilkPublishability.detect}.
  *
- * @since 0.1.0
+ * @since 0.4.0
  */
-export declare const SilkPublishabilityPluginLive: Layer.Layer<SilkPublishabilityPlugin, never, TargetResolver>;
+export declare const SilkPublishabilityDetectorLive: Layer.Layer<PublishabilityDetector, never, FileSystem.FileSystem>;
 
 /**
  * Silk-extended publishConfig schema.
@@ -1250,9 +1190,9 @@ declare const SilkPublishConfig_base: Schema.Class<SilkPublishConfig, {
  *
  * @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.
+ * {@link ChangesetConfigReader}, {@link VersioningStrategy}, and
+ * {@link TagStrategy} to produce a complete {@link WorkspaceAnalysis} for a
+ * given workspace root.
  *
  * @example
  * ```typescript
@@ -1292,12 +1232,11 @@ declare const SilkWorkspaceAnalyzer_base: Context.TagClass<SilkWorkspaceAnalyzer
  *
  * @remarks
  * Requires {@link WorkspaceDiscovery}, {@link PackageManagerDetector},
- * {@link SilkPublishabilityPlugin}, {@link ChangesetConfigReader},
- * {@link VersioningStrategy}, and {@link TagStrategy}.
+ * {@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>;
+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>;
@@ -1559,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.
  *