// ---------------------------------------------------------------------------// Shared execution stack — turn a (user, org) into a runnable executor + engine.//// Cloud and self-host both had an identical `makeExecutionStack`://   createScopedExecutor -> createExecutionEngine({ executor, codeExecutor }) ->//   { executor, engine }// differing only in (a) the code substrate (cloud's Cloudflare dynamic-worker vs// self-host's in-process QuickJS) and (b) cloud's usage-metering decorator// (an app-only billing overlay), absent on self-host.//// This factory owns the common body. The two differences are injected://   - `CodeExecutorProvider` — the `codeExecutor` value. Cloud's Layer wraps//     `makeDynamicWorkerExecutor({ loader: env.LOADER })`; self-host's wraps//     `makeQuickJsExecutor()`.//   - `EngineDecorator` — `decorate(engine) => engine`. Cloud's app layer applies//     a usage-metering overlay; the default Layer is a no-op (self-host, local,//     tests, and cloud's non-metering MCP session path).//// The per-(user, org) executor itself comes from `makeScopedExecutor` (sdk),// which reads the DB handle / plugins / host config from its own seams. This// lives in `@executor-js/api` because it is the only package that depends on// both `@executor-js/sdk` (for `makeScopedExecutor`) and `@executor-js/execution`// (for `createExecutionEngine`).// --------------------------------------------------------------------------- import { Context, Effect, Layer } from "effect";import type * as Cause from "effect/Cause"; import type { McpResource } from "@executor-js/host-mcp";import type { AnyPlugin, Executor, ExecutorConfig, StorageFailure } from "@executor-js/sdk";import {  createExecutionEngine,  type ExecutionEngine,  type ExecutionEngineConfig,} from "@executor-js/execution"; import { DbProvider } from "./executor-fuma-db";import {  HostConfig,  PluginsProvider,  makePlatformExecutor,  makeScopedExecutor,} from "./scoped-executor"; // ---------------------------------------------------------------------------// CodeExecutorProvider seam — the host's code-execution substrate. Typed to the// widened `Cause.YieldableError` channel (matching `ExecutionEngineService`) so// a runtime-specific tagged error (DynamicWorkerExecutionError, QuickJS errors)// assigns structurally.// --------------------------------------------------------------------------- export type CodeExecutor = ExecutionEngineConfig<Cause.YieldableError>["codeExecutor"]; export class CodeExecutorProvider extends Context.Service<CodeExecutorProvider, CodeExecutor>()(  "@executor-js/api/CodeExecutorProvider",) {} // ---------------------------------------------------------------------------// EngineDecorator seam — wrap the freshly built engine (e.g. with usage// metering). `decorate` receives the same `(accountId, organizationId,// organizationName)` identity the stack was built for, so a host can bind the// decorator to the org (cloud's per-org usage metering needs the org id). The// default Layer is a no-op so hosts that do not decorate (self-host, local,// tests) get an identity transform for free.// --------------------------------------------------------------------------- export interface EngineStackIdentity {  readonly accountId: string;  readonly organizationId: string;  readonly organizationName: string;} export interface EngineDecoratorShape {  readonly decorate: <E extends Cause.YieldableError>(    engine: ExecutionEngine<E>,    identity: EngineStackIdentity,    context: EngineStackContext,  ) => ExecutionEngine<E>;} /** * What the stack was built to serve, beyond the identity: the MCP resource * when the caller is an MCP session (absent on the HTTP plane). Lets a * decorator distinguish a toolkit-scoped engine without the host threading a * side channel. */export interface EngineStackContext {  readonly mcpResource?: McpResource;} export class EngineDecorator extends Context.Service<EngineDecorator, EngineDecoratorShape>()(  "@executor-js/api/EngineDecorator",) {} /** No-op decorator: the engine passes through unchanged. */export const EngineDecoratorNoop: Layer.Layer<EngineDecorator> = Layer.succeed(EngineDecorator)({  decorate: (engine) => engine,}); // ---------------------------------------------------------------------------// makeExecutionStack — shared (user, org) -> { executor, engine }.//// Reads `makeScopedExecutor` (sdk), the code substrate from// `CodeExecutorProvider`, and the engine wrap from `EngineDecorator`. The// returned engine error channel is widened to `Cause.YieldableError`, matching// `ExecutionEngineService` and the runtime-specific code executors.// --------------------------------------------------------------------------- export const makeExecutionStack = <  const TPlugins extends readonly AnyPlugin[] = readonly AnyPlugin[],>(  accountId: string,  organizationId: string,  organizationName: string,  options?: {    readonly mcpResource?: McpResource;    /** Workspace-settings permission for this binding (see     *  `ExecutorConfig.orgWrites`), derived from the acting member's role. */    readonly orgWrites?: ExecutorConfig<TPlugins>["orgWrites"];  },): Effect.Effect<  { readonly executor: Executor<TPlugins>; readonly engine: ExecutionEngine<Cause.YieldableError> },  StorageFailure,  DbProvider | PluginsProvider | HostConfig | CodeExecutorProvider | EngineDecorator> =>  Effect.gen(function* () {    const executor = yield* makeScopedExecutor<TPlugins>(      accountId,      organizationId,      organizationName,      {        plugins: { mcpResource: options?.mcpResource },        ...(options?.orgWrites === undefined ? {} : { orgWrites: options.orgWrites }),      },    ).pipe(Effect.withSpan("executor.stack.scoped_executor"));    const codeExecutor = yield* CodeExecutorProvider.asEffect().pipe(      Effect.withSpan("executor.stack.code_executor"),    );    const { decorate } = yield* EngineDecorator.asEffect().pipe(      Effect.withSpan("executor.stack.decorator"),    );    const engine = yield* Effect.sync(() =>      decorate(        createExecutionEngine({ executor, codeExecutor }),        {          accountId,          organizationId,          organizationName,        },        { mcpResource: options?.mcpResource },      ),    );    return { executor, engine };  }).pipe(Effect.withSpan("executor.stack.build")); // ---------------------------------------------------------------------------// makePlatformExecutionStack — the org-credential sibling: a subject-less,// write-refusing executor (`makePlatformExecutor`) and no REAL engine. An org// key is an observer; the execution engine exists to run code as an acting// member, so no engine is built here. The middleware still provides// `ExecutionEngineService` (handlers' service requirements demand one) — as a// stub whose reachable reads answer "nothing here" and whose execute/resume// members sit behind the middleware's safe-request gate (see// `readOnlyExecutionEngine` in ./execution-stack-middleware.ts).// --------------------------------------------------------------------------- export const makePlatformExecutionStack = <  const TPlugins extends readonly AnyPlugin[] = readonly AnyPlugin[],>(  organizationId: string,): Effect.Effect<  { readonly executor: Executor<TPlugins> },  StorageFailure,  DbProvider | PluginsProvider | HostConfig> =>  makePlatformExecutor(organizationId).pipe(    // The platform executor is built against the erased plugin set; re-narrow    // via the same phantom cast `makeScopedExecutor` performs for the scoped one.    Effect.map((executor) => ({ executor: executor as Executor<TPlugins> })),    Effect.withSpan("executor.stack.platform.build"),  );