apps 1.0.0-beta.0 → 1.0.0-beta.2

package/README.md

@@ -49,5 +49,6 @@ export default defineTool({
 
 The root export is pure and synchronous — no effect dependency, no node
 builtins — so authored files run unmodified anywhere, including sandboxed
-workers. Host machinery lives behind subpaths (`apps/manifest`,
-`apps/runner`) and requires `effect`.
+workers. `apps/runtime` is the single execution core every environment
+shares; host machinery lives behind `apps/manifest` and `apps/runner` and
+requires `effect`.

package/dist/authoring/index.js

@@ -10,17 +10,17 @@ import {
   service,
   setActiveRegistry,
   toolSpecOf
-} from "../index-8wmxmfhc.js";
+} from "../chunk-LWKQDDLZ.js";
 export {
-  toolSpecOf,
-  setActiveRegistry,
-  service,
-  secrets,
-  requirementSpecOf,
-  oauth,
-  newRegistry,
-  defineTool,
-  defineApp,
+  __enterFile,
   __leaveFile,
-  __enterFile
+  defineApp,
+  defineTool,
+  newRegistry,
+  oauth,
+  requirementSpecOf,
+  secrets,
+  service,
+  setActiveRegistry,
+  toolSpecOf
 };

package/dist/chunk-646MS7DD.js

@@ -0,0 +1,99 @@
+import {
+  __enterFile,
+  __leaveFile,
+  newRegistry,
+  setActiveRegistry
+} from "./chunk-LWKQDDLZ.js";
+import {
+  PublishError
+} from "./chunk-B7NEUIJL.js";
+import {
+  manifestOf
+} from "./chunk-OGCPVWAZ.js";
+
+// src/manifest/index.ts
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Effect, FileSystem, MutableRef, Semaphore } from "effect";
+var moduleProblem = (where, error) => `${where}: failed to execute (${error instanceof Error ? error.message : String(error)})`;
+var loadPermit = Semaphore.makeUnsafe(1);
+var runNonce = MutableRef.make(0);
+var importedAppUrls = MutableRef.make(/* @__PURE__ */ new Set());
+var canonicalModuleUrl = (path, where) => FileSystem.FileSystem.pipe(
+  Effect.flatMap((fs) => fs.realPath(path)),
+  Effect.map(pathToFileURL),
+  Effect.mapError((error) => new PublishError({ problems: [moduleProblem(where, error)] }))
+);
+var importModule = (specifier, where) => Effect.tryPromise({
+  try: () => import(specifier),
+  catch: (error) => new PublishError({ problems: [moduleProblem(where, error)] })
+}).pipe(Effect.asVoid);
+var executeModule = (registry, where, load) => Effect.suspend(() => {
+  __enterFile(where);
+  return load;
+}).pipe(
+  Effect.catchTag(
+    "PublishError",
+    (error) => Effect.sync(() => {
+      registry.problems.push(...error.problems.map((message) => ({ message })));
+    })
+  )
+);
+var appEntrySpecifier = (appUrl, nonce) => {
+  const seen = MutableRef.get(importedAppUrls);
+  if (!seen.has(appUrl.href)) {
+    MutableRef.set(importedAppUrls, /* @__PURE__ */ new Set([...seen, appUrl.href]));
+    return appUrl.href;
+  }
+  return `${fileURLToPath(appUrl)}?m=${nonce}`;
+};
+var executeModules = (appDir, files) => loadPermit.withPermit(
+  Effect.acquireUseRelease(
+    Effect.sync(() => {
+      const registry = newRegistry();
+      return { registry, previous: setActiveRegistry(registry) };
+    }),
+    ({ registry }) => Effect.gen(function* () {
+      const nonce = MutableRef.incrementAndGet(runNonce);
+      yield* executeModule(
+        registry,
+        "app.ts",
+        canonicalModuleUrl(`${appDir}/app.ts`, "app.ts").pipe(
+          Effect.flatMap((appUrl) => importModule(appEntrySpecifier(appUrl, nonce), "app.ts"))
+        )
+      );
+      for (const file of files) {
+        const where = `tools/${file}`;
+        yield* executeModule(
+          registry,
+          where,
+          canonicalModuleUrl(`${appDir}/tools/${file}`, where).pipe(
+            Effect.flatMap((url) => importModule(`${fileURLToPath(url)}?m=${nonce}`, where))
+          )
+        );
+      }
+      return registry;
+    }),
+    ({ previous }) => Effect.sync(() => {
+      __leaveFile();
+      setActiveRegistry(previous);
+    })
+  )
+);
+var toolFiles = (appDir) => FileSystem.FileSystem.pipe(
+  Effect.flatMap((fs) => fs.readDirectory(`${appDir}/tools`)),
+  Effect.mapError((error) => new PublishError({ problems: [`tools/: ${error.message}`] })),
+  Effect.map((entries) => entries.filter((file) => file.endsWith(".ts")).sort())
+);
+var loadApp = (appDir) => Effect.gen(function* () {
+  const files = yield* toolFiles(appDir);
+  const registry = yield* executeModules(appDir, files);
+  const outcome = yield* Effect.promise(() => manifestOf(registry));
+  if (!outcome.ok) return yield* new PublishError({ problems: outcome.problems });
+  return { registry, result: outcome.result };
+});
+var manifest = (appDir) => Effect.map(loadApp(appDir), ({ result }) => result);
+
+export {
+  loadApp,
+  manifest
+};

package/dist/{index-mcjwntr2.js → chunk-B7NEUIJL.js}

@@ -1,13 +1,14 @@
 // src/manifest/contract.ts
 import { Data, Schema } from "effect";
 var JsonSchemaObject = Schema.Record(Schema.String, Schema.Json);
-
-class PublishError extends Data.TaggedError("PublishError") {
+var PublishError = class extends Data.TaggedError("PublishError") {
   get message() {
     return `publish failed:
-${this.problems.map((problem) => `  - ${problem}`).join(`
-`)}`;
+${this.problems.map((problem) => `  - ${problem}`).join("\n")}`;
   }
-}
+};
 
-export { JsonSchemaObject, PublishError };
+export {
+  JsonSchemaObject,
+  PublishError
+};

package/dist/{index-8wmxmfhc.js → chunk-LWKQDDLZ.js}

@@ -4,12 +4,12 @@ var oauth = (opts) => ({ kind: "oauth", ...opts });
 var RequirementKey = Symbol.for("executor/apps/requirement");
 var DynamicKey = Symbol.for("executor/apps/dynamic");
 var newRegistry = () => ({
-  app: undefined,
-  services: new Map,
-  tools: new Map,
-  dynamic: new Map,
+  app: void 0,
+  services: /* @__PURE__ */ new Map(),
+  tools: /* @__PURE__ */ new Map(),
+  dynamic: /* @__PURE__ */ new Map(),
   problems: [],
-  toolFiles: new Map
+  toolFiles: /* @__PURE__ */ new Map()
 });
 var activeRegistry = newRegistry();
 var currentFile;
@@ -22,11 +22,10 @@ var __enterFile = (path) => {
   currentFile = path;
 };
 var __leaveFile = () => {
-  currentFile = undefined;
+  currentFile = void 0;
 };
 var sourceFileFor = (claim) => {
-  if (currentFile !== undefined)
-    return currentFile;
+  if (currentFile !== void 0) return currentFile;
   activeRegistry.problems.push({
     message: `${claim} called outside an authored module import`
   });
@@ -51,16 +50,14 @@ var service = (decl) => {
     activeRegistry.services.set(decl.origin, { decl, file });
   return value;
 };
-var isRequirement = (value) => typeof value === "object" && value !== null && (RequirementKey in value);
-var isService = (value) => isRequirement(value) && ("decl" in value) && ("optional" in value) && ("array" in value) && ("grant" in value);
-var requirementSpecOf = (value) => isService(value) || isRequirement(value) ? value[RequirementKey] : undefined;
+var isRequirement = (value) => typeof value === "object" && value !== null && RequirementKey in value;
+var isService = (value) => isRequirement(value) && "decl" in value && "optional" in value && "array" in value && "grant" in value;
+var requirementSpecOf = (value) => isService(value) || isRequirement(value) ? value[RequirementKey] : void 0;
 var defineApp = (manifest) => {
   const file = sourceFileFor("defineApp(...)");
   const value = { kind: "executor-app", ...manifest };
-  if (activeRegistry.app === undefined)
-    activeRegistry.app = value;
-  else
-    activeRegistry.problems.push({ message: `${file}: duplicate defineApp(...)` });
+  if (activeRegistry.app === void 0) activeRegistry.app = value;
+  else activeRegistry.problems.push({ message: `${file}: duplicate defineApp(...)` });
   return value;
 };
 var ToolKey = Symbol.for("executor/apps/tool");
@@ -73,18 +70,29 @@ var defineTool = (spec) => {
   const fileSummary = activeRegistry.toolFiles.get(file);
   activeRegistry.toolFiles.set(file, {
     definitions: (fileSummary?.definitions ?? 0) + 1,
-    hasUnnamedTool: fileSummary?.hasUnnamedTool === true || spec.name === undefined
+    hasUnnamedTool: fileSummary?.hasUnnamedTool === true || spec.name === void 0
   });
   const existing = activeRegistry.tools.get(name);
-  if (existing !== undefined) {
+  if (existing !== void 0) {
     activeRegistry.problems.push({
       message: `${file}: tool name '${name}' is already defined in ${existing.file}`
     });
-  } else
-    activeRegistry.tools.set(name, { spec, file });
+  } else activeRegistry.tools.set(name, { spec, file });
   return value;
 };
-var isTool = (value) => typeof value === "object" && value !== null && (ToolKey in value);
-var toolSpecOf = (value) => isTool(value) ? value[ToolKey] : undefined;
+var isTool = (value) => typeof value === "object" && value !== null && ToolKey in value;
+var toolSpecOf = (value) => isTool(value) ? value[ToolKey] : void 0;
 
-export { secrets, oauth, newRegistry, setActiveRegistry, __enterFile, __leaveFile, service, requirementSpecOf, defineApp, defineTool, toolSpecOf };
+export {
+  secrets,
+  oauth,
+  newRegistry,
+  setActiveRegistry,
+  __enterFile,
+  __leaveFile,
+  service,
+  requirementSpecOf,
+  defineApp,
+  defineTool,
+  toolSpecOf
+};

package/dist/{index-dh4z81es.js → chunk-NFLNA2SC.js}

@@ -1,10 +1,11 @@
 // src/runner/protocol.ts
 import { Data } from "effect";
-
-class CallError extends Data.TaggedError("CallError") {
+var CallError = class extends Data.TaggedError("CallError") {
   get message() {
     return `${this.target}: ${this.reason}`;
   }
-}
+};
 
-export { CallError };
+export {
+  CallError
+};

package/dist/chunk-OGCPVWAZ.js

@@ -0,0 +1,191 @@
+// src/runtime/index.ts
+var failure = (reason) => ({ ok: false, reason });
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+var isJsonValue = (value) => {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(isJsonValue);
+  if (typeof value !== "object") return false;
+  return Object.values(value).every(isJsonValue);
+};
+var standardJsonSchemaOf = (input) => "~standard" in input ? input["~standard"].jsonSchema : void 0;
+var strictify = (node) => {
+  if (typeof node !== "object" || node === null) return node;
+  if (Array.isArray(node)) return node.map(strictify);
+  const object = { ...node };
+  if (object.type === "object" && object.additionalProperties === void 0)
+    object.additionalProperties = false;
+  for (const key of ["items", "anyOf", "oneOf", "allOf"])
+    if (key in object) object[key] = strictify(object[key]);
+  for (const key of ["properties", "$defs"])
+    if (object[key] !== void 0 && typeof object[key] === "object" && object[key] !== null)
+      object[key] = Object.fromEntries(
+        Object.entries(object[key]).map(([name, value]) => [
+          name,
+          strictify(value)
+        ])
+      );
+  return object;
+};
+var compileInputSchema = (input, where) => {
+  const standard = standardJsonSchemaOf(input);
+  if ("~standard" in input && typeof standard?.input !== "function")
+    return {
+      problem: `${where}: input is a Standard Schema without the jsonSchema extension \u2014 use a library that implements it (zod 4+, effect Schema) or pass raw JSON schema`
+    };
+  try {
+    const compiled = strictify(
+      typeof standard?.input === "function" ? standard.input({ target: "draft-2020-12" }) : structuredClone(input)
+    );
+    if (typeof compiled !== "object" || compiled === null || Array.isArray(compiled) || !isJsonValue(compiled))
+      throw new Error("expected a JSON object");
+    return { value: compiled };
+  } catch (error) {
+    return {
+      problem: `${where}: input schema could not compile to JSON schema (${errorMessage(error)})`
+    };
+  }
+};
+var requirementKey = Symbol.for("executor/apps/requirement");
+var requirementSpecOf = (value) => typeof value === "object" && value !== null && requirementKey in value ? value[requirementKey] : void 0;
+var canonicalJson = (value) => {
+  const sortKeys = (node) => {
+    if (Array.isArray(node)) return node.map(sortKeys);
+    if (typeof node === "object" && node !== null)
+      return Object.fromEntries(
+        Object.entries(node).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortKeys(child)])
+      );
+    return node;
+  };
+  return JSON.stringify(sortKeys(value));
+};
+var collectRegistry = (registry) => {
+  const problems = registry.problems.map((problem) => problem.message);
+  const app = registry.app;
+  const claims = /* @__PURE__ */ new Map();
+  for (const [origin, registered] of registry.services) {
+    if (registered.file !== "app.ts") continue;
+    const { decl } = registered;
+    claims.set(origin, {
+      origin,
+      reach: decl.reach ?? [],
+      params: decl.params ?? {},
+      auth: decl.auth ?? {}
+    });
+  }
+  const collectRequirement = (role, requirement, where) => {
+    const spec = requirementSpecOf(requirement);
+    if (spec === void 0) {
+      problems.push(`${where}: requirement '${role}' is not a service/requirement value`);
+      return void 0;
+    }
+    const origin = spec.service.origin;
+    if (!claims.has(origin))
+      problems.push(`${where}: requirement '${role}' names ${origin}, which app.ts does not declare`);
+    if (spec.grant !== void 0 && !(spec.grant in (spec.service.auth ?? {})))
+      problems.push(
+        `${where}: requirement '${role}' pins grant '${spec.grant}', not a auth method on ${origin}`
+      );
+    return {
+      role,
+      service: origin,
+      arity: spec.arity,
+      ...spec.grant === void 0 ? {} : { grant: spec.grant },
+      ...spec.description === void 0 ? {} : { description: spec.description }
+    };
+  };
+  if (app === void 0) problems.push("app.ts must call defineApp({...})");
+  else if (typeof app.description !== "string" || app.description.trim().length === 0)
+    problems.push("app.ts: app description must not be empty");
+  for (const [file, summary] of registry.toolFiles) {
+    if (summary.definitions > 1 && summary.hasUnnamedTool)
+      problems.push(`${file}: multi-tool files must name every tool`);
+  }
+  const tools = [];
+  if (app !== void 0) {
+    for (const [name, registered] of registry.tools) {
+      const { spec, file } = registered;
+      const address = `${app.key}/${name}`;
+      if (typeof spec.description !== "string" || spec.description.trim().length === 0)
+        problems.push(`${file}: tool '${name}' description must not be empty`);
+      const requires = Object.entries(spec.requirements ?? {}).flatMap(([role, requirement]) => {
+        const collected = collectRequirement(role, requirement, address);
+        return collected === void 0 ? [] : [collected];
+      }).sort((left, right) => left.role.localeCompare(right.role));
+      const compiled = compileInputSchema(spec.input, address);
+      if ("problem" in compiled) {
+        problems.push(compiled.problem);
+        continue;
+      }
+      tools.push({
+        address,
+        name,
+        description: spec.description,
+        inputSchema: compiled.value,
+        annotations: spec.annotations ?? {},
+        requires,
+        file
+      });
+    }
+  }
+  if (problems.length > 0 || app === void 0) return { problems };
+  const services = [...claims.values()].sort(
+    (left, right) => left.origin.localeCompare(right.origin)
+  );
+  const sortedTools = [...tools].sort((left, right) => left.address.localeCompare(right.address));
+  const appResult = { key: app.key, label: app.label, description: app.description };
+  const manifest = { app: appResult, services, tools: sortedTools };
+  return { problems: [], manifest, canonical: canonicalJson(manifest) };
+};
+var digestOf = async (canonical) => {
+  const bytes = new Uint8Array(
+    await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonical))
+  );
+  return Array.from(bytes.slice(0, 8), (byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+var manifestOf = async (registry) => {
+  const collected = collectRegistry(registry);
+  if (collected.problems.length > 0) return { ok: false, problems: collected.problems };
+  if (!("manifest" in collected))
+    return { ok: false, problems: ["validated registry projection unexpectedly missing"] };
+  return {
+    ok: true,
+    result: { digest: `snap:${await digestOf(collected.canonical)}`, ...collected.manifest }
+  };
+};
+var standardValidateOf = (input) => "~standard" in input && typeof input["~standard"].validate === "function" ? input["~standard"].validate : void 0;
+var parseInput = async (spec, input) => {
+  const validate = standardValidateOf(spec.input);
+  if (validate === void 0)
+    return { ok: false, reason: "input schema does not implement Standard Schema validate" };
+  try {
+    const result = await validate(input);
+    if (result.issues !== void 0)
+      return {
+        ok: false,
+        reason: `invalid input (${result.issues.map((issue) => issue.message).join("; ")})`
+      };
+    return { ok: true, value: result.value };
+  } catch (error) {
+    return { ok: false, reason: `input validation threw (${errorMessage(error)})` };
+  }
+};
+var callTool = async (registry, name, input, ctx) => {
+  const registered = registry.tools.get(name);
+  if (registered === void 0) return failure("unknown tool");
+  const parsed = await parseInput(registered.spec, input);
+  if (!parsed.ok) return parsed;
+  try {
+    const handler = registered.spec.handler;
+    return { ok: true, value: await handler(parsed.value, ctx) };
+  } catch (error) {
+    return failure(`handler failed (${errorMessage(error)})`);
+  }
+};
+var discoverTool = async (_registry, _name, _binding) => failure("no dynamic tools yet");
+
+export {
+  manifestOf,
+  callTool,
+  discoverTool
+};

package/dist/index.d.ts

@@ -1,9 +1 @@
-/**
- * The authoring surface: what app code imports. Pure and synchronous —
- * no effect dependency, no node builtins — so authored files run
- * unmodified in any execution environment, including sandboxed workers.
- *
- * Host-side machinery lives behind subpaths: "apps/manifest" loads and
- * validates authored sources, "apps/runner" executes them.
- */
 export * from "./authoring/index";

package/dist/index.js

@@ -10,17 +10,17 @@ import {
   service,
   setActiveRegistry,
   toolSpecOf
-} from "./index-8wmxmfhc.js";
+} from "./chunk-LWKQDDLZ.js";
 export {
-  toolSpecOf,
-  setActiveRegistry,
-  service,
-  secrets,
-  requirementSpecOf,
-  oauth,
-  newRegistry,
-  defineTool,
-  defineApp,
+  __enterFile,
   __leaveFile,
-  __enterFile
+  defineApp,
+  defineTool,
+  newRegistry,
+  oauth,
+  requirementSpecOf,
+  secrets,
+  service,
+  setActiveRegistry,
+  toolSpecOf
 };

package/dist/manifest/contract.js

@@ -1,8 +1,8 @@
 import {
   JsonSchemaObject,
   PublishError
-} from "../index-mcjwntr2.js";
+} from "../chunk-B7NEUIJL.js";
 export {
-  PublishError,
-  JsonSchemaObject
+  JsonSchemaObject,
+  PublishError
 };

package/dist/manifest/index.d.ts

@@ -1,9 +1,11 @@
 /**
- * Manifest: execute an authored app folder, read its registry, validate
- * every claim, and emit the deterministic publish manifest. Defines run
- * without user context; platform services begin at this boundary.
+ * Manifest: execute an authored app folder and project its registry.
+ * This module owns exactly what differs on a host with a filesystem —
+ * finding and importing authored modules. Everything after the modules
+ * load (validation, canonicalization, digesting) is the shared
+ * execution core in ../runtime; sandboxed guests run that same core.
  */
-import { Crypto, Effect, FileSystem } from "effect";
+import { Effect, FileSystem } from "effect";
 import { type Registry } from "../authoring/index";
 import { PublishError, type AppManifestResult } from "./contract";
 export * from "./contract";
@@ -13,6 +15,6 @@ export interface LoadedApp {
     readonly result: AppManifestResult;
 }
 /** Loads an app once and returns both its live registry and manifest. @internal */
-export declare const loadApp: (appDir: string) => Effect.Effect<LoadedApp, PublishError, Crypto.Crypto | FileSystem.FileSystem>;
+export declare const loadApp: (appDir: string) => Effect.Effect<LoadedApp, PublishError, FileSystem.FileSystem>;
 /** Executes an app and returns its deterministic publish manifest. */
-export declare const manifest: (appDir: string) => Effect.Effect<AppManifestResult, PublishError, Crypto.Crypto | FileSystem.FileSystem>;
+export declare const manifest: (appDir: string) => Effect.Effect<AppManifestResult, PublishError, FileSystem.FileSystem>;

package/dist/manifest/index.js

@@ -1,15 +1,16 @@
 import {
   loadApp,
   manifest
-} from "../index-wfngzvv2.js";
-import"../index-8wmxmfhc.js";
+} from "../chunk-646MS7DD.js";
+import "../chunk-LWKQDDLZ.js";
 import {
   JsonSchemaObject,
   PublishError
-} from "../index-mcjwntr2.js";
+} from "../chunk-B7NEUIJL.js";
+import "../chunk-OGCPVWAZ.js";
 export {
-  manifest,
-  loadApp,
+  JsonSchemaObject,
   PublishError,
-  JsonSchemaObject
+  loadApp,
+  manifest
 };

package/dist/runner/index.js

@@ -1,61 +1,52 @@
 import {
   loadApp
-} from "../index-wfngzvv2.js";
-import"../index-8wmxmfhc.js";
-import"../index-mcjwntr2.js";
+} from "../chunk-646MS7DD.js";
+import "../chunk-LWKQDDLZ.js";
+import "../chunk-B7NEUIJL.js";
 import {
   CallError
-} from "../index-dh4z81es.js";
+} from "../chunk-NFLNA2SC.js";
+import {
+  callTool,
+  discoverTool
+} from "../chunk-OGCPVWAZ.js";
 
 // src/runner/index.ts
 import { Effect } from "effect";
-var hasStandardValidate = (input) => ("~standard" in input) && typeof input["~standard"].validate === "function";
-var parseInput = (name, spec, input) => {
-  if (!hasStandardValidate(spec.input))
-    return Effect.fail(new CallError({ target: name, reason: "input schema does not implement Standard Schema validate" }));
-  const standard = spec.input["~standard"];
-  return Effect.tryPromise({
-    try: () => Promise.resolve(standard.validate(input)),
-    catch: (error) => new CallError({
-      target: name,
-      reason: `input validation threw (${error instanceof Error ? error.message : String(error)})`
-    })
-  }).pipe(Effect.flatMap((result) => result.issues === undefined ? Effect.succeed(result.value) : Effect.fail(new CallError({
-    target: name,
-    reason: `invalid input (${result.issues.map((issue) => issue.message).join("; ")})`
-  }))));
-};
 var localRunner = (appDir) => {
   let cachedLoad;
   const loaded = () => Effect.suspend(() => {
-    if (cachedLoad !== undefined)
-      return cachedLoad;
-    return Effect.flatMap(Effect.cached(loadApp(appDir)), (effect) => Effect.sync(() => {
-      cachedLoad = effect;
-      return effect;
-    }).pipe(Effect.flatten));
+    if (cachedLoad !== void 0) return cachedLoad;
+    return Effect.flatMap(
+      Effect.cached(loadApp(appDir)),
+      (effect) => Effect.sync(() => {
+        cachedLoad = effect;
+        return effect;
+      }).pipe(Effect.flatten)
+    );
   });
-  const loadedFor = (target) => loaded().pipe(Effect.mapError((error) => new CallError({ target, reason: `app failed to load (${error.message})` })));
+  const registryFor = (target) => loaded().pipe(
+    Effect.map(({ registry }) => registry),
+    Effect.mapError(
+      (error) => new CallError({ target, reason: `app failed to load (${error.message})` })
+    )
+  );
+  const settle = (target, outcome) => outcome.ok ? Effect.succeed(outcome.value) : Effect.fail(new CallError({ target, reason: outcome.reason }));
   return {
     manifest: () => Effect.map(loaded(), ({ result }) => result),
-    call: (name, input, ctx) => Effect.gen(function* () {
-      const { registry } = yield* loadedFor(name);
-      const registered = registry.tools.get(name);
-      if (registered === undefined)
-        return yield* new CallError({ target: name, reason: "unknown tool" });
-      const parsed = yield* parseInput(name, registered.spec, input);
-      return yield* Effect.tryPromise({
-        try: () => registered.spec.handler(parsed, ctx),
-        catch: (error) => new CallError({
-          target: name,
-          reason: `handler failed (${error instanceof Error ? error.message : String(error)})`
-        })
-      });
-    }),
-    discover: (name, _binding) => Effect.fail(new CallError({ target: name, reason: "no dynamic tools yet" }))
+    call: (name, input, ctx) => registryFor(name).pipe(
+      Effect.flatMap((registry) => Effect.promise(() => callTool(registry, name, input, ctx))),
+      Effect.flatMap((outcome) => settle(name, outcome))
+    ),
+    discover: (name, binding) => registryFor(name).pipe(
+      Effect.flatMap(
+        (registry) => Effect.promise(() => discoverTool(registry, name, binding))
+      ),
+      Effect.flatMap((outcome) => settle(name, outcome))
+    )
   };
 };
 export {
-  localRunner,
-  CallError
+  CallError,
+  localRunner
 };