@plurnk/plurnk-execs 1.16.4 → 1.17.0

package/.env.defaults

@@ -1,16 +1,11 @@
-# --- @plurnk/plurnk-execs : runtime registration policy (SPEC §3.3) ---
-# Purely subtractive: these only ever REMOVE tags from the registered set — there
-# is no force-enable verb. Unset ⇒ every discovered runtime is registered. This
-# package sets no operative default; the comments below ARE the operator docs.
+# @plurnk/plurnk-execs — installed runtime admission.
+# These filters only remove registered runtimes; they cannot install or force-enable tools.
 
-# Allowlist: register ONLY these tags (comma-separated); every other tag is off.
+# Comma-separated allowlist; unset = all discovered runtimes.
 # PLURNK_EXECS_ONLY=sh,jq
-
-# Per-tag kill-switch (case-insensitive): set any registered tag to 0 to drop it.
-# Absent ⇒ the runtime stays enabled. e.g.:
+# Per-runtime switch, case-insensitive: 0 = disabled; absent = enabled.
 # PLURNK_EXECS_PYTHON3=0
 # PLURNK_EXECS_BC=0
-
-# Maximum source characters retained from third-party diagnostics in a failed
-# operation's model-facing Problem detail. Empty/unset leaves them unbounded.
+# PLURNK_EXECS_QUESTION=0
+# Maximum diagnostic characters in model-facing errors; empty/unset = unbounded.
 PLURNK_EXECS_ERROR_DETAIL_LIMIT=512

package/README.md

@@ -51,10 +51,15 @@ One package may claim several tags; the consumer instantiates and probes each
 tag independently. A name uses lowercase URI-scheme syntax
 `[a-z][a-z0-9+.-]*`; `only` is reserved by runtime policy. `summary` is the
 one-line capability description. `invocation` defines the body and optional
-target buckets plus one canonical example used for dispatch enforcement and the
-generated `worker://~/_plurnk/tools/` document. A `docs/<tag>.md` file supplies
+target buckets used for dispatch enforcement and a canonical example for its
+generated `worker:///_plurnk/plurnk/<tag>.md` document. A `docs/<tag>.md` file supplies
 supplemental detail. See {§executor-runtime-declaration}.
 
+For JSON inputs, supply `invocation.inputSchema` instead of an authored example
+or signature. The shared renderer lists required top-level fields and links to
+the complete raw schema and description; nested and optional inputs stay in
+that on-demand document ({§executor-input-schema-preview}).
+
 ### Implement the executor
 
 | Runtime shape         | Base class           | Author-owned hooks                                                                      |
@@ -85,11 +90,33 @@ The EXEC `(target)` slot is runtime-specific:
 The consumer supplies both `cwd` and a resolved `target`; the leaf maps them
 to its tool rather than reconstructing filesystem or scheme policy.
 
