apps 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/runner/index.js

@@ -1,39 +1,19 @@
 import {
   loadApp
-} from "../chunk-J5AVXTHA.js";
-import "../chunk-LWKQDDLZ.js";
+} from "../chunk-Y6LLTN7W.js";
+import {
+  callTool,
+  discoverTool
+} from "../chunk-MUFMJRXR.js";
 import "../chunk-B7NEUIJL.js";
 import {
-  CallError
-} from "../chunk-NFLNA2SC.js";
-import "../chunk-RZA7AXBK.js";
+  CallError,
+  DiscoverError
+} from "../chunk-4OZFMCTT.js";
+import "../chunk-A3H32P2J.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 === void 0 ? 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(() => {
@@ -46,36 +26,41 @@ var localRunner = (appDir) => {
       }).pipe(Effect.flatten)
     );
   });
-  const loadedFor = (target) => loaded().pipe(
+  const registryFor = (target) => loaded().pipe(
+    Effect.map(({ registry }) => registry),
     Effect.mapError(
-      (error) => new CallError({ target, reason: `app failed to load (${error.message})` })
+      (error) => new CallError({
+        target,
+        kind: "handler",
+        reason: `app failed to load (${error.message})`
+      })
     )
   );
+  const settle = (target, outcome) => outcome.ok ? Effect.succeed(outcome.value) : Effect.fail(new CallError({
+    target,
+    kind: outcome.kind,
+    reason: outcome.reason
+  }));
+  const settleDiscovery = (segment, outcome) => outcome.ok ? Effect.succeed(outcome.value) : Effect.fail(new DiscoverError({ segment, 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 === void 0)
-        return yield* new CallError({ target: name, reason: "unknown tool" });
-      const parsed = yield* parseInput(name, registered.spec, input);
-      return yield* Effect.tryPromise({
-        // SAFETY: ToolSpec intentionally erases authored handler inputs to keep
-        // authoring generic-free; validation and ToolCtx establish this call boundary.
-        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: (address, input, ctx, detail) => registryFor(address).pipe(
+      Effect.flatMap(
+        (registry) => Effect.promise(() => callTool(registry, address, input, ctx, detail))
+      ),
+      Effect.flatMap((outcome) => settle(address, outcome))
+    ),
+    discover: (segment, ctx) => registryFor(segment).pipe(
+      Effect.mapError((error) => new DiscoverError({ segment, reason: error.reason })),
+      Effect.flatMap(
+        (registry) => Effect.promise(() => discoverTool(registry, segment, ctx))
+      ),
+      Effect.flatMap((outcome) => settleDiscovery(segment, outcome))
+    )
   };
 };
 export {
   CallError,
+  DiscoverError,
   localRunner
 };

package/dist/runner/protocol.d.ts

@@ -1,28 +1,33 @@
-import { Crypto, type Effect, FileSystem } from "effect";
+import { type Effect, FileSystem } from "effect";
 import type { AppManifestResult, PublishError } from "../manifest/contract";
-/** The capability exposed to one tool requirement role. */
-export interface ToolCtxEntry {
-    readonly grant: string;
-    readonly token?: string;
-    readonly secrets?: Readonly<Record<string, string>>;
-    fetch(path: string, init?: RequestInit): Promise<Response>;
-}
-/** Tool capabilities keyed by requirement role. */
-export type ToolCtx = Readonly<Record<string, ToolCtxEntry>>;
+import type { CallFailureKind, DiscoveredTool, ToolCtx } from "../runtime/index";
+export type { DiscoveredTool, ToolCtx, ToolCtxEntry, ToolDescriptor, } from "../runtime/index";
+/** Which invocation phase failed. */
+export type CallErrorKind = CallFailureKind;
 declare const CallError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "CallError";
 } & Readonly<A>;
-/** A runner operation failure associated with its target. */
+/** A runner operation failure associated with its target and phase. */
 export declare class CallError extends CallError_base<{
     readonly target: string;
+    readonly kind: CallErrorKind;
+    readonly reason: string;
+}> {
+    get message(): string;
+}
+declare const DiscoverError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "DiscoverError";
+} & Readonly<A>;
+/** A discovery failure associated with one dynamic segment. */
+export declare class DiscoverError extends DiscoverError_base<{
+    readonly segment: string;
     readonly reason: string;
 }> {
     get message(): string;
 }
 /** The platform protocol implemented by an app execution environment. */
 export interface AppRunner {
-    manifest(): Effect.Effect<AppManifestResult, PublishError, Crypto.Crypto | FileSystem.FileSystem>;
-    call(name: string, input: unknown, ctx: ToolCtx): Effect.Effect<unknown, CallError, Crypto.Crypto | FileSystem.FileSystem>;
-    discover(name: string, binding: unknown): Effect.Effect<unknown, CallError, Crypto.Crypto | FileSystem.FileSystem>;
+    manifest(): Effect.Effect<AppManifestResult, PublishError, FileSystem.FileSystem>;
+    call(address: string, input: unknown, ctx: ToolCtx, detail?: unknown): Effect.Effect<unknown, CallError, FileSystem.FileSystem>;
+    discover(segment: string, ctx: ToolCtx): Effect.Effect<readonly DiscoveredTool[], DiscoverError, FileSystem.FileSystem>;
 }
-export {};

package/dist/runner/protocol.js

@@ -1,6 +1,8 @@
 import {
-  CallError
-} from "../chunk-NFLNA2SC.js";
+  CallError,
+  DiscoverError
+} from "../chunk-4OZFMCTT.js";
 export {
-  CallError
+  CallError,
+  DiscoverError
 };

package/dist/runtime/index.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The execution core: everything that happens after authored modules
+ * load, in any environment. Project a registry into its deterministic
+ * manifest, validate a call's input, run the handler, shape the
+ * outcome. There is exactly one implementation of this logic; the
+ * local runner and the sandboxed workerd guest are both thin doors
+ * onto this module.
+ *
+ * Deliberately dependency-free (no effect, no node builtins): this
+ * module bundles into sandboxed guests, where every dependency is
+ * paid on each cold start. Digesting uses WebCrypto, which node, bun,
+ * and workerd all provide.
+ */
+import type { Registry } from "../authoring/index";
+import type { AppManifestResult, JsonSchemaObject } from "../manifest/contract";
+/** The capability exposed to one tool requirement role. */
+export interface ToolCtxEntry {
+    readonly grant: string;
+    readonly kind: "bearer" | "basic" | "secrets" | "oauth";
+    readonly token?: string;
+    readonly username?: string;
+    readonly password?: string;
+    readonly secrets?: Readonly<Record<string, string>>;
+    fetch(path: string, init?: RequestInit): Promise<Response>;
+}
+/** Tool capabilities keyed by requirement role. */
+export type ToolCtx = Readonly<Record<string, ToolCtxEntry>>;
+/** A manifest projection: the app's deterministic description, or why not. */
+export type ManifestOutcome = {
+    readonly ok: true;
+    readonly result: AppManifestResult;
+} | {
+    readonly ok: false;
+    readonly problems: readonly string[];
+};
+/** Which invocation phase failed. */
+export type CallFailureKind = "input" | "handler";
+/** One tool invocation's result envelope. */
+export type CallOutcome = {
+    readonly ok: true;
+    readonly value: unknown;
+} | {
+    readonly ok: false;
+    readonly kind: CallFailureKind;
+    readonly reason: string;
+};
+/** Agent-facing descriptor compiled from one discovery result. */
+export interface ToolDescriptor {
+    readonly description: string;
+    readonly inputSchema: JsonSchemaObject;
+    readonly annotations: {
+        readonly readOnly?: boolean;
+        readonly destructive?: boolean;
+    };
+}
+/** One tool emitted by a dynamic segment discovery. */
+export interface DiscoveredTool {
+    readonly segment: string;
+    readonly name: string;
+    readonly descriptor: ToolDescriptor;
+    readonly detail: unknown;
+}
+/** One dynamic discovery result envelope. */
+export type DiscoverOutcome = {
+    readonly ok: true;
+    readonly value: readonly DiscoveredTool[];
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+type InputSchemaCompilation = {
+    readonly value: JsonSchemaObject;
+} | {
+    readonly problem: string;
+};
+export declare const compileInputSchema: (input: object, where: string) => InputSchemaCompilation;
+/** Project a loaded registry into the app's deterministic manifest. */
+export declare const manifestOf: (registry: Registry) => Promise<ManifestOutcome>;
+/** Validate input and run one static or dynamic tool handler. */
+export declare const callTool: (registry: Registry, address: string, input: unknown, ctx: ToolCtx, detail?: unknown) => Promise<CallOutcome>;
+/** Discover and compile one dynamic segment. */
+export declare const discoverTool: (registry: Registry, segment: string, ctx: ToolCtx) => Promise<DiscoverOutcome>;
+export {};

package/dist/runtime/index.js

@@ -0,0 +1,12 @@
+import {
+  callTool,
+  compileInputSchema,
+  discoverTool,
+  manifestOf
+} from "../chunk-MUFMJRXR.js";
+export {
+  callTool,
+  compileInputSchema,
+  discoverTool,
+  manifestOf
+};

package/dist/workerd/index.d.ts

@@ -1,2 +1,7 @@
-/** Worker-safe registry projection injected into sandboxed app workers. @internal */
-export { collectRegistry } from "../manifest/collect";
+/**
+ * The execution core re-exported for sandboxed guests. A generated
+ * guest module imports the authored files (filling the registry) and
+ * exposes these verbs over RPC; the logic itself lives in ../runtime
+ * and is identical to what the local runner executes. @internal
+ */
+export { callTool, discoverTool, manifestOf, type CallOutcome, type DiscoverOutcome, type DiscoveredTool, type ManifestOutcome, type ToolCtx, type ToolCtxEntry, } from "../runtime/index";

package/dist/workerd/index.js

@@ -1,6 +1,10 @@
 import {
-  collectRegistry
-} from "../chunk-RZA7AXBK.js";
+  callTool,
+  discoverTool,
+  manifestOf
+} from "../chunk-MUFMJRXR.js";
 export {
-  collectRegistry
+  callTool,
+  discoverTool,
+  manifestOf
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apps",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.3",
   "description": "Author executor apps: declare services, auth, and tools in plain TypeScript; the executor platform runs, validates, and serves them.",
   "license": "MIT",
   "type": "module",
@@ -24,6 +24,10 @@
       "types": "./dist/authoring/index.d.ts",
       "default": "./dist/authoring/index.js"
     },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "default": "./dist/runtime/index.js"
+    },
     "./manifest": {
       "types": "./dist/manifest/index.d.ts",
       "default": "./dist/manifest/index.js"
@@ -40,6 +44,18 @@
       "types": "./dist/runner/protocol.d.ts",
       "default": "./dist/runner/protocol.js"
     },
+    "./mcp": {
+      "types": "./dist/mcp/index.d.ts",
+      "default": "./dist/mcp/index.js"
+    },
+    "./openapi": {
+      "types": "./dist/openapi/index.d.ts",
+      "default": "./dist/openapi/index.js"
+    },
+    "./http": {
+      "types": "./dist/http/index.d.ts",
+      "default": "./dist/http/index.js"
+    },
     "./workerd": {
       "types": "./dist/workerd/index.d.ts",
       "default": "./dist/workerd/index.js"
@@ -52,10 +68,5 @@
     "effect": {
       "optional": false
     }
-  },
-  "devDependencies": {
-    "@types/node": "22",
-    "esbuild": "0.25",
-    "typescript": "5.9.3"
   }
-}
+}