@savvy-web/mcp 3.2.4 → 3.3.0

package/errors.js

@@ -1,117 +1,59 @@
+import { ToolFailure } from "@effected/mcp";
 import { Schema } from "effect";
 
 //#region src/errors.ts
 /**
-* The one typed failure union every savvy-mcp tool declares, plus the helpers
-* that keep each member's `message` self-contained on the wire.
-*
-* @remarks
-* Under `failureMode: "error"` (the only mode these tools use) a declared
-* typed failure reaches the client as
-* `{ isError: true, content: [{ type: "text", text: error.message }] }` and
-* `structuredContent` is never populated for it
-* (rc.116's `registerToolkit`, `declaredFailureResult` in
-* `.repos/effect/packages/effect/src/unstable/ai/McpServer.ts` — see the
-* header of `server.ts`). So a structured `remediation`
-* field is invisible to a real client: every member folds its hint into
-* `message` at construction through {@link composeRemediatedMessage}, and any
-* caller-supplied value echoed back passes through {@link truncateEchoed}.
-*
-* @packageDocumentation
-*/
-/** What a caller should do next about a failed tool call. @public */
-const Remediation = Schema.Struct({
-	hint: Schema.String,
-	suggestedTool: Schema.optionalKey(Schema.String)
-});
-/**
-* Compose a self-contained wire message from a raw cause message and its
-* remediation: the human message, then the hint, then `Try <suggestedTool>.`
-* when one is present. Every {@link McpToolError} member's `message` is built
-* through this at construction, because `message` is the only field a
-* declared failure delivers to the wire.
-*
-* @public
-*/
-const composeRemediatedMessage = (message, remediation) => remediation.suggestedTool === void 0 ? `${message} ${remediation.hint}` : `${message} ${remediation.hint} Try ${remediation.suggestedTool}.`;
-const ECHO_LIMIT = 200;
-/**
-* The limit for an ENGINE message echoed through {@link engineError} or an
-* argument-decode message: wider than {@link truncateEchoed}'s default because
-* the engine's own rendering (a git stderr, a decode path) is the diagnostic,
-* but still bounded — the kit embeds caller values (`base`, `task`, the
-* decoded value) in those messages untruncated.
-*/
-const ENGINE_ECHO_LIMIT = 2e3;
-/**
-* Truncate a caller-supplied value before it is echoed back inside an error's
-* `message`. Without this a pathological argument (a multi-megabyte `cwd`,
-* say) is echoed once in the response's `content[0].text` and once more in the
-* corresponding log line, burning an agent's context twice on what is usually
-* a typo.
-*
-* @public
-*/
-const truncateEchoed = (value, limit = ECHO_LIMIT) => value.length > limit ? `${value.slice(0, limit)}…` : value;
-/**
 * No workspace root was found walking up from the requested directory.
-* `message` is composed through {@link composeRemediatedMessage} at
-* construction, so it is what reaches the wire as `content[0].text`.
+* `message` is composed through `ToolFailure.message` at construction, so it
+* is what reaches the wire as `content[0].text`.
 *
 * @public
 */
 var WorkspaceNotFound = class extends Schema.TaggedError()("WorkspaceNotFound", {
-	cwd: Schema.String,
-	message: Schema.String,
-	remediation: Remediation
+	...ToolFailure.fields,
+	cwd: Schema.String
 }) {};
 /**
 * A tool argument was structurally acceptable but semantically invalid — a
 * `repos_manage` action missing the field it needs, a `biome_check` path
 * outside the workspace, a `changeset_validate` directory that does not
-* exist. `message` is composed through {@link composeRemediatedMessage}.
+* exist. `message` is composed through `ToolFailure.message`.
 *
 * @public
 */
 var InvalidArgument = class extends Schema.TaggedError()("InvalidArgument", {
-	argument: Schema.String,
-	message: Schema.String,
-	remediation: Remediation
+	...ToolFailure.fields,
+	argument: Schema.String
 }) {};
 /**
 * A silk-effects engine program failed with one of its own typed errors
 * (`TurboError`, `GitError`, `ReposConfigError`, …). `source` carries that
 * error's `_tag`; `message` is its own rendering plus the remediation,
-* composed through {@link composeRemediatedMessage}.
+* composed through `ToolFailure.message`.
 *
 * @public
 */
 var EngineError = class extends Schema.TaggedError()("EngineError", {
-	source: Schema.String,
-	message: Schema.String,
-	remediation: Remediation
+	...ToolFailure.fields,
+	source: Schema.String
 }) {};
 /**
 * No Biome binary could be located. `message` is composed through
-* {@link composeRemediatedMessage}.
+* `ToolFailure.message`.
 *
 * @public
 */