+### Own invocation metadata
+
+`prepare(input)` validates the tool's raw header metadata before admission and
+returns the effective cwd. `run(args)` receives that cwd and the original
+metadata, separately from the unchanged body. Source acquisition never inherits
+EXEC metadata. `BaseExecutor` supplies `[{"cwd": "..."}]`; `SubprocessExecutor` adds
+literal script arguments with `[{"args": ["arg",...]}]`. Override preparation for
+tool-specific options. See {§executor-metadata}.
+
+### Receive live input
+
+In-process executors may call `args.registerInput?.(async ({ body, metadata,
+signal }) => result)` once during `run()`. Keep the receiver local to that
+invocation, honor cancellation, and return a standard `SchemeResult` for each
+delivery. The consumer routes SEND to the existing execution address and owns
+ordering, deadlines, permissions, and proposals. This does not expose Worker
+identity or grant access to stored output.
+
+`SubprocessExecutor` supplies this receiver when launched with `[{"stdin": "open"}]`.
+SEND writes exact UTF-8 input; `[{"eof": true}]` ends stdin. No option means ordinary
+batch EOF. See [the live-input contract](SPEC.md#executor-live-input-invocation-local-input).
+
 ### Address output
 
 The runtime tag is also the output scheme. A subprocess result is therefore
-read at an address such as `sh:///1/2/3#stdout`, while a structured result may
-be `sqlite:///1/2/3#results`. `exec://` is not an output address. Executors only
+read at an address such as `sh:///ab3d5678#stdout`, while a structured result may
+be `sqlite:///f2c49a10#results`. `exec://` is not an output address. Executors only
 produce channels; the consumer owns storage and every later READ/FIND. See
 {§executor-output-address}.
 
@@ -116,7 +143,6 @@ Policy is subtractive; a downstream layer cannot restore a removed tag. See
 
 - `BaseExecutor`, `SubprocessExecutor`, and `SpawnArgs`.
 - `discover`, `Policy`, `RuntimeTag`, and runtime discovery types.
-- `Advertise`, a deprecated frozen 1.x compatibility helper with no current service path.
 - `ErrorDetail` and `PLURNK_EXECS_ERROR_DETAIL_LIMIT`.
 - Executor arguments, channel, availability, and effect types.
 - `Results`, result types, and runtime-neutral Notice types.

package/SPEC.md

@@ -39,6 +39,7 @@ abstract class BaseExecutor {
 
     abstract get channels(): Readonly<Record<string, ChannelDecl>>;
     get defaultChannel(): string;
+    prepare(input: ExecInput): Promise<ExecPreparation>;
     abstract run(args: ExecArgs): Promise<ExecResult>;
     probe(signal?: AbortSignal): Promise<RuntimeAvailability>;
     effect(target: string | null): Effect;
@@ -55,8 +56,10 @@ interface ExecArgs {
     body: string;
     cwd: string | null;
     target: string | null;
+    metadata: readonly string[] | null;
     env?: NodeJS.ProcessEnv;
     signal: AbortSignal;
+    registerInput?(receiver: ExecInputReceiver): void;
     write(channel: string, chunk: string, mimetype?: string): void;
     setState(channel: string, state: ChannelState): void;
     emit(notice: Notice): void;
@@ -71,10 +74,9 @@ interface ExecArgs {
 `ExecArgs` deliberately carries **no Worker identity**: an executor is a
 worker-agnostic capability, and `run` may assume nothing about which Worker,
 Loop, or workspace invoked it beyond the arguments given. A runtime whose
-behavior depends on a Worker — an attached MCP server, a Worker Functionality
-manager — is published per Worker by its owning module, closing over that
-identity at publication ({§functionality-model-projection} in the core
-specification; the MCP host is the precedent). Consumers must not smuggle
+behavior depends on a workspace — an attached MCP server or Functionality
+manager — is published per workspace by its module, closing over that
+identity at publication ({§functionality-model-projection}). Consumers must not smuggle
 identity through `env` or `body` conventions.
 
 interface RuntimeAvailability {
@@ -101,8 +103,10 @@ surface.
 | `body`     | The authored EXEC body, interpreted according to the runtime's invocation declaration.                |
 | `cwd`      | Consumer-selected project working directory, or `null` for a runtime that has none.                     |
 | `target`   | Consumer-realized optional EXEC target. Its representation and role come from the invocation declaration. |
+| `metadata` | Exact ordered header blocks owned by the invoked executor, retained separately from the body and target. |
 | `env`      | Exact child environment when supplied. A subprocess must use it instead of reconstructing host policy.  |
 | `signal`   | Consumer cancellation. Every executor must honor it at each cancellable boundary.                       |
+| `registerInput` | Optionally register one live input receiver for this invocation under {§executor-live-input}. |
 | `write`    | Append to a declared channel. An optional mimetype replaces that channel's per-call output type.        |
 | `setState` | Move a declared channel from `active` to terminal `closed` or `errored`.                                |
 | `emit`     | Publish a transient, nonterminal Notice.                                                                |
@@ -113,6 +117,61 @@ The executor receives callbacks, never a database, subscription registry,
 packet builder, or wake mechanism. Related lifecycle behavior remains on the
 consumer side of {§executor-role}.
 
+### §executor-metadata Invocation metadata ownership
+
+The invoked executor owns its `[metadata]` for every target kind. The source
+scheme supplies the program or data; it does not inherit the invoking tool's
+options. An internal source READ therefore carries no EXEC metadata. An
+authored READ retains its own source-scheme metadata contract.
+
+| Stage | Contract |
+| ----- | -------- |
+| Preparation | Optional `prepare(input)` receives `runtime`, `body`, logical `target`, default `cwd`, and ordered raw `metadata`, before effect admission or source acquisition. It validates options without executing the program and returns `200` with a concrete `cwd` or `null`, or one universal failure. No hook means no metadata support. |
+| Framework default | `BaseExecutor.prepare` accepts `[{"cwd": "<directory>"}]`. Relative directories resolve against the supplied default cwd; an absent override preserves it. Unknown fields, duplicates, malformed values, and nonexistent directories are refused. Tools can override preparation to own different metadata. |
+| Subprocess options | `SubprocessExecutor` additionally accepts `[{"stdin": "open"}]` ({§executor-stdin}) and `[{"args": ["arg",...]}]`. The JSON array contains strings without NUL, preserves order and empty/whitespace-containing arguments, and appends directly to the spawn argument vector without shell parsing. Inline programs retain their interpreter's usual argument conventions. |
+| Execution | `run()` receives the prepared cwd, realized target, unchanged body, and original metadata. The subprocess family uses the same option parser to obtain argv; cwd is already prepared and is not resolved a second time. |
+| Evidence | Raw metadata follows the existing transient proposal handoff, never added to proposal attrs or emitted as receipt metadata. Expected preparation failures retain the tool's Problem; malformed preparation results are internal contract failures. |
+
+Metadata does not turn inline programs or script stdin into JSON envelopes.
+Executable references document advanced options on demand; no language-level
+option names or hot-path teaching are required.
+
+### §executor-live-input Invocation-local input
+
+`ExecArgs.registerInput?(receiver)` binds one receiver to the current invocation.
+The receiver accepts `{ body: string, metadata: readonly string[] | null,
+signal: AbortSignal }` and resolves a universal `SchemeResult`. The body is exact
+authored text; metadata belongs to the receiver. Registration is once per run,
+never executor-instance state. An absent callback means the consumer cannot
+deliver live input. A receiver must honor cancellation at each delivery boundary.
+
+| Responsibility | Owner |
+| --- | --- |
+| Address, workspace admission, capability checks, proposals | Consumer, using the existing execution identity and effect. |
+| Delivery ordering, bounded backpressure, lifetime | Consumer; serialize accepted deliveries, never replay an ambiguous write, retire on execution settlement/cancellation. |
+| Input meaning, framing, EOF, delivery result | Receiver; acceptance does not imply consumption, command success, or execution completion. |
+| Output, progress, completion | Existing `write`, `setState`, and `run` result; input introduces no second output or wake path. |
+
+#### §executor-stdin Subprocess input
+
+`SubprocessExecutor` accepts `[{"stdin": "open"}]` at invocation. The initial recipe
+input precedes SEND bodies and stdin remains open; without this option, existing
+batch input and EOF behavior is unchanged. The same input adapter serves `jq`.
+
+| SEND input | Effect |
+| --- | --- |
+| Body, no metadata | Write its exact UTF-8 bytes, including authored newlines; no implicit newline. Empty input is a no-op, not EOF. |
+| `[{"eof": true}]` with optional body | Write the body, then close stdin. Later SENDs return `410 input-closed`, including repeated EOF. |
+| Other or duplicate metadata | `400`, before writing. |
+| Pipe failure | Factual delivery failure with the native error code; no automatic retry. |
+| Delivery cancellation | Stop the pending write and close stdin. The process retains its ordinary lifecycle. |
+
+A successful receipt reports `bytesAccepted` and `inputClosed`, with those facts
+in the ordinary model-visible `detail`. It acknowledges the writable pipe, not
+application processing. Subprocess leaves inherit this
+contract; logical executors need not offer a receiver. In particular, SQLite,
+client-interaction tools, and MCP transports do not gain stdin through this API.
+
 ### §executor-channels Channels
 
 The executor declares every channel it may write. The consumer seeds a stream
@@ -135,8 +194,10 @@ reformatting arbitrary source JSON read from an entry.
 subprocess `exitCode`. A result with `status >= 400` carries exactly one RFC
 9457 Problem whose status agrees with the result. Expected runtime failures
 resolve as failure results and leave affected channels `errored`; they do not
-throw. The consumer validates the boundary and converts a throw or invalid
-result into its own durable failure before closing the stream.
+throw. Rejection by an aborted execution's signal reason or an `AbortError`
+is cancellation, not an executor defect; the consumer preserves its distinct
+cancellation/deadline result. Other throws and invalid results become durable
+contract failures before the consumer closes the stream.
 
 A nonzero subprocess exit directs the caller only to inspect both stdout and
 stderr because either may contain the useful diagnostic; it does not presume
@@ -202,27 +263,42 @@ no second scheme manifest.
 
 | Output                    | Model-facing address                                               |
 | ------------------------- | ------------------------------------------------------------------ |
-| Calling worker's stream   | `<tag>:///<loop>/<turn>/<sequence>/EXEC#<channel>`                 |
-| Fragmentless read         | `<tag>:///<loop>/<turn>/<sequence>/EXEC` → the declared default channel |
-| Example subprocess stdout | `sh:///1/2/3/EXEC#stdout`                                          |
-| Example structured result | `sqlite:///1/2/3/EXEC#results`                                     |
+| Workspace execution stream   | `<tag>:///<id>#<channel>`                 |
+| Fragmentless read         | `<tag>:///<id>` → the declared default channel |
+| Example subprocess stdout | `sh:///ab3d5678#stdout`                                          |
+| Example structured result | `sqlite:///c2d45678#results`                                     |
 
 The executor only produces through `write` and `setState`. The consumer stores
 the entry and serves every later READ/FIND through uniform entry machinery.
 An executor does not implement a private read face, orientation receipt,
-slicer, or index. Owner-qualified cross-worker addresses and packet projection
-belong to core's {§stream-owner-scoped} and {§exec-stream} contracts.
+slicer, or index. Workspace-stable resource addresses and packet projection
+belong to core's {§execution-output-identity} and {§exec-stream} contracts.
+Address resolution binds the workspace without requiring an exact stored row:
+FIND patterns and descendant resource paths participate in ordinary discovery;
+an exact READ reports its own missing resource ({§entry-address-resolution}).
+
+`publishedChannel` selects one declared channel for automatic stream observations;
+absent/null selects all channels. Non-published channels remain READ-addressable.
+This is the ordinary subscription publication selection, not another delivery path.
 
 ### §executor-entry-sink Optional materialization
 
-`entry(path, content, { tags, mimetype? })` is a consumer-implemented sink, not
-executor access to storage. The consumer materializes or updates an entry,
-uses the tags to classify its ordinary journal announcement, and resolves the
-canonical model-facing address. Tags never become resource metadata.
-`content === null` requests consumer-sourced
-acquisition. Rejection means only that this materialization failed; it does not
-invalidate the executor's upstream result. When the sink is absent, the
-executor preserves its result without inventing a materialization verdict.
+`entry(path, content, { mimetype?, name? })` is a consumer-implemented sink, not
+executor access to storage. It returns the canonical address of an ordinary
+resource; publication alone does not attach media or wake a Worker.
+
+| Input | Meaning |
+| --- | --- |
+| Absolute resource URL | Materialize or update that resource through its scheme owner. |
+| `path: null` | Publish beneath this invocation's output address, in `resources/`. Preserve `name` as one URI-encoded component; otherwise allocate an eight-character hexadecimal identifier. Duplicate names receive a hash suffix, never overwrite another publication. The returned address is workspace-stable and carries no Worker selector. |
+| String content + mimetype | Supplied text; preserve its source layout. |
+| `Uint8Array` content + mimetype | Supplied bytes, retained as bytes, not a JSON/base64 body. |
+| `content: null` | Consumer-sourced acquisition from an absolute HTTP(S) URL. |
+
+Core owns names, storage, publication evidence, and byte acquisition. Executors
+publish returned addresses in their result. Rejection means materialization
+failed, not that the upstream operation had no effect. An absent sink cannot
+be reported as successful resource publication.
 
 ## §executor-discovery Discovery and registration
 
@@ -284,7 +360,7 @@ at boot; changing package membership or configuration requires a restart.
 | ------------- | -------------------------------------------------------------------------------------------------- |
 | `name`        | Canonical runtime tag and derived output-scheme name, admitted below.                              |
 | `glyph`       | Optional presentation glyph.                                                                       |
-| `summary`     | Required one-line description, or `{ from: "tools" }` for an exact family inventory.              |
+| `summary`     | Required one-line description, or `{ from: "tools", description?: string }` for an exact family inventory with an optional one-line purpose. |
 | `invocation`  | Required body and target contract, validated and normalized below.                                 |
 | `details`     | Optional supplemental Markdown. `docs/<tag>.md` wins over the inline manifest field.               |
 | `attribution` | Published per-tag projection of the validated package declaration ({§plugin-attribution}).         |
@@ -294,7 +370,11 @@ The framework validates and carries the summary source, invocation, and suppleme
 details as separate facts. A `{ from: "tools" }` summary is valid only for a
 runtime implementing {§executor-tool-registry}; the consumer resolves it from
 the exact effective tool set, after capability attenuation, so a denied tool
-cannot survive in the family orientation line. The consumer deterministically renders the
+cannot survive in the family orientation line. The inventory renders as
+one compact executable fence naming `runtime (target|...)`, with the optional
+purpose as a trailing aside and body line breaks represented by literal `\n`;
+an authored string remains a description, without expanding its tool inventory.
+The consumer deterministically renders the
 model-facing tool document from either the static invocation or the executor's exact
 {§executor-tool-registry}; authors never duplicate Summary or Invocation in
 prose. A
@@ -320,19 +400,20 @@ details; the generated tool document owns the one model-facing H1.
 | `target.kind`      | One of the structural realization modes below.                                                            |
 | `exclusive`        | Optional `true`: body and target are alternative inputs and supplying both is refused.                    |
 | `example`          | Concise executable witness with a one-line `body`, `target`, or both as the declared shape permits. |
-| `signature`        | One-line structural body signature for a schema-backed invocation; no fabricated argument values. |
+| `signature`        | Authored one-line structural body signature when no JSON Schema defines the input. |
+| `inputSchema`      | Original JSON Schema object for the input; the common document renderer derives its preview. |
 
 | Target kind | Consumer realization                                                                                                           |
 | ----------- | ------------------------------------------------------------------------------------------------------------------------------ |
 | `literal`   | Preserve the complete authored target string. It is an executor identifier, never a scheme read or filesystem classification. |
 | `path`      | Accept only a local or `file://` path and pass that path directly.                                                             |
-| `resource`  | Pass a local/file path directly; resolve a non-file data-scheme address through one exact READ and materialize its string representation to a temporary file. |
+| `resource`  | Pass a local/file path directly. After acceptance, resolve a non-file data-scheme address through one exact READ; use its owner-supplied native file or a standalone temporary representation ({§exec-source-temporary}). |
 | `script`    | As `resource`, and the local path must be an existing file: a directory or an absent path is refused before anything spawns ({§exec-executor-slot}). |
 
 Every EXEC must supply at least a body or target even when neither field is
 independently required. A target's meaning never changes because the body is
-empty or non-empty. `exclusive` requires a target declaration. Exactly one of `example` or
-`signature` is present. An example must satisfy the same required, refused,
+empty or non-empty. `exclusive` requires a target declaration. Exactly one of `example`,
+`signature`, or `inputSchema` is present. An example must satisfy the same required, refused,
 and exclusive buckets and parse as exactly one EXEC section for the runtime. A
 signature is presentation, not an executable example; dispatch still enforces
 the invocation's body and target declarations. An invocation declaration
@@ -377,19 +458,32 @@ I/O boundary rather than making packet assembly perform network discovery.
 §executor-tool-document **Tool documents are the model-facing executor
 directory.** A general runtime's document carries exact H2 `Summary` and
 `Invocation` sections plus its executable witness. Its Summary is that compact
-invocation witness in inline code, with the authored description as an
-operation annotation on its invocation line and a literal `\n` before a
-one-line body. An exact registry instead renders one compact family document
-whose Summary remains the family description and whose H2 `Invocation`
-contains one `example` fence with
-every exact annotated EXEC heading and signature, plus one child document per
-tool. Each child's Summary is its annotated invocation form; its H2 `Invocation`
-contains the literal target, signature, and supplemental input details.
+invocation witness in plain text, with the authored description as an
+operation aside on its invocation line and a literal `\n` before a
+one-line body. The bundled subprocess interpreters declare concrete inline-program
+examples; their catalog summaries include the program body without a script target.
+An exact registry instead renders one compact family document whose Summary is
+authored or derived from its effective tools. Its H2 `Tools` contains one
+executable fence per tool, naming the runtime and exact target, with its aside
+and input preview. A schema-backed invocation
+links from its aside to a child document containing the full description and
+original input JSON Schema. Non-schema invocations retain their authored witness
+and supplemental details.
 Supplemental `details` follows framework-owned sections and cannot own identity,
 invocation, or admission. The consumer chooses resource addresses, materializes
 the documents, and exposes each Summary through ordinary FIND metadata. No
 executor table or executor-specific discovery protocol exists.
 
+§executor-input-schema-preview Schema-backed previews list only explicitly
+required top-level fields, with quoted names and declared broad JSON types.
+Nested objects and arrays stay opaque; an undeclared type is `unknown`. Optional
+fields, references, constraints, and conditional branches are not interpreted.
+The preview is not a complete signature or validation promise. Its schema link
+provides the complete original schema, including descriptions, definitions,
+references, and constraints; repository-owned referenced schemas are included
+unchanged alongside it. Documentation performs no network reference resolution.
+Output schemas are not input teaching.
+
 Runtime-name admission is one identity contract:
 
 | Constraint  | Contract                                                                                                      |
@@ -429,7 +523,8 @@ swallowed.
 
 ### §executor-policy Subtractive runtime policy
 
-Discovery applies the daemon's registration policy to every tag. The exported
+Registration applies the daemon's policy to every tag, whether discovered from
+a package or supplied by a daemon module, including workspace-scoped runtimes. The exported
 `Policy` parser can apply the same grammar to additional consumer-owned layers.
 
 | Variable                                 | Enforced effect                                             |
@@ -440,18 +535,11 @@ Discovery applies the daemon's registration policy to every tag. The exported
 | `Policy.enabledAcross(tag, [a, b, ...])` | Keep the tag only when every supplied layer enables it.     |
 
 Policy is purely subtractive: no layer can re-enable a tag removed by another.
-Boot-disabled tags are absent from the registry and returned in
-`Discovery.disabled`. Workspace and loop admission remain consumer concerns;
+Disabled tags publish neither an executor nor its scheme or tool documents;
+package discovery also returns them in `Discovery.disabled`.
+Workspace and loop admission remain consumer concerns;
 the framework does not define a second Active/Available state machine.
 
-### §executor-advertise-compat Frozen `Advertise` compatibility
-
-| Surface                              | 1.x contract                                                                                                |
-|--------------------------------------|-------------------------------------------------------------------------------------------------------------|
-| `Advertise.contribute(registry, fn)` | Filters the supplied registry; returns `NO_EXECS_NOTICE` only when the filtered result is empty.            |
-| Architectural ownership             | None. It does not discover, probe, admit, dispatch, or render; the composed service never calls it.         |
-| Evolution                            | Frozen. New consumers compose discovery and `Policy` with their own presentation. Removal is SemVer-major. |
-
 ## §executor-default-inventory Current installed set
 
 The default `@plurnk/plurnk-service` composition installs the following
@@ -490,9 +578,10 @@ interface SpawnArgs {
 | `python3`                  | `python3 -c <body>`.                                                 |
 | Other default-base runtime | `<runtime> -c <body>`; specialized leaves override this fallback.    |
 
-With a target, the target is the program and the body is its stdin. The working
+With a target, the target is the program and the body is its stdin. Each leaf
+uses its interpreter's file form (`awk -f <target>`, for example). The working
 directory is the consumer's `cwd` — the project root, or the directory a
-`{cwd=<directory>}` block on the heading names ({§exec-executor-slot}); a
+`[{"cwd": "<directory>"}]` block on the heading names ({§exec-executor-slot}); a
 directory is never a target. Data runtimes define their own declared target
 kind and role.
 

package/dist/BaseExecutor.d.ts

@@ -1,5 +1,5 @@
 import type { SchemeHandler, SchemeManifest } from "@plurnk/plurnk-schemes";
-import type { ChannelDecl, Effect, ExecArgs, ExecResult, ExecutorMetadata, RuntimeAvailability } from "./types.ts";
+import type { ChannelDecl, Effect, ExecArgs, ExecInput, ExecPreparation, ExecResult, ExecutorMetadata, RuntimeAvailability } from "./types.ts";
 export default abstract class BaseExecutor implements SchemeHandler {
     readonly runtime: string;
     readonly glyph: string;
@@ -7,7 +7,9 @@ export default abstract class BaseExecutor implements SchemeHandler {
     get manifest(): SchemeManifest;
     get traits(): ReadonlyArray<string> | undefined;
     get defaultChannel(): string;
+    get publishedChannel(): string | null;
     abstract get channels(): Readonly<Record<string, ChannelDecl>>;
+    prepare(input: ExecInput): Promise<ExecPreparation>;
     abstract run(args: ExecArgs): Promise<ExecResult>;
     probe(_signal?: AbortSignal): Promise<RuntimeAvailability>;
     effect(_target: string | null): Effect;

package/dist/BaseExecutor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseExecutor.d.ts","sourceRoot":"","sources":["../src/BaseExecutor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAWnH,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,YAAa,YAAW,aAAa;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,YAAY,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,gBAAgB,EAG/C;IAaD,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAGD,IAAI,MAAM,IAAI,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAE9C;IAID,IAAI,cAAc,IAAI,MAAM,CAE3B;IAOD,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAO/D,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAmB5C,KAAK,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAE/D;IAQD,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAErC;CACJ"}
+{"version":3,"file":"BaseExecutor.d.ts","sourceRoot":"","sources":["../src/BaseExecutor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAY/I,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,YAAa,YAAW,aAAa;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,YAAY,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,gBAAgB,EAG/C;IAaD,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAGD,IAAI,MAAM,IAAI,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAE9C;IAID,IAAI,cAAc,IAAI,MAAM,CAE3B;IAGD,IAAI,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAEpC;IAOD,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAE/D,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,eAAe,CAAC,CAElD;IAOD,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAmB5C,KAAK,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAE/D;IAQD,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAErC;CACJ"}

package/dist/BaseExecutor.js

@@ -1,4 +1,5 @@
 import { OutputScheme } from "@plurnk/plurnk-schemes";
+import InvocationMetadata from "./InvocationMetadata.js";
 // Base class for runtime executors (parallel to plurnk-mimetypes' BaseHandler).
 // A `@plurnk/plurnk-execs-*` sibling subclasses this and implements `run()`.
 // The framework instantiates one executor per matched runtime tag, injecting
@@ -44,6 +45,13 @@ export default class BaseExecutor {
     get defaultChannel() {
         return Object.keys(this.channels)[0] ?? "";
     }
+    // Select the existing stream-publication contract; null publishes every channel.
+    get publishedChannel() {
+        return null;
+    }
+    prepare(input) {
+        return InvocationMetadata.prepare(input);
+    }
     // Whether this runtime's execution environment is usable in the current
     // deployment. Default: available (pure / in-process runtimes — e.g. node,
     // sqlite, where the daemon itself satisfies the dependency). Subclasses

package/dist/BaseExecutor.js.map

@@ -1 +1 @@
-{"version":3,"file":"BaseExecutor.js","sourceRoot":"","sources":["../src/BaseExecutor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAItD,gFAAgF;AAChF,6EAA6E;AAC7E,6EAA6E;AAC7E,yEAAyE;AACzE,EAAE;AACF,2EAA2E;AAC3E,6EAA6E;AAC7E,2EAA2E;AAC3E,4DAA4D;AAC5D,MAAM,CAAC,OAAO,OAAgB,YAAY;IAC7B,OAAO,CAAS;IAChB,KAAK,CAAS;IAEvB,YAAY,EAAE,OAAO,EAAE,KAAK,EAAoB;QAC5C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACvB,CAAC;IAED,kEAAkE;IAClE,gCAAgC;IAChC,8EAA8E;IAC9E,8EAA8E;IAC9E,6EAA6E;IAC7E,yDAAyD;IACzD,2EAA2E;IAC3E,0EAA0E;IAC1E,6EAA6E;IAC7E,2EAA2E;IAC3E,8EAA8E;IAC9E,IAAI,QAAQ;QACR,OAAO,YAAY,CAAC,mBAAmB,CAAC;YACpC,IAAI,EAAE,IAAI,CAAC,OAAO;YAClB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,QAAQ,EAAE,MAAM,CAAC,WAAW,CACxB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAC7E;YACD,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,MAAM,EAAE,IAAI,CAAC,MAAM;SACtB,CAAC,CAAC;IACP,CAAC;IAED,+DAA+D;IAC/D,IAAI,MAAM;QACN,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,yEAAyE;IACzE,oEAAoE;IACpE,IAAI,cAAc;QACd,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC/C,CAAC;IAgBD,wEAAwE;IACxE,0EAA0E;IAC1E,wEAAwE;IACxE,iEAAiE;IACjE,EAAE;IACF,8EAA8E;IAC9E,yEAAyE;IACzE,2EAA2E;IAC3E,yEAAyE;IACzE,4DAA4D;IAC5D,EAAE;IACF,sEAAsE;IACtE,4EAA4E;IAC5E,yEAAyE;IACzE,kEAAkE;IAClE,6EAA6E;IAC7E,iBAAiB;IACjB,KAAK,CAAC,KAAK,CAAC,OAAqB;QAC7B,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;IAC/B,CAAC;IAED,4EAA4E;IAC5E,6EAA6E;IAC7E,8EAA8E;IAC9E,yEAAyE;IACzE,wEAAwE;IACxE,gEAAgE;IAChE,MAAM,CAAC,OAAsB;QACzB,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ"}
+{"version":3,"file":"BaseExecutor.js","sourceRoot":"","sources":["../src/BaseExecutor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAGtD,OAAO,kBAAkB,MAAM,yBAAyB,CAAC;AAEzD,gFAAgF;AAChF,6EAA6E;AAC7E,6EAA6E;AAC7E,yEAAyE;AACzE,EAAE;AACF,2EAA2E;AAC3E,6EAA6E;AAC7E,2EAA2E;AAC3E,4DAA4D;AAC5D,MAAM,CAAC,OAAO,OAAgB,YAAY;IAC7B,OAAO,CAAS;IAChB,KAAK,CAAS;IAEvB,YAAY,EAAE,OAAO,EAAE,KAAK,EAAoB;QAC5C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACvB,CAAC;IAED,kEAAkE;IAClE,gCAAgC;IAChC,8EAA8E;IAC9E,8EAA8E;IAC9E,6EAA6E;IAC7E,yDAAyD;IACzD,2EAA2E;IAC3E,0EAA0E;IAC1E,6EAA6E;IAC7E,2EAA2E;IAC3E,8EAA8E;IAC9E,IAAI,QAAQ;QACR,OAAO,YAAY,CAAC,mBAAmB,CAAC;YACpC,IAAI,EAAE,IAAI,CAAC,OAAO;YAClB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,QAAQ,EAAE,MAAM,CAAC,WAAW,CACxB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAC7E;YACD,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,MAAM,EAAE,IAAI,CAAC,MAAM;SACtB,CAAC,CAAC;IACP,CAAC;IAED,+DAA+D;IAC/D,IAAI,MAAM;QACN,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,yEAAyE;IACzE,oEAAoE;IACpE,IAAI,cAAc;QACd,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC/C,CAAC;IAED,iFAAiF;IACjF,IAAI,gBAAgB;QAChB,OAAO,IAAI,CAAC;IAChB,CAAC;IASD,OAAO,CAAC,KAAgB;QACpB,OAAO,kBAAkB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IASD,wEAAwE;IACxE,0EAA0E;IAC1E,wEAAwE;IACxE,iEAAiE;IACjE,EAAE;IACF,8EAA8E;IAC9E,yEAAyE;IACzE,2EAA2E;IAC3E,yEAAyE;IACzE,4DAA4D;IAC5D,EAAE;IACF,sEAAsE;IACtE,4EAA4E;IAC5E,yEAAyE;IACzE,kEAAkE;IAClE,6EAA6E;IAC7E,iBAAiB;IACjB,KAAK,CAAC,KAAK,CAAC,OAAqB;QAC7B,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;IAC/B,CAAC;IAED,4EAA4E;IAC5E,6EAA6E;IAC7E,8EAA8E;IAC9E,yEAAyE;IACzE,wEAAwE;IACxE,gEAAgE;IAChE,MAAM,CAAC,OAAsB;QACzB,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ"}

package/dist/DocFile.d.ts

@@ -0,0 +1,5 @@
+export default class DocFile {
+    static read(dir: string, tag: string): Promise<string | null>;
+    static body(source: string, tag: string): string;
+}
+//# sourceMappingURL=DocFile.d.ts.map

package/dist/DocFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocFile.d.ts","sourceRoot":"","sources":["../src/DocFile.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,OAAO,OAAO,OAAO;IAExB,OAAa,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAMlE;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAM/C;CACJ"}

package/dist/DocFile.js

@@ -0,0 +1,28 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+// A package's `docs/<tag>.md` — the authored teaching carried beneath a generated tool
+// document's header ({§executor-discovery}). Runtimes and Functionality families share this
+// one rule: the file stays a valid standalone document whose exact authoring title `# <tag>`
+// is removed, because the generated document owns the one model-facing H1.
+export default class DocFile {
+    // The tag's supplemental detail file, or null when the package ships none.
+    static async read(dir, tag) {
+        try {
+            return DocFile.body(await fs.readFile(path.join(dir, "docs", `${tag}.md`), "utf-8"), tag);
+        }
+        catch {
+            return null;
+        }
+    }
+    static body(source, tag) {
+        const title = `# ${tag}`;
+        if (source === title || source === `${title}\n`)
+            return "";
+        if (source.startsWith(`${title}\r\n`))
+            return source.slice(title.length + 2).replace(/^\r?\n/u, "");
+        if (source.startsWith(`${title}\n`))
+            return source.slice(title.length + 1).replace(/^\r?\n/u, "");
+        return source;
+    }
+}
+//# sourceMappingURL=DocFile.js.map

package/dist/DocFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocFile.js","sourceRoot":"","sources":["../src/DocFile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAClC,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,uFAAuF;AACvF,4FAA4F;AAC5F,6FAA6F;AAC7F,2EAA2E;AAC3E,MAAM,CAAC,OAAO,OAAO,OAAO;IACxB,2EAA2E;IAC3E,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAW,EAAE,GAAW;QACtC,IAAI,CAAC;YACD,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,CAAC;QAC9F,CAAC;QAAC,MAAM,CAAC;YACL,OAAO,IAAI,CAAC;QAChB,CAAC;IACL,CAAC;IAED,MAAM,CAAC,IAAI,CAAC,MAAc,EAAE,GAAW;QACnC,MAAM,KAAK,GAAG,KAAK,GAAG,EAAE,CAAC;QACzB,IAAI,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,GAAG,KAAK,IAAI;YAAE,OAAO,EAAE,CAAC;QAC3D,IAAI,MAAM,CAAC,UAAU,CAAC,GAAG,KAAK,MAAM,CAAC;YAAE,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;QACpG,IAAI,MAAM,CAAC,UAAU,CAAC,GAAG,KAAK,IAAI,CAAC;YAAE,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;QAClG,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ"}

package/dist/InvocationMetadata.d.ts

@@ -0,0 +1,22 @@
+import { type SchemeResult } from "@plurnk/plurnk-schemes";
+import type { ExecInput, ExecPreparation } from "./types.ts";
+type Options = {
+    cwd?: string;
+    args: string[];
+    stdin?: "open";
+};
+type Accepted = {
+    args?: boolean;
+    stdin?: boolean;
+};
+type Parsed = {
+    options: Options;
+} | {
+    failure: SchemeResult;
+};
+export default class InvocationMetadata {
+    static parse(input: ExecInput, accepted?: Accepted): Parsed;
+    static prepare(input: ExecInput, accepted?: Accepted): Promise<ExecPreparation>;
+}
+export {};
+//# sourceMappingURL=InvocationMetadata.d.ts.map

package/dist/InvocationMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InvocationMetadata.d.ts","sourceRoot":"","sources":["../src/InvocationMetadata.ts"],"names":[],"mappings":"AAEA,OAAO,EAA4B,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACrF,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7D,KAAK,OAAO,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAChE,KAAK,QAAQ,GAAG;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AACpD,KAAK,MAAM,GAAG;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC;AAK/D,MAAM,CAAC,OAAO,OAAO,kBAAkB;IACnC,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,GAAE,QAAa,GAAG,MAAM,CA6B9D;IAED,OAAa,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,GAAE,QAAa,GAAG,OAAO,CAAC,eAAe,CAAC,CAgBxF;CACJ"}

package/dist/InvocationMetadata.js

@@ -0,0 +1,63 @@
+import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { MetadataOptions, Results } from "@plurnk/plurnk-schemes";
+// {§executor-metadata} The executor framework owns these options, not Core. The
+// heading's `[metadata]` is one JSON array of option objects ({§scheme-metadata-modifier});
+// the keys this framework knows are `cwd`, `args`, and `stdin`.
+export default class InvocationMetadata {
+    static parse(input, accepted = {}) {
+        const fail = (code, detail) => ({
+            failure: Results.failure("executor:metadata", code, 400, detail, {}, {
+                runtime: input.runtime, retryable: false,
+            }),
+        });
+        const read = MetadataOptions.parse(input.metadata, "executor:metadata", { runtime: input.runtime });
+        if ("failure" in read)
+            return read;
+        const options = { args: [] };
+        for (const [field, value] of Object.entries(read.options)) {
+            if (field !== "cwd" && !(accepted.args && field === "args") && !(accepted.stdin && field === "stdin")) {
+                return fail("metadata-unsupported", `Executable tool '${input.runtime}' does not accept metadata field '${field}'.`);
+            }
+            if (field === "stdin") {
+                if (value !== "open")
+                    return fail("invalid-stdin", 'Execution stdin accepts only "open".');
+                options.stdin = "open";
+                continue;
+            }
+            if (field === "cwd") {
+                if (typeof value !== "string" || value.length === 0 || value.includes("\0"))
+                    return fail("invalid-cwd", "Execution cwd must be a nonempty directory path string without NUL.");
+                options.cwd = value;
+                continue;
+            }
+            if (!Array.isArray(value) || !value.every((arg) => typeof arg === "string" && !arg.includes("\0"))) {
+                return fail("invalid-args", "Execution args must be a JSON array of strings without NUL.");
+            }
+            options.args = value;
+        }
+        return { options };
+    }
+    static async prepare(input, accepted = {}) {
+        const parsed = this.parse(input, accepted);
+        if ("failure" in parsed)
+            return parsed.failure;
+        const directory = parsed.options.cwd;
+        if (directory === undefined)
+            return { status: 200, cwd: input.cwd };
+        const cwd = resolve(input.cwd ?? process.cwd(), directory);
+        try {
+            if ((await stat(cwd)).isDirectory())
+                return { status: 200, cwd };
+        }
+        catch (cause) {
+            const code = cause.code;
+            if (code !== "ENOENT" && code !== "ENOTDIR")
+                throw cause;
+        }
+        return Results.failure("executor:metadata", "cwd-not-found", 400, `Execution cwd '${directory}' is not an existing directory.`, {}, {
+            runtime: input.runtime, retryable: false,
+        });
+    }
+}
+//# sourceMappingURL=InvocationMetadata.js.map

package/dist/InvocationMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InvocationMetadata.js","sourceRoot":"","sources":["../src/InvocationMetadata.ts"],"names":[],"mappings":"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"}

package/dist/RuntimeInvocation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RuntimeInvocation.d.ts","sourceRoot":"","sources":["../src/RuntimeInvocation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGR,iBAAiB,IAAI,qBAAqB,EAE1C,mBAAmB,EAGtB,MAAM,YAAY,CAAC;AAoEpB,MAAM,CAAC,OAAO,OAAO,iBAAiB;IAClC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,qBAAqB,CAoFzF;IAED,MAAM,CAAC,kBAAkB,CACrB,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GAChB,mBAAmB,CA4CrB;CACJ"}
+{"version":3,"file":"RuntimeInvocation.d.ts","sourceRoot":"","sources":["../src/RuntimeInvocation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGR,iBAAiB,IAAI,qBAAqB,EAE1C,mBAAmB,EAGtB,MAAM,YAAY,CAAC;AAqEpB,MAAM,CAAC,OAAO,OAAO,iBAAiB;IAClC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,qBAAqB,CAsFzF;IAED,MAAM,CAAC,kBAAkB,CACrB,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GAChB,mBAAmB,CA4CrB;CACJ"}