apps 1.0.0-beta.1 → 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/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/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/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,13 +1,13 @@
 import {
   loadApp,
   manifest
-} from "../chunk-J5AVXTHA.js";
+} from "../chunk-646MS7DD.js";
 import "../chunk-LWKQDDLZ.js";
 import {
   JsonSchemaObject,
   PublishError
 } from "../chunk-B7NEUIJL.js";
-import "../chunk-RZA7AXBK.js";
+import "../chunk-OGCPVWAZ.js";
 export {
   JsonSchemaObject,
   PublishError,

package/dist/runner/index.js

@@ -1,39 +1,18 @@
 import {
   loadApp
-} from "../chunk-J5AVXTHA.js";
+} from "../chunk-646MS7DD.js";
 import "../chunk-LWKQDDLZ.js";
 import "../chunk-B7NEUIJL.js";
 import {
   CallError
 } from "../chunk-NFLNA2SC.js";
-import "../chunk-RZA7AXBK.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 === 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,33 +25,25 @@ 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})` })
     )
   );
+  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 === 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: (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 {

package/dist/runner/protocol.d.ts

@@ -1,14 +1,7 @@
-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 { ToolCtx } from "../runtime/index";
+export type { ToolCtx, ToolCtxEntry } from "../runtime/index";
 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>;
@@ -21,8 +14,7 @@ export declare class CallError extends CallError_base<{
 }
 /** 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(name: string, input: unknown, ctx: ToolCtx): Effect.Effect<unknown, CallError, FileSystem.FileSystem>;
+    discover(name: string, binding: unknown): Effect.Effect<unknown, CallError, FileSystem.FileSystem>;
 }
-export {};

package/dist/runtime/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 } 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>>;
+/** 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[];
+};
+/** One tool invocation's result envelope. */
+export type CallOutcome = {
+    readonly ok: true;
+    readonly value: unknown;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/** Project a loaded registry into the app's deterministic manifest. */
+export declare const manifestOf: (registry: Registry) => Promise<ManifestOutcome>;
+/** Validate input and run one registered tool's handler. */
+export declare const callTool: (registry: Registry, name: string, input: unknown, ctx: ToolCtx) => Promise<CallOutcome>;
+/** Discover one dynamic tool set's current segment. Unbuilt: always fails. */
+export declare const discoverTool: (_registry: Registry, _name: string, _binding: unknown) => Promise<CallOutcome>;

package/dist/runtime/index.js

@@ -0,0 +1,10 @@
+import {
+  callTool,
+  discoverTool,
+  manifestOf
+} from "../chunk-OGCPVWAZ.js";
+export {
+  callTool,
+  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 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-OGCPVWAZ.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.2",
   "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"
@@ -58,4 +62,4 @@
     "esbuild": "0.25",
     "typescript": "5.9.3"
   }
-}
+}

package/src/index.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";