-var BiomeUnavailable = class extends Schema.TaggedError()("BiomeUnavailable", {
-	message: Schema.String,
-	remediation: Remediation
-}) {};
+var BiomeUnavailable = class extends Schema.TaggedError()("BiomeUnavailable", { ...ToolFailure.fields }) {};
 /**
 * Biome itself failed (exit status above 1, a spawn error, or a timeout) —
 * distinct from "lint issues found", which is a successful result. `message`
-* is composed through {@link composeRemediatedMessage}.
+* is composed through `ToolFailure.message`.
 *
 * @public
 */
 var BiomeFailed = class extends Schema.TaggedError()("BiomeFailed", {
-	exitCode: Schema.optionalKey(Schema.Number),
-	message: Schema.String,
-	remediation: Remediation
+	...ToolFailure.fields,
+	exitCode: Schema.optionalKey(Schema.Number)
 }) {};
 /** The one failure schema every savvy-mcp tool declares. @public */
 const McpToolError = Schema.Union([
@@ -130,13 +72,13 @@ const WORKSPACE_REMEDIATION = {
 * Build a {@link WorkspaceNotFound} for the directory the caller asked about.
 * The kit's own `WorkspaceRootNotFoundError` message renders the search path
 * and probed markers; it is not echoed because it embeds the untruncated
-* caller value, which `cwd` already carries through {@link truncateEchoed}.
+* caller value, which `cwd` already carries through `ToolFailure.truncate`.
 *
 * @public
 */
 const workspaceNotFound = (cwd) => new WorkspaceNotFound({
 	cwd,
-	message: composeRemediatedMessage(`No workspace root was found walking up from "${truncateEchoed(cwd)}".`, WORKSPACE_REMEDIATION),
+	message: ToolFailure.message(`No workspace root was found walking up from "${ToolFailure.truncate(cwd)}".`, WORKSPACE_REMEDIATION),
 	remediation: WORKSPACE_REMEDIATION
 });
 /**
@@ -147,21 +89,21 @@ const workspaceNotFound = (cwd) => new WorkspaceNotFound({
 */
 const invalidArgument = (argument, raw, remediation) => new InvalidArgument({
 	argument,
-	message: composeRemediatedMessage(raw, remediation),
+	message: ToolFailure.message(raw, remediation),
 	remediation
 });
 /**
 * Build an {@link EngineError} from a silk-effects typed error. Every engine
 * error in this server renders itself through a `message` getter, so that
-* rendering is the raw message — passed through {@link truncateEchoed} at
-* {@link ENGINE_ECHO_LIMIT}, since the kit embeds caller values in it;
+* rendering is the raw message — passed through `ToolFailure.truncate` at
+* `ToolFailure.ENGINE_ECHO_LIMIT`, since the kit embeds caller values in it;
 * `source` keeps the tag for anything that inspects the typed error directly.
 *
 * @public
 */
 const engineError = (cause, remediation) => new EngineError({
 	source: cause._tag,
-	message: composeRemediatedMessage(truncateEchoed(cause.message, ENGINE_ECHO_LIMIT), remediation),
+	message: ToolFailure.message(ToolFailure.truncate(cause.message, ToolFailure.ENGINE_ECHO_LIMIT), remediation),
 	remediation
 });
 /**
@@ -179,4 +121,4 @@ const engineError = (cause, remediation) => new EngineError({
 const mapEngineError = (requestedCwd, remediation) => (cause) => cause._tag === "WorkspaceRootNotFoundError" ? workspaceNotFound(requestedCwd) : engineError(cause, remediation);
 
 //#endregion
-export { BiomeFailed, BiomeUnavailable, ENGINE_ECHO_LIMIT, EngineError, InvalidArgument, McpToolError, Remediation, WorkspaceNotFound, composeRemediatedMessage, engineError, invalidArgument, mapEngineError, truncateEchoed, workspaceNotFound };
+export { BiomeFailed, BiomeUnavailable, EngineError, InvalidArgument, McpToolError, WorkspaceNotFound, engineError, invalidArgument, mapEngineError, workspaceNotFound };

package/index.d.ts

@@ -1,82 +1,59 @@
-import { Context, FileSystem, Layer, Path, Schema, Stdio } from "effect";
+import { Distribution } from "@effected/engine";
+import { FileSystem, Layer, Path, Schema, Stdio } from "effect";
 import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets, Repos, SilkWorkspaceAnalyzer, Turbo } from "@savvy-web/silk-effects";
 import { ChildProcessSpawner } from "effect/unstable/process";
 import { Tool, Toolkit } from "effect/unstable/ai";
 //#region src/errors.d.ts
-/** What a caller should do next about a failed tool call. @public */
-export declare const Remediation: Schema.Struct<{
-  readonly hint: Schema.String;
-  readonly suggestedTool: Schema.optionalKey<Schema.String>;
-}>;
-/** @public */
-export type Remediation = typeof Remediation.Type;
-/**
- * Compose a self-contained wire message from a raw cause message and its
- * remediation: the human message, then the hint, then `Try <suggestedTool>.`
- * when one is present. Every {@link McpToolError} member's `message` is built
- * through this at construction, because `message` is the only field a
- * declared failure delivers to the wire.
- *
- * @public
- */
-export declare const composeRemediatedMessage: (message: string, remediation: Remediation) => string;
-/**
- * Truncate a caller-supplied value before it is echoed back inside an error's
- * `message`. Without this a pathological argument (a multi-megabyte `cwd`,
- * say) is echoed once in the response's `content[0].text` and once more in the
- * corresponding log line, burning an agent's context twice on what is usually
- * a typo.
- *
- * @public
- */
-export declare const truncateEchoed: (value: string, limit?: number) => string;
 declare const WorkspaceNotFound_base: Schema.Class<WorkspaceNotFound, Schema.TaggedStruct<"WorkspaceNotFound", {
-  readonly cwd: Schema.String;
   readonly message: Schema.String;
   readonly remediation: Schema.Struct<{
     readonly hint: Schema.String;
     readonly suggestedTool: Schema.optionalKey<Schema.String>;
+    readonly suggestedArgs: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
   }>;
+  readonly cwd: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 /**
  * No workspace root was found walking up from the requested directory.
- * `message` is composed through {@link composeRemediatedMessage} at
- * construction, so it is what reaches the wire as `content[0].text`.
+ * `message` is composed through `ToolFailure.message` at construction, so it
+ * is what reaches the wire as `content[0].text`.
  *
  * @public
  */
 export declare class WorkspaceNotFound extends WorkspaceNotFound_base {}
 declare const InvalidArgument_base: Schema.Class<InvalidArgument, Schema.TaggedStruct<"InvalidArgument", {
-  readonly argument: Schema.String;
   readonly message: Schema.String;
   readonly remediation: Schema.Struct<{
     readonly hint: Schema.String;
     readonly suggestedTool: Schema.optionalKey<Schema.String>;
+    readonly suggestedArgs: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
   }>;
+  readonly argument: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 /**
  * A tool argument was structurally acceptable but semantically invalid — a
  * `repos_manage` action missing the field it needs, a `biome_check` path
  * outside the workspace, a `changeset_validate` directory that does not
- * exist. `message` is composed through {@link composeRemediatedMessage}.
+ * exist. `message` is composed through `ToolFailure.message`.
  *
  * @public
  */
 export declare class InvalidArgument extends InvalidArgument_base {}
 declare const EngineError_base: Schema.Class<EngineError, Schema.TaggedStruct<"EngineError", {
-  readonly source: Schema.String;
   readonly message: Schema.String;
   readonly remediation: Schema.Struct<{
     readonly hint: Schema.String;
     readonly suggestedTool: Schema.optionalKey<Schema.String>;
+    readonly suggestedArgs: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
   }>;
+  readonly source: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 /**
  * A silk-effects engine program failed with one of its own typed errors
  * (`TurboError`, `GitError`, `ReposConfigError`, …). `source` carries that
  * error's `_tag`; `message` is its own rendering plus the remediation,
- * composed through {@link composeRemediatedMessage}.
+ * composed through `ToolFailure.message`.
  *
  * @public
  */
@@ -86,27 +63,29 @@ declare const BiomeUnavailable_base: Schema.Class<BiomeUnavailable, Schema.Tagge
   readonly remediation: Schema.Struct<{
     readonly hint: Schema.String;
     readonly suggestedTool: Schema.optionalKey<Schema.String>;
+    readonly suggestedArgs: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
   }>;
 }>, import("effect/Cause").YieldableError>;
 /**
  * No Biome binary could be located. `message` is composed through
- * {@link composeRemediatedMessage}.
+ * `ToolFailure.message`.
  *
  * @public
  */
 export declare class BiomeUnavailable extends BiomeUnavailable_base {}
 declare const BiomeFailed_base: Schema.Class<BiomeFailed, Schema.TaggedStruct<"BiomeFailed", {
-  readonly exitCode: Schema.optionalKey<Schema.Number>;
   readonly message: Schema.String;
   readonly remediation: Schema.Struct<{
     readonly hint: Schema.String;
     readonly suggestedTool: Schema.optionalKey<Schema.String>;
+    readonly suggestedArgs: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
   }>;
+  readonly exitCode: Schema.optionalKey<Schema.Number>;
 }>, import("effect/Cause").YieldableError>;
 /**
  * Biome itself failed (exit status above 1, a spawn error, or a timeout) —
  * distinct from "lint issues found", which is a successful result. `message`
- * is composed through {@link composeRemediatedMessage}.
+ * is composed through `ToolFailure.message`.
  *
  * @public
  */
@@ -116,18 +95,6 @@ export declare const McpToolError: Schema.Union<readonly [typeof WorkspaceNotFou
 /** @public */
 export type McpToolError = typeof McpToolError.Type;
 //#endregion
-//#region src/markdown.d.ts
-declare const SilkMarkdown_base: Context.ServiceClass<SilkMarkdown, "@savvy-web/mcp/SilkMarkdown", (data: unknown) => string>;
-/**
- * Renders a tool's decoded success value as the markdown transcript an agent
- * reads. Typed over `unknown` because the annotation is read generically at
- * registration; each tool supplies `Schema.decodeUnknownSync(<X>AsMarkdown)`,
- * whose own decoder is the type guard.
- *
- * @public
- */
-export declare class SilkMarkdown extends SilkMarkdown_base {}
-//#endregion
 //#region src/runtime.d.ts
 /**
  * Every service the MCP runtime provides to the tool handlers.
@@ -173,25 +140,38 @@ export declare const makeSilkRuntimeLayer: (cwd: string) => Layer.Layer<McpServi
 /**
  * Everything {@link ServerLayer} still needs from the platform: the three
  * services `makeSilkRuntimeLayer` requires, plus `Stdio`, which
- * `McpServer.layerStdio` itself requires. `NodeServices.layer` supplies all
+ * `McpStdio.layer` itself requires. `NodeServices.layer` supplies all
  * four in `main.ts`; tests swap `Stdio` for `Stdio.layerTest`.
  *
  * @public
  */
 type PlatformServices = FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner | Stdio.Stdio;
+/**
+ * Options for {@link ServerLayer}.
+ *
+ * @public
+ */
+interface ServerOptions {
+  /**
+   * The carrier this server was installed through (for example
+   * `@savvy-web/silk`), rendered into `serverInfo.version` as
+   * `" via <name> <version>"`. Absent for a direct install.
+   */
+  readonly distribution?: Distribution | undefined;
+}
 /**
  * The whole server as one layer: the ten-tool toolkit, the silk-effects
- * runtime discharging its dependencies, over `McpServer.layerStdio`.
+ * runtime discharging its dependencies, over `@effected/mcp`'s
+ * `McpStdio.layer`.
  *
- * `protocols` lists the stateless `2026-07-28` adapter first, then the two
- * newest stateful ones — see gotcha 2 in the module remarks.
- * `Cause.IllegalArgumentError` in `layerStdio`'s error channel is `orDie`d:
- * `protocols` is a static literal with exactly one stateless member, so a
- * failure there is an implementer-time defect, not a runtime condition.
+ * `McpStdio.layer` is `McpServer.layerStdio` with the kit's default
+ * `protocols` (the stateless `2026-07-28` adapter first, then the two newest
+ * stateful ones — see gotcha 2), `LogToStderr` merged into its output, a
+ * stdin guard answering a non-JSON line with `-32700`, and `Layer.orDie`.
  *
  * @public
  */
-export declare const ServerLayer: (cwd: string) => Layer.Layer<never, never, PlatformServices>;
+export declare const ServerLayer: (cwd: string, options?: ServerOptions) => Layer.Layer<never, never, PlatformServices>;
 //#endregion
 //#region src/tools/biome-check.d.ts
 /**
@@ -741,5 +721,5 @@ export declare const ToolsLayer: (cwd: string) => Layer.Layer<Tool.HandlersFor<S
  */
 export declare const CURRENT_MCP_VERSION: any;
 //#endregion
-export type { McpServices, PlatformServices, SilkTools };
+export type { McpServices, PlatformServices, ServerOptions, SilkTools };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,8 +1,7 @@
-import { BiomeFailed, BiomeUnavailable, EngineError, InvalidArgument, McpToolError, Remediation, WorkspaceNotFound, composeRemediatedMessage, truncateEchoed } from "./errors.js";
-import { SilkMarkdown } from "./markdown.js";
+import { BiomeFailed, BiomeUnavailable, EngineError, InvalidArgument, McpToolError, WorkspaceNotFound } from "./errors.js";
 import { makeSilkRuntimeLayer } from "./runtime.js";
 import { SilkToolkit, ToolsLayer } from "./toolkit.js";
 import { CURRENT_MCP_VERSION } from "./version.js";
 import { ServerLayer } from "./server.js";
 
-export { BiomeFailed, BiomeUnavailable, CURRENT_MCP_VERSION, EngineError, InvalidArgument, McpToolError, Remediation, ServerLayer, SilkMarkdown, SilkToolkit, ToolsLayer, WorkspaceNotFound, composeRemediatedMessage, makeSilkRuntimeLayer, truncateEchoed };
+export { BiomeFailed, BiomeUnavailable, CURRENT_MCP_VERSION, EngineError, InvalidArgument, McpToolError, ServerLayer, SilkToolkit, ToolsLayer, WorkspaceNotFound, makeSilkRuntimeLayer };

package/main.d.ts

@@ -1,25 +1,30 @@
+import { Distribution } from "@effected/engine";
 //#region src/main.d.ts
 /**
- * Owns the `savvy-mcp` process: crash guards, project-root resolution, and the
- * server layer launched over stdio.
+ * Options for {@link main}.
  *
- * @remarks
- * No static imports of the server graph — every module reachable from the
- * MCP tool surface is imported dynamically, after the crash guards are
- * registered, so an error during that import (or anything downstream) is
- * caught by `uncaughtException`/`unhandledRejection` rather than crashing
- * before a handler exists.
- *
- * @packageDocumentation
+ * @public
  */
+export interface MainOptions {
+  /**
+   * The carrier this bin was installed through, for example
+   * `{ name: "@savvy-web/silk", version }`; rendered into the server's
+   * reported version. Absent for a direct install.
+   */
+  readonly distribution?: Distribution | undefined;
+}
 /**
  * Run the savvy MCP server over stdio. Owns the process.
  *
  * @remarks
- * NO static imports of the server graph — see the module remarks.
+ * The project directory is the first positional argument, then
+ * `SAVVY_MCP_PROJECT_DIR`, then `CLAUDE_PROJECT_DIR`, then the working
+ * directory — an empty value or an unsubstituted `${VAR}` placeholder is
+ * skipped (`LaunchContext.projectDir`). NO static imports of the server
+ * graph — see the module remarks.
  *
  * @public
  */
-export declare const main: () => Promise<void>;
+export declare const main: (options?: MainOptions) => Promise<void>;
 //#endregion
 //# sourceMappingURL=main.d.ts.map

package/main.js

@@ -1,18 +1,4 @@
 //#region src/main.ts
-/**
-* Owns the `savvy-mcp` process: crash guards, project-root resolution, and the
-* server layer launched over stdio.
-*
-* @remarks
-* No static imports of the server graph — every module reachable from the
-* MCP tool surface is imported dynamically, after the crash guards are
-* registered, so an error during that import (or anything downstream) is
-* caught by `uncaughtException`/`unhandledRejection` rather than crashing
-* before a handler exists.
-*
-* @packageDocumentation
-*/
-/* v8 ignore start -- process bootstrap; covered by the server-lifecycle e2e and the silk bins e2e */
 const fatal = (label, error) => {
 	process.stderr.write(`savvy-mcp: ${label}: ${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
 	process.exit(1);
@@ -21,20 +7,29 @@ const fatal = (label, error) => {
 * Run the savvy MCP server over stdio. Owns the process.
 *
 * @remarks
-* NO static imports of the server graph — see the module remarks.
+* The project directory is the first positional argument, then
+* `SAVVY_MCP_PROJECT_DIR`, then `CLAUDE_PROJECT_DIR`, then the working
+* directory — an empty value or an unsubstituted `${VAR}` placeholder is
+* skipped (`LaunchContext.projectDir`). NO static imports of the server
+* graph — see the module remarks.
 *
 * @public
 */
-const main = async () => {
+const main = async (options = {}) => {
 	process.on("uncaughtException", (e) => fatal("uncaught exception", e));
 	process.on("unhandledRejection", (r) => fatal("unhandled rejection", r));
 	const { NodeRuntime, NodeServices } = await import("@effect/platform-node");
-	const { Cause, Exit, Layer, Logger, Runtime } = await import("effect");
-	const { resolveProjectDir } = await import("./internal/project-root.js");
+	const { Layer } = await import("effect");
+	const { LaunchContext } = await import("@effected/engine");
+	const { McpStdio } = await import("@effected/mcp");
 	const { ServerLayer } = await import("./server.js");
-	const cwd = resolveProjectDir(process.argv.slice(2), process.env, () => process.cwd());
-	const program = Layer.launch(ServerLayer(cwd).pipe(Layer.provide(NodeServices.layer), Layer.provide(Logger.layer([Logger.consolePretty()])), Layer.provide(Layer.succeed(Logger.LogToStderr, true))));
-	NodeRuntime.runMain(program, { teardown: (exit, onExit) => Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause) ? onExit(0) : Runtime.defaultTeardown(exit, onExit) });
+	const cwd = LaunchContext.projectDir({
+		argv: process.argv.slice(2, 3),
+		env: process.env,
+		keys: ["SAVVY_MCP_PROJECT_DIR", "CLAUDE_PROJECT_DIR"],
+		cwd: process.cwd()
+	});
+	NodeRuntime.runMain(McpStdio.launch(ServerLayer(cwd, options).pipe(Layer.provide(NodeServices.layer))), { teardown: McpStdio.teardown });
 };
 /* v8 ignore stop */
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/mcp",
-	"version": "3.2.4",
+	"version": "3.3.0",
 	"private": false,
 	"description": "The savvy MCP server — Silk Suite tooling and library knowledge for coding agents",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/mcp",
@@ -38,7 +38,9 @@
 	"dependencies": {
 		"@effect/platform-node": "4.0.0-rc.117",
 		"@effected/commands": "^0.9.0",
+		"@effected/engine": "^0.1.0",
 		"@effected/git": "^0.17.0",
+		"@effected/mcp": "^0.1.1",
 		"@effected/templates": "^0.8.0",
 		"@effected/workspaces": "^0.26.0",
 		"@savvy-web/silk-effects": "9.1.3",