@plurnk/plurnk-execs 1.16.5 → 1.18.0

package/.env.defaults

@@ -1,16 +1,24 @@
-# --- @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
+
+# Subprocess-common floors ({§operator-config-env-defaults}, {§exec-env-scoped}). The
+# executor framework owns these because every subprocess runtime wants them and one owner
+# per key is enforced at boot — each executor redeclaring them would crash the daemon.
+# They are set-if-unset, so an operator who exports PAGER=less keeps theirs.
+# A pager that waits for a keypress hangs a spawn that has no terminal.
+PAGER=cat
+# git consults its own pager variable first, so both are set.
+GIT_PAGER=cat
+# Colour escapes and progress spinners are noise in a captured channel.
+NO_COLOR=1
+# Non-interactive by construction: tools that branch on CI take the unattended path.
+CI=1

package/README.md

@@ -1,7 +1,7 @@
 # plurnk-execs
 
 Lean framework and contract for `@plurnk/plurnk-execs-*` runtime packages. Core
-uses it to discover EXEC tags, admit calls, and stream each runtime's output
+uses it to discover runtime tags, admit calls, and stream each runtime's output
 under its own tag-addressed scheme. The default service manifest, not this
 framework, owns the standard installed leaf set ({§bundled-set}).
 
@@ -18,7 +18,7 @@ framework or service.
 ## Documentation
 
 - [`SPEC.md`](./SPEC.md) — authoritative executor author and consumer contract.
-- [plurnk-contracts](https://github.com/plurnk/plurnk-service/tree/main/plurnk-contracts) — EXEC AST and shared runtime-neutral contracts.
+- [plurnk-contracts](https://github.com/plurnk/plurnk-service/tree/main/plurnk-contracts) — the execution AST and shared runtime-neutral contracts.
 - [plurnk-schemes](https://github.com/plurnk/plurnk-service/tree/main/plurnk-schemes) — universal operation results and derived output-scheme contract.
 
 ## Write an executor
@@ -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                                                                      |
@@ -75,7 +80,7 @@ acceptance is not a same-turn result. See {§executor-effect}.
 
 ### Understand the target
 
-The EXEC `(target)` slot is runtime-specific:
+The execution's `(target)` slot is runtime-specific:
 
 | Runtime family | Typical mapping                                                   |
 | -------------- | ----------------------------------------------------------------- |
@@ -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
+execution 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

@@ -6,7 +6,7 @@ the framework; executor leaves implement it.
 ## §executor-role Role and ownership
 
 An executor owns one declared runtime-specific invocation shape, its mapping
-from that EXEC body and realized target to work, declared output channels,
+from that fence body and realized target to work, declared output channels,
 environment availability, and effect classification. The consumer owns
 dispatch, invocation-shape enforcement and target realization, proposal policy,
 storage, subscriptions, deadlines, polling, cancellation delivery, packet
@@ -17,7 +17,7 @@ flowchart LR
     Manifest["package runtime declarations"] --> Discover["framework discovery"]
     Discover --> Registry["runtime-tag registry"]
     Registry --> Probe["consumer instantiates and probes each tag"]
-    Request["EXEC with runtime tag"] --> Effect["executor effect fact"]
+    Request["fence with runtime tag"] --> Effect["executor effect fact"]
     Effect --> Admission["consumer proposal policy"]
     Admission --> Stream["consumer creates tag-addressed stream"]
     Stream --> Run["executor run with consumer sinks"]
@@ -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,11 +74,12 @@ 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
-identity through `env` or `body` conventions.
+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; a consumer that owns both a
+runtime and the execution identity binds the two to each other outside these
+arguments, at the operation.
 
 interface RuntimeAvailability {
     available: boolean;
@@ -90,7 +94,7 @@ The framework constructs one executor per matched runtime tag with
 `this.runtime`; it must not retain per-run state on the executor instance. The
 derived addressable runtime scheme retains `glyph` for client discovery
 ({§manifest-client-display}); runtime aliases remain excluded from scheme
-model-teaching because the EXEC invocation directory owns that hot-path
+model-teaching because the execution invocation directory owns that hot-path
 surface.
 
 ### §executor-sinks Inputs and sinks
@@ -98,11 +102,13 @@ surface.
 | Field      | Contract                                                                                                |
 | ---------- | ------------------------------------------------------------------------------------------------------- |
 | `runtime`  | The matched tag.                                                                                        |
-| `body`     | The authored EXEC body, interpreted according to the runtime's invocation declaration.                |
+| `body`     | The authored fence 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. |
+| `target`   | Consumer-realized optional execution 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 +119,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 execution 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 +196,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
@@ -173,7 +236,7 @@ reclassifies the materialized path.
 | `pure` | Has no externally observable side effect.    | Automatically accepted.    |
 
 The classification controls admission policy and may be reused as operational
-metadata; it never changes within the invocation. After acceptance, every EXEC
+metadata; it never changes within the invocation. After acceptance, every execution
 uses the same background stream path: output is not returned in the dispatching
 turn. Core owns that composed behavior in {§exec-host-proposes},
 {§exec-readpure-ungated}, and {§exec-stream}.
@@ -195,34 +258,49 @@ unavailable is a fail-hard boot error.
 
 ## §executor-output-address Tag-addressed output
 
-`exec` is the consumer's internal EXEC dispatcher; it is not a model-facing
+`exec` is the consumer's internal execution dispatcher; it is not a model-facing
 output namespace. Every available runtime receives one derived read-only
 scheme face from its tag, channels, and default channel. The executor authors
 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 +362,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 +372,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,20 +402,21 @@ 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
+Every execution 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,
-and exclusive buckets and parse as exactly one EXEC section for the runtime. A
+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 executor fence for the runtime. A
 signature is presentation, not an executable example; dispatch still enforces
 the invocation's body and target declarations. An invocation declaration
 with a missing field, unknown field, invalid combination, multiline role, or
@@ -377,25 +460,38 @@ 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                                                                                                      |
 | ----------- | ------------------------------------------------------------------------------------------------------------- |
-| Syntax      | `[a-z][a-z0-9+.-]*`: canonical lowercase RFC-scheme syntax that is also an admitted EXEC identifier.           |
-| Identity    | The exact name is the EXEC selector, registry key, tool-family identity, and output URI-scheme name.           |
+| Syntax      | `[a-z][a-z0-9+.-]*`: canonical lowercase RFC-scheme syntax that is also an admitted execution identifier.           |
+| Identity    | The exact name is the fence name, registry key, tool-family identity, and output URI-scheme name.           |
 | Reservation | `only` is unavailable because `PLURNK_EXECS_ONLY` owns that case-insensitive configuration key.               |
 
 Installed static declarations, trusted dynamic-hook declarations, and
@@ -429,7 +525,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 +537,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 +580,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.
 
@@ -504,7 +595,7 @@ violations for the consumer to contain.
 
 ### §executor-cancellation Cancellation and consumer timing
 
-Executors know only the supplied `AbortSignal`. Core owns EXEC timeout and poll
+Executors know only the supplied `AbortSignal`. Core owns execution timeout and poll
 syntax, timers, wakes, and loop lifetime in {§exec-timeout} and {§exec-poll}.
 Subprocess cancellation signals the process group: a caller-supplied kill code
 is delivered once; ordinary cancellation uses SIGHUP; loop-end housekeeping
@@ -516,7 +607,7 @@ The consumer:
 
 1. discovers declared tags, instantiates and probes each tag, and caches the verdict;
 2. registers a derived output scheme for every admitted, available tag;
-3. resolves EXEC to exactly one tag and obtains its effect fact;
+3. resolves the fence name to exactly one tag and obtains its effect fact;
 4. applies proposal policy, creates the stream entry, and supplies sinks plus cancellation;
 5. validates the terminal result and closes every declared channel and subscription coherently; and
 6. projects stream observations and later reads without calling back into the executor.

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"}