@savvy-web/mcp 1.3.3 → 1.3.4

package/public/content/packages/silk-effects/api/variable/sectiondiff.md

@@ -0,0 +1,70 @@
+---
+id: packages/silk-effects/api/variable/sectiondiff
+title: "SectionDiff — silk-effects variable"
+summary: "variable SectionDiff from @savvy-web/silk-effects."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# SectionDiff
+
+```ts
+SectionDiff: {
+  readonly Unchanged: Data.Case.Constructor<{
+    readonly _tag: "Unchanged";
+  }, "_tag">;
+  readonly Changed: Data.Case.Constructor<{
+    readonly _tag: "Changed";
+    readonly added: ReadonlyArray<string>;
+    readonly removed: ReadonlyArray<string>;
+  }, "_tag">;
+  readonly $is: <Tag extends "Unchanged" | "Changed">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Unchanged";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Changed";
+    readonly added: ReadonlyArray<string>;
+    readonly removed: ReadonlyArray<string>;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <const Cases extends {
+      readonly Unchanged: (args: {
+        readonly _tag: "Unchanged";
+      }) => any;
+      readonly Changed: (args: {
+        readonly _tag: "Changed";
+        readonly added: ReadonlyArray<string>;
+        readonly removed: ReadonlyArray<string>;
+      }) => any;
+    }>(cases: Cases & { [K in Exclude<keyof Cases, "Unchanged" | "Changed">]: never }): (value: {
+      readonly _tag: "Unchanged";
+    } | {
+      readonly _tag: "Changed";
+      readonly added: ReadonlyArray<string>;
+      readonly removed: ReadonlyArray<string>;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Unchanged" | "Changed"]>>;
+    <const Cases extends {
+      readonly Unchanged: (args: {
+        readonly _tag: "Unchanged";
+      }) => any;
+      readonly Changed: (args: {
+        readonly _tag: "Changed";
+        readonly added: ReadonlyArray<string>;
+        readonly removed: ReadonlyArray<string>;
+      }) => any;
+    }>(value: {
+      readonly _tag: "Unchanged";
+    } | {
+      readonly _tag: "Changed";
+      readonly added: ReadonlyArray<string>;
+      readonly removed: ReadonlyArray<string>;
+    }, cases: Cases & { [K in Exclude<keyof Cases, "Unchanged" | "Changed">]: never }): import("effect/Unify").Unify<ReturnType<Cases["Unchanged" | "Changed"]>>;
+  };
+}
+```

package/public/content/packages/silk-effects/api/variable/silkchangesetconfigfile.md

@@ -0,0 +1,40 @@
+---
+id: packages/silk-effects/api/variable/silkchangesetconfigfile
+title: "SilkChangesetConfigFile — silk-effects variable"
+summary: "variable SilkChangesetConfigFile from @savvy-web/silk-effects."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# SilkChangesetConfigFile
+
+```ts
+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;
+  }>;
+}>>
+```

package/public/content/packages/silk-effects/api/variable/silkpublishabilitydetectorlive.md

@@ -0,0 +1,18 @@
+---
+id: packages/silk-effects/api/variable/silkpublishabilitydetectorlive
+title: "SilkPublishabilityDetectorLive — silk-effects variable"
+summary: "Override of `workspaces-effect`'s SilkPublishability Tag with pure silk rules."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# SilkPublishabilityDetectorLive
+
+Override of `workspaces-effect`'s [SilkPublishability](silk://packages/silk-effects/api/class/silkpublishability) Tag with pure silk rules.
+
+```ts
+SilkPublishabilityDetectorLive: Layer.Layer<PublishabilityDetector, never, FileSystem.FileSystem>
+```

package/public/content/packages/silk-effects/api/variable/silkworkspaceanalyzerlive.md

@@ -0,0 +1,20 @@
+---
+id: packages/silk-effects/api/variable/silkworkspaceanalyzerlive
+title: "SilkWorkspaceAnalyzerLive — silk-effects variable"
+summary: "Live implementation of SilkWorkspaceAnalyzer."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# SilkWorkspaceAnalyzerLive
+
+Live implementation of [SilkWorkspaceAnalyzer](silk://packages/silk-effects/api/class/silkworkspaceanalyzer).
+
+```ts
+SilkWorkspaceAnalyzerLive: Layer.Layer<SilkWorkspaceAnalyzer, never, FileSystem.FileSystem |
+  WorkspaceDiscovery | TopologicalSorter | PackageManagerDetector | ChangesetConfigReader |
+  VersioningStrategy | TagStrategy>
+```

package/public/content/packages/silk-effects/api/variable/sourcerequirement.md

@@ -0,0 +1,92 @@
+---
+id: packages/silk-effects/api/variable/sourcerequirement
+title: "SourceRequirement — silk-effects variable"
+summary: "variable SourceRequirement from @savvy-web/silk-effects."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# SourceRequirement
+
+```ts
+SourceRequirement: {
+  readonly Any: Data.Case.Constructor<{
+    readonly _tag: "Any";
+  }, "_tag">;
+  readonly OnlyLocal: Data.Case.Constructor<{
+    readonly _tag: "OnlyLocal";
+  }, "_tag">;
+  readonly OnlyGlobal: Data.Case.Constructor<{
+    readonly _tag: "OnlyGlobal";
+  }, "_tag">;
+  readonly Both: Data.Case.Constructor<{
+    readonly _tag: "Both";
+  }, "_tag">;
+  readonly $is: <Tag extends "Any" | "OnlyLocal" | "OnlyGlobal" | "Both">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Any";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "OnlyLocal";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "OnlyGlobal";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Both";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <const Cases extends {
+      readonly Any: (args: {
+        readonly _tag: "Any";
+      }) => any;
+      readonly OnlyLocal: (args: {
+        readonly _tag: "OnlyLocal";
+      }) => any;
+      readonly OnlyGlobal: (args: {
+        readonly _tag: "OnlyGlobal";
+      }) => any;
+      readonly Both: (args: {
+        readonly _tag: "Both";
+      }) => any;
+    }>(cases: Cases & { [K in Exclude<keyof Cases, "Any" | "OnlyLocal" | "OnlyGlobal" | "Both">]: never }): (value: {
+      readonly _tag: "Any";
+    } | {
+      readonly _tag: "OnlyLocal";
+    } | {
+      readonly _tag: "OnlyGlobal";
+    } | {
+      readonly _tag: "Both";
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Any" | "OnlyLocal" | "OnlyGlobal" | "Both"]>>;
+    <const Cases extends {
+      readonly Any: (args: {
+        readonly _tag: "Any";
+      }) => any;
+      readonly OnlyLocal: (args: {
+        readonly _tag: "OnlyLocal";
+      }) => any;
+      readonly OnlyGlobal: (args: {
+        readonly _tag: "OnlyGlobal";
+      }) => any;
+      readonly Both: (args: {
+        readonly _tag: "Both";
+      }) => any;
+    }>(value: {
+      readonly _tag: "Any";
+    } | {
+      readonly _tag: "OnlyLocal";
+    } | {
+      readonly _tag: "OnlyGlobal";
+    } | {
+      readonly _tag: "Both";
+    }, cases: Cases & { [K in Exclude<keyof Cases, "Any" | "OnlyLocal" | "OnlyGlobal" | "Both">]: never }): import("effect/Unify").Unify<ReturnType<Cases["Any" | "OnlyLocal" | "OnlyGlobal" | "Both"]>>;
+  };
+}
+```

package/public/content/packages/silk-effects/api/variable/syncresult.md

@@ -0,0 +1,81 @@
+---
+id: packages/silk-effects/api/variable/syncresult
+title: "SyncResult — silk-effects variable"
+summary: "variable SyncResult from @savvy-web/silk-effects."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# SyncResult
+
+```ts
+SyncResult: {
+  readonly Unchanged: Data.Case.Constructor<{
+    readonly _tag: "Unchanged";
+  }, "_tag">;
+  readonly Created: Data.Case.Constructor<{
+    readonly _tag: "Created";
+  }, "_tag">;
+  readonly Updated: Data.Case.Constructor<{
+    readonly _tag: "Updated";
+    readonly diff: SectionDiff;
+  }, "_tag">;
+  readonly $is: <Tag extends "Unchanged" | "Created" | "Updated">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Unchanged";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Created";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Updated";
+    readonly diff: SectionDiff;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <const Cases extends {
+      readonly Unchanged: (args: {
+        readonly _tag: "Unchanged";
+      }) => any;
+      readonly Created: (args: {
+        readonly _tag: "Created";
+      }) => any;
+      readonly Updated: (args: {
+        readonly _tag: "Updated";
+        readonly diff: SectionDiff;
+      }) => any;
+    }>(cases: Cases & { [K in Exclude<keyof Cases, "Unchanged" | "Created" | "Updated">]: never }): (value: {
+      readonly _tag: "Unchanged";
+    } | {
+      readonly _tag: "Created";
+    } | {
+      readonly _tag: "Updated";
+      readonly diff: SectionDiff;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Unchanged" | "Created" | "Updated"]>>;
+    <const Cases extends {
+      readonly Unchanged: (args: {
+        readonly _tag: "Unchanged";
+      }) => any;
+      readonly Created: (args: {
+        readonly _tag: "Created";
+      }) => any;
+      readonly Updated: (args: {
+        readonly _tag: "Updated";
+        readonly diff: SectionDiff;
+      }) => any;
+    }>(value: {
+      readonly _tag: "Unchanged";
+    } | {
+      readonly _tag: "Created";
+    } | {
+      readonly _tag: "Updated";
+      readonly diff: SectionDiff;
+    }, cases: Cases & { [K in Exclude<keyof Cases, "Unchanged" | "Created" | "Updated">]: never }): import("effect/Unify").Unify<ReturnType<Cases["Unchanged" | "Created" | "Updated"]>>;
+  };
+}
+```

package/public/content/packages/silk-effects/api/variable/tagstrategylive.md

@@ -0,0 +1,18 @@
+---
+id: packages/silk-effects/api/variable/tagstrategylive
+title: "TagStrategyLive — silk-effects variable"
+summary: "Live implementation of TagStrategy with no external dependencies."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# TagStrategyLive
+
+Live implementation of [TagStrategy](silk://packages/silk-effects/api/class/tagstrategy) with no external dependencies.
+
+```ts
+TagStrategyLive: Layer.Layer<TagStrategy>
+```

package/public/content/packages/silk-effects/api/variable/tagstrategytype.md

@@ -0,0 +1,18 @@
+---
+id: packages/silk-effects/api/variable/tagstrategytype
+title: "TagStrategyType — silk-effects variable"
+summary: "Git tag naming strategy for a workspace."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# TagStrategyType
+
+Git tag naming strategy for a workspace.
+
+```ts
+TagStrategyType: Schema.Literal<["single", "scoped"]>
+```

package/public/content/packages/silk-effects/api/variable/tooldiscoverylive.md

@@ -0,0 +1,19 @@
+---
+id: packages/silk-effects/api/variable/tooldiscoverylive
+title: "ToolDiscoveryLive — silk-effects variable"
+summary: "Live implementation of ToolDiscovery."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# ToolDiscoveryLive
+
+Live implementation of [ToolDiscovery](silk://packages/silk-effects/api/class/tooldiscovery).
+
+```ts
+ToolDiscoveryLive: Layer.Layer<ToolDiscovery, never, CommandExecutor.CommandExecutor |
+  PackageManagerDetector | WorkspaceRoot>
+```

package/public/content/packages/silk-effects/api/variable/toolsource.md

@@ -0,0 +1,18 @@
+---
+id: packages/silk-effects/api/variable/toolsource
+title: "ToolSource — silk-effects variable"
+summary: "Where a tool was resolved from."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# ToolSource
+
+Where a tool was resolved from.
+
+```ts
+ToolSource: Schema.Literal<["global", "local"]>
+```

package/public/content/packages/silk-effects/api/variable/versionextractor.md

@@ -0,0 +1,99 @@
+---
+id: packages/silk-effects/api/variable/versionextractor
+title: "VersionExtractor — silk-effects variable"
+summary: "variable VersionExtractor from @savvy-web/silk-effects."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# VersionExtractor
+
+```ts
+VersionExtractor: {
+  readonly Flag: Data.Case.Constructor<{
+    readonly _tag: "Flag";
+    readonly flag: string;
+    readonly parse?: ((output: string) => string) | undefined | undefined;
+  }, "_tag">;
+  readonly Json: Data.Case.Constructor<{
+    readonly _tag: "Json";
+    readonly flag: string;
+    readonly path: string;
+  }, "_tag">;
+  readonly None: Data.Case.Constructor<{
+    readonly _tag: "None";
+  }, "_tag">;
+  readonly $is: <Tag extends "Flag" | "Json" | "None">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Flag";
+    readonly flag: string;
+    readonly parse?: ((output: string) => string) | undefined | undefined;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Json";
+    readonly flag: string;
+    readonly path: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "None";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <const Cases extends {
+      readonly Flag: (args: {
+        readonly _tag: "Flag";
+        readonly flag: string;
+        readonly parse?: ((output: string) => string) | undefined | undefined;
+      }) => any;
+      readonly Json: (args: {
+        readonly _tag: "Json";
+        readonly flag: string;
+        readonly path: string;
+      }) => any;
+      readonly None: (args: {
+        readonly _tag: "None";
+      }) => any;
+    }>(cases: Cases & { [K in Exclude<keyof Cases, "Flag" | "Json" | "None">]: never }): (value: {
+      readonly _tag: "Flag";
+      readonly flag: string;
+      readonly parse?: ((output: string) => string) | undefined | undefined;
+    } | {
+      readonly _tag: "Json";
+      readonly flag: string;
+      readonly path: string;
+    } | {
+      readonly _tag: "None";
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Flag" | "Json" | "None"]>>;
+    <const Cases extends {
+      readonly Flag: (args: {
+        readonly _tag: "Flag";
+        readonly flag: string;
+        readonly parse?: ((output: string) => string) | undefined | undefined;
+      }) => any;
+      readonly Json: (args: {
+        readonly _tag: "Json";
+        readonly flag: string;
+        readonly path: string;
+      }) => any;
+      readonly None: (args: {
+        readonly _tag: "None";
+      }) => any;
+    }>(value: {
+      readonly _tag: "Flag";
+      readonly flag: string;
+      readonly parse?: ((output: string) => string) | undefined | undefined;
+    } | {
+      readonly _tag: "Json";
+      readonly flag: string;
+      readonly path: string;
+    } | {
+      readonly _tag: "None";
+    }, cases: Cases & { [K in Exclude<keyof Cases, "Flag" | "Json" | "None">]: never }): import("effect/Unify").Unify<ReturnType<Cases["Flag" | "Json" | "None"]>>;
+  };
+}
+```

package/public/content/packages/silk-effects/api/variable/versioningstrategylive.md

@@ -0,0 +1,18 @@
+---
+id: packages/silk-effects/api/variable/versioningstrategylive
+title: "VersioningStrategyLive — silk-effects variable"
+summary: "Live implementation of VersioningStrategy."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# VersioningStrategyLive
+
+Live implementation of [VersioningStrategy](silk://packages/silk-effects/api/class/versioningstrategy).
+
+```ts
+VersioningStrategyLive: Layer.Layer<VersioningStrategy, never, ChangesetConfigReader>
+```

package/public/content/packages/silk-effects/api/variable/versioningstrategyresult.md

@@ -0,0 +1,22 @@
+---
+id: packages/silk-effects/api/variable/versioningstrategyresult
+title: "VersioningStrategyResult — silk-effects variable"
+summary: "Output of the versioning strategy detection, combining the strategy type with group metadata."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# VersioningStrategyResult
+
+Output of the versioning strategy detection, combining the strategy type with group metadata.
+
+```ts
+VersioningStrategyResult: Schema.Struct<{
+  type: Schema.Literal<["single", "fixed-group", "independent"]>;
+  fixedGroups: Schema.Array$<Schema.Array$<typeof Schema.String>>;
+  publishablePackages: Schema.Array$<typeof Schema.String>;
+}>
+```

package/public/content/packages/silk-effects/api/variable/versioningstrategytype.md

@@ -0,0 +1,18 @@
+---
+id: packages/silk-effects/api/variable/versioningstrategytype
+title: "VersioningStrategyType — silk-effects variable"
+summary: "Versioning strategy classification for a workspace."
+tier: packages
+source: generated
+tags: [silk-effects, api]
+priority: 0.3
+related: []
+---
+
+# VersioningStrategyType
+
+Versioning strategy classification for a workspace.
+
+```ts
+VersioningStrategyType: Schema.Literal<["single", "fixed-group", "independent"]>
+```