@sharpee/stdlib 0.9.111 → 1.0.0

package/channels/registry.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * @sharpee/stdlib/channels — channel registry instance.
+ *
+ * Owner context: stdlib language layer. Hosts the canonical
+ * `IChannelRegistry` instance for Sharpee's channel-I/O system.
+ * Engine bootstrap imports this instance, lets stories register their
+ * channels onto it (`Story.registerChannels?.(registry)`), then hands
+ * it to a fresh `ChannelService` (per ADR-163 §13, §14).
+ *
+ * The instance is populated at module init with the ten standard
+ * channels and the eleven static media channels. The `Story.registerChannels`
+ * hook may add story-specific channels or override standards by
+ * re-registering with the same id (last-write-wins per ADR-163 §6).
+ *
+ * Lifecycle: a fresh `ChannelService` is created per session
+ * (engine restart, RESTART command). The registry itself is reused —
+ * stdlib's standard channels stay registered across sessions, and the
+ * `ChannelService`'s per-session `prevValues` map provides the
+ * isolation. The Story.registerChannels hook is invoked once per
+ * engine bootstrap; if a story overrides a standard channel, that
+ * override persists for the lifetime of the engine instance.
+ *
+ * Tests can construct their own `IChannelRegistry` instance for
+ * isolation (unit tests should not depend on this singleton's
+ * pre-populated state for behavior-specific assertions).
+ *
+ * @see ADR-163 — Channel-Service Platform — §6, §7, §13, §14
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelRegistry = exports.StdlibChannelRegistry = void 0;
+const standard_1 = require("./standard");
+const media_1 = require("./media");
+const sound_events_1 = require("./sound-events");
+/**
+ * In-memory `IChannelRegistry` implementation. Last-write-wins on
+ * `add(channel)` by `channel.id` — which is how stories override
+ * platform standards (ADR-163 §6).
+ */
+class StdlibChannelRegistry {
+    channels = new Map();
+    add(channel) {
+        this.channels.set(channel.id, channel);
+    }
+    get(id) {
+        return this.channels.get(id);
+    }
+    all() {
+        return [...this.channels.values()];
+    }
+    /**
+     * Test-only helper: snapshot the current channel ids. Stable
+     * iteration order matches insertion order (Map semantics).
+     */
+    ids() {
+        return [...this.channels.keys()];
+    }
+}
+exports.StdlibChannelRegistry = StdlibChannelRegistry;
+/**
+ * The canonical channel registry instance for Sharpee. Pre-populated
+ * with ten standard channels (`main`, `prompt`, `score`, `turn`,
+ * `location`, `info`, `ifid`, `death`, `endgame`, `score_notify`)
+ * plus eleven static media channels (`image:preload`,
+ * `image:background`, `image:main`, `image:overlay`, `sound`,
+ * `music`, `animation`, `animate`, `transition`, `layout`, `clear`).
+ *
+ * Engine bootstrap consumes this directly; stories extend through
+ * the `Story.registerChannels?(registry)` hook.
+ */
+exports.channelRegistry = (() => {
+    const registry = new StdlibChannelRegistry();
+    for (const channel of standard_1.STANDARD_CHANNELS) {
+        registry.add(channel);
+    }
+    for (const channel of media_1.MEDIA_CHANNELS) {
+        registry.add(channel);
+    }
+    for (const channel of sound_events_1.SOUND_CHANNELS) {
+        registry.add(channel);
+    }
+    return registry;
+})();
+//# sourceMappingURL=registry.js.map

package/channels/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../../../../../repos/sharpee/packages/stdlib/src/channels/registry.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;;;AAGH,yCAA+C;AAC/C,mCAAyC;AACzC,iDAAgD;AAEhD;;;;GAIG;AACH,MAAa,qBAAqB;IACf,QAAQ,GAAG,IAAI,GAAG,EAAqB,CAAC;IAEzD,GAAG,CAAC,OAAkB;QACpB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IAED,GAAG,CAAC,EAAU;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED,GAAG;QACD,OAAO,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACrC,CAAC;IAED;;;OAGG;IACH,GAAG;QACD,OAAO,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACnC,CAAC;CACF;AAtBD,sDAsBC;AAED;;;;;;;;;;GAUG;AACU,QAAA,eAAe,GAAqB,CAAC,GAAG,EAAE;IACrD,MAAM,QAAQ,GAAG,IAAI,qBAAqB,EAAE,CAAC;IAC7C,KAAK,MAAM,OAAO,IAAI,4BAAiB,EAAE,CAAC;QACxC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACxB,CAAC;IACD,KAAK,MAAM,OAAO,IAAI,sBAAc,EAAE,CAAC;QACrC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACxB,CAAC;IACD,KAAK,MAAM,OAAO,IAAI,6BAAc,EAAE,CAAC;QACrC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACxB,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC,EAAE,CAAC"}

package/channels/sound-events.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @sharpee/stdlib/channels — spatial sound channel (ADR-172 Phase 5).
+ *
+ * Owner context: stdlib language layer. Defines:
+ *
+ *  - `SOUND_EVENT_TYPES` — semantic-event type constants the engine's
+ *    sound dispatcher (Phase 6) emits when the propagation function
+ *    delivers an `AudibilityEvent` to a listener.
+ *  - `audibilityChannel` — the `IOChannel` that filters those events
+ *    out of the per-turn event stream and projects their payloads.
+ *
+ * **Channel id is `'audibility'`, not `'sound'`.** The `'sound'` id is
+ * reserved by ADR-163 for the media-cue channel (`media.sound.play`
+ * payloads). ADR-172's per-listener audibility events are a distinct
+ * concept (perception of a propagated sound, with prose+audio render
+ * branches) so they ride a distinct channel id.
+ *
+ * The channel is **not** capability-gated. Per ADR-172 §Channel routing,
+ * both text-only and audio-capable clients consume audibility events:
+ * text-only renders descriptive prose ("muffled voices to the north"),
+ * audio-capable additionally plays a cue at a tier-mapped playback
+ * volume. The wire shape is the `AudibilityEvent`; clients render what
+ * they can.
+ *
+ * @see ADR-172 — Spatial Sound Propagation §Channel routing
+ * @see ADR-163 — Channel-Service Platform §6, §7 (closure-per-channel)
+ */
+import type { IOChannel } from "../../if-domain/index";
+import type { IAudibilityEvent } from "../../if-domain/index";
+/**
+ * Semantic-event types emitted by the sound subsystem. Phase 6's
+ * dispatcher fires `AUDIBILITY_HEARD` once per listener per propagated
+ * sound; the event's `data` field carries the listener-specific
+ * `IAudibilityEvent` payload.
+ */
+export declare const SOUND_EVENT_TYPES: {
+    /**
+     * A listener perceived a propagated sound. Event `data` is an
+     * `IAudibilityEvent` (per-listener tier, source-room, optional
+     * crossing wall, content if content-bearing).
+     */
+    readonly AUDIBILITY_HEARD: "sound.audibility.heard";
+};
+export type SoundEventType = typeof SOUND_EVENT_TYPES[keyof typeof SOUND_EVENT_TYPES];
+/**
+ * `audibility` — append-mode channel carrying every `AudibilityEvent`
+ * delivered to listeners during the turn just executed.
+ *
+ * Mode is `append` because a single turn may produce multiple
+ * `AUDIBILITY_HEARD` events (multiple emissions × multiple listeners
+ * after dispatcher fan-out in Phase 6). Each turn's projected value is
+ * the array of newly-heard events; quiet turns emit nothing under the
+ * `sparse` policy.
+ *
+ * Renderers consume per their capability:
+ *  - text-only — language layer maps `(kind, audibilityTier)` to
+ *    descriptive prose (see `sound-messages` in lang-{locale}).
+ *  - audio-capable — optionally plays an audio cue per the existing
+ *    Web Audio infrastructure (ADR-169), playback volume mapped from
+ *    `audibilityTier`.
+ */
+export declare const audibilityChannel: IOChannel<IAudibilityEvent>;
+/**
+ * Sound-subsystem channels. Currently a single entry; the constant
+ * exists to match the `STANDARD_CHANNELS` / `MEDIA_CHANNELS`
+ * registration pattern and to give future sound-related channels a
+ * stable bucket.
+ */
+export declare const SOUND_CHANNELS: ReadonlyArray<IOChannel>;
+export declare const SOUND_CHANNEL_IDS: readonly ["audibility"];
+export type SoundChannelId = typeof SOUND_CHANNEL_IDS[number];
+//# sourceMappingURL=sound-events.d.ts.map

package/channels/sound-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sound-events.d.ts","sourceRoot":"","sources":["../../../../../../repos/sharpee/packages/stdlib/src/channels/sound-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;IAC5B;;;;OAIG;;CAEK,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,OAAO,iBAAiB,CAAC,MAAM,OAAO,iBAAiB,CAAC,CAAC;AAEtF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,CAAC,gBAAgB,CAezD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,aAAa,CAAC,SAAS,CAAuB,CAAC;AAE5E,eAAO,MAAM,iBAAiB,yBAA0B,CAAC;AACzD,MAAM,MAAM,cAAc,GAAG,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC"}

package/channels/sound-events.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * @sharpee/stdlib/channels — spatial sound channel (ADR-172 Phase 5).
+ *
+ * Owner context: stdlib language layer. Defines:
+ *
+ *  - `SOUND_EVENT_TYPES` — semantic-event type constants the engine's
+ *    sound dispatcher (Phase 6) emits when the propagation function
+ *    delivers an `AudibilityEvent` to a listener.
+ *  - `audibilityChannel` — the `IOChannel` that filters those events
+ *    out of the per-turn event stream and projects their payloads.
+ *
+ * **Channel id is `'audibility'`, not `'sound'`.** The `'sound'` id is
+ * reserved by ADR-163 for the media-cue channel (`media.sound.play`
+ * payloads). ADR-172's per-listener audibility events are a distinct
+ * concept (perception of a propagated sound, with prose+audio render
+ * branches) so they ride a distinct channel id.
+ *
+ * The channel is **not** capability-gated. Per ADR-172 §Channel routing,
+ * both text-only and audio-capable clients consume audibility events:
+ * text-only renders descriptive prose ("muffled voices to the north"),
+ * audio-capable additionally plays a cue at a tier-mapped playback
+ * volume. The wire shape is the `AudibilityEvent`; clients render what
+ * they can.
+ *
+ * @see ADR-172 — Spatial Sound Propagation §Channel routing
+ * @see ADR-163 — Channel-Service Platform §6, §7 (closure-per-channel)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOUND_CHANNEL_IDS = exports.SOUND_CHANNELS = exports.audibilityChannel = exports.SOUND_EVENT_TYPES = void 0;
+/**
+ * Semantic-event types emitted by the sound subsystem. Phase 6's
+ * dispatcher fires `AUDIBILITY_HEARD` once per listener per propagated
+ * sound; the event's `data` field carries the listener-specific
+ * `IAudibilityEvent` payload.
+ */
+exports.SOUND_EVENT_TYPES = {
+    /**
+     * A listener perceived a propagated sound. Event `data` is an
+     * `IAudibilityEvent` (per-listener tier, source-room, optional
+     * crossing wall, content if content-bearing).
+     */
+    AUDIBILITY_HEARD: 'sound.audibility.heard',
+};
+/**
+ * `audibility` — append-mode channel carrying every `AudibilityEvent`
+ * delivered to listeners during the turn just executed.
+ *
+ * Mode is `append` because a single turn may produce multiple
+ * `AUDIBILITY_HEARD` events (multiple emissions × multiple listeners
+ * after dispatcher fan-out in Phase 6). Each turn's projected value is
+ * the array of newly-heard events; quiet turns emit nothing under the
+ * `sparse` policy.
+ *
+ * Renderers consume per their capability:
+ *  - text-only — language layer maps `(kind, audibilityTier)` to
+ *    descriptive prose (see `sound-messages` in lang-{locale}).
+ *  - audio-capable — optionally plays an audio cue per the existing
+ *    Web Audio infrastructure (ADR-169), playback volume mapped from
+ *    `audibilityTier`.
+ */
+exports.audibilityChannel = {
+    id: 'audibility',
+    contentType: 'json',
+    mode: 'append',
+    emit: 'sparse',
+    produce: (ctx) => {
+        const heard = [];
+        for (const event of ctx.events) {
+            if (event.type !== exports.SOUND_EVENT_TYPES.AUDIBILITY_HEARD)
+                continue;
+            const data = event.data;
+            if (!data)
+                continue;
+            heard.push(data);
+        }
+        return heard.length > 0 ? heard : undefined;
+    },
+};
+/**
+ * Sound-subsystem channels. Currently a single entry; the constant
+ * exists to match the `STANDARD_CHANNELS` / `MEDIA_CHANNELS`
+ * registration pattern and to give future sound-related channels a
+ * stable bucket.
+ */
+exports.SOUND_CHANNELS = [exports.audibilityChannel];
+exports.SOUND_CHANNEL_IDS = ['audibility'];
+//# sourceMappingURL=sound-events.js.map

package/channels/sound-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sound-events.js","sourceRoot":"","sources":["../../../../../../../repos/sharpee/packages/stdlib/src/channels/sound-events.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;;AAKH;;;;;GAKG;AACU,QAAA,iBAAiB,GAAG;IAC/B;;;;OAIG;IACH,gBAAgB,EAAE,wBAAwB;CAClC,CAAC;AAIX;;;;;;;;;;;;;;;;GAgBG;AACU,QAAA,iBAAiB,GAAgC;IAC5D,EAAE,EAAE,YAAY;IAChB,WAAW,EAAE,MAAM;IACnB,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,QAAQ;IACd,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;QACf,MAAM,KAAK,GAAuB,EAAE,CAAC;QACrC,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC;YAC/B,IAAI,KAAK,CAAC,IAAI,KAAK,yBAAiB,CAAC,gBAAgB;gBAAE,SAAS;YAChE,MAAM,IAAI,GAAG,KAAK,CAAC,IAAoC,CAAC;YACxD,IAAI,CAAC,IAAI;gBAAE,SAAS;YACpB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnB,CAAC;QACD,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9C,CAAC;CACF,CAAC;AAEF;;;;;GAKG;AACU,QAAA,cAAc,GAA6B,CAAC,yBAAiB,CAAC,CAAC;AAE/D,QAAA,iBAAiB,GAAG,CAAC,YAAY,CAAU,CAAC"}

package/channels/standard.d.ts

@@ -0,0 +1,209 @@
+/**
+ * @sharpee/stdlib/channels — standard `IOChannel` definitions.
+ *
+ * Owner context: stdlib language layer. The ten platform-vocabulary
+ * channels from ADR-163 §4 — co-located with stdlib because their
+ * closures read stdlib data sources (capabilities, blocks the
+ * text-service produces, world projections).
+ *
+ * Per ADR-163 §6, channels are self-contained: each `IOChannel`
+ * carries its identity, configuration, and a closure that computes
+ * the channel's value for the current turn from the
+ * `ChannelProduceContext`. There is no separate rule schema or
+ * routing layer; closures are the routing.
+ *
+ * **Standard channels are NOT capability-gated** (per §6 — they exist
+ * on every surface). Media channels gate; standards do not.
+ *
+ * @see ADR-163 — Channel-Service Platform — §4, §5, §6
+ */
+import type { IOChannel, MainEntry } from "../../if-domain/index";
+/**
+ * Event types the standard channels listen for. Stories or extensions
+ * that want to populate `death`, `endgame`, or `score_notify` emit
+ * events of these types; stdlib does not emit them itself.
+ *
+ * The values align with what the engine and stdlib extensions actually
+ * emit today:
+ *
+ * - `game.won` / `game.lost` — engine emits these from `engine.stop()`
+ *   via `createGameWonEvent` / `createGameLostEvent` (core/events).
+ * - `combat.player_died` — emitted by the `@sharpee/ext-basic-combat`
+ *   extension. Stories not using basic-combat that want a death
+ *   channel emission must either fire `combat.player_died` themselves
+ *   or override `deathChannel` with their own closure.
+ * - `game.score_changed` — no production emitter today. The channel
+ *   listens for it, but it stays silent until a story or extension
+ *   adopts the convention. Listed for forward-compatibility.
+ *
+ * Each event carries its message in `event.data.message` (string).
+ */
+export declare const STANDARD_CHANNEL_EVENTS: {
+    readonly PLAYER_DIED: "combat.player_died";
+    readonly GAME_WON: "game.won";
+    readonly GAME_LOST: "game.lost";
+    readonly SCORE_CHANGED: "game.score_changed";
+};
+/**
+ * `main` — append-mode prose transcript. Carries `MainEntry` objects
+ * (`{ content, tight? }`) so renderers can preserve decorations *and*
+ * the per-entry visual-continuation hint introduced by the pre-line
+ * removal (session 2026-05-12). Closure projects every block whose key
+ * is in `MAIN_KEYS` into the channel's append stream.
+ */
+export declare const mainChannel: IOChannel<MainEntry>;
+/**
+ * `prompt` — replace-mode input prompt. Defaults to `'> '` when no
+ * prompt block is emitted, so the renderer always has a sensible
+ * placeholder. Closure flattens the prompt block's content to plain
+ * string (decorations stripped).
+ */
+export declare const promptChannel: IOChannel<string>;
+/**
+ * `location` — replace-mode status-line location name. Closure reads
+ * the player's containing room from the world and returns its display
+ * name. Returns `undefined` (the channel re-emits its prevValue) if
+ * the world has no player or the room cannot be resolved.
+ */
+export declare const locationChannel: IOChannel<string>;
+/**
+ * `score` — replace-mode `{current, max}` payload.
+ *
+ * Reads the canonical ADR-129 score ledger first (`world.getScore()`
+ * and `world.getMaxScore()`); falls back to the legacy `scoring`
+ * capability's `scoreValue`/`maxScore` for older worlds that haven't
+ * adopted the ledger. The fallback path also serves stories that
+ * track score outside the ledger (rare; ADR-129 is the recommended
+ * pattern).
+ *
+ * `max: null` (not `0`) signals an unbounded score per ADR-163 §4
+ * commentary; `maxScore: 0` is treated as null since a 0-cap scoring
+ * system has no usable progress fraction.
+ *
+ * Returns `undefined` only when the world is missing entirely (test
+ * harness with a stub) — `always`-mode then re-emits prev.
+ */
+export declare const scoreChannel: IOChannel<{
+    current: number;
+    max: number | null;
+}>;
+/**
+ * `turn` — replace-mode turn count. Closure returns `ctx.turn`
+ * directly. Always emits because the turn counter changes every turn.
+ */
+export declare const turnChannel: IOChannel<number>;
+/**
+ * Wire shape for the `info` channel — full story metadata.
+ *
+ * Optional fields are omitted from the emitted payload when empty so
+ * renderers can branch cleanly on presence. The engine populates the
+ * underlying `storyInfo` capability from `StoryConfig` + `StoryInfoTrait`
+ * during `setStory()`.
+ */
+export interface StoryInfoPayload {
+    title?: string;
+    author?: string;
+    version?: string;
+    description?: string;
+    buildDate?: string;
+    engineVersion?: string;
+    clientVersion?: string;
+}
+/**
+ * `info` — replace-mode story metadata. Closure projects every
+ * non-empty field from the `storyInfo` capability into a single
+ * payload object. The same payload is consumed by the browser
+ * `info` renderer (sets `document.title` + `data-*` attributes) and
+ * by any author-supplied dashboards.
+ */
+export declare const infoChannel: IOChannel<StoryInfoPayload>;
+/**
+ * `ifid` — replace-mode IFID string. Closure reads `storyInfo.ifid`
+ * and skips emission when the value is empty (sparse-suppress style),
+ * so stories without an IFID don't emit empty strings into the
+ * channel state.
+ */
+export declare const ifidChannel: IOChannel<string>;
+/**
+ * `death` — event-mode death notification. Closure looks for an
+ * `if.event.player_died` event in this turn's events and projects its
+ * `data.message` field. Stories that want different death handling
+ * register a replacement `IOChannel` with id `'death'` (last-write-wins
+ * per ADR-163 §6).
+ */
+export declare const deathChannel: IOChannel<string>;
+/**
+ * `endgame` — event-mode endgame notification (game won OR game lost
+ * — the closure folds both into one channel since renderers typically
+ * present them similarly). Closure scans for either event type and
+ * returns the message of the first match.
+ */
+export declare const endgameChannel: IOChannel<string>;
+/**
+ * `score_notify` — event-mode transient score-change announcement.
+ * Closure scans for `if.event.score_changed` and emits its message.
+ */
+export declare const scoreNotifyChannel: IOChannel<string>;
+/**
+ * Discriminator values for `LifecyclePayload`.
+ *
+ * - `save_failed` — save handler reported failure or threw.
+ * - `restore_failed` — restore handler returned no data, threw, or
+ *   was not registered.
+ * - `restore_completed` — restore succeeded; renderers should refresh
+ *   any cached UI derived from world state.
+ */
+export type LifecycleEventKind = 'save_failed' | 'restore_failed' | 'restore_completed';
+/**
+ * Wire shape for the `lifecycle` channel. `message` is populated for
+ * the failure kinds and copied verbatim from the platform event's
+ * `payload.error` field. Successful kinds (`restore_completed`) carry
+ * no message — they are pure signals.
+ */
+export interface LifecyclePayload {
+    kind: LifecycleEventKind;
+    message?: string;
+}
+/**
+ * `lifecycle` — event-mode save/restore signals. Projects the trio of
+ * platform completion events (`platform.save_failed`,
+ * `platform.restore_failed`, `platform.restore_completed`) into a
+ * single sparse channel.
+ *
+ * Renderers branch on `payload.kind`: failures display `payload.message`
+ * (or a fallback string), `restore_completed` triggers UI refresh
+ * without text. Sparse-emit semantics mean turns without a lifecycle
+ * event suppress emission entirely — the channel value retains its
+ * prior state on quiet turns.
+ *
+ * If multiple lifecycle events appear in one turn, the **last** one
+ * wins. In practice this is unobservable since each save/restore
+ * operation produces exactly one completion event, but the rule is
+ * documented so test authors don't expect first-wins semantics.
+ */
+export declare const lifecycleChannel: IOChannel<LifecyclePayload>;
+/**
+ * The ten platform-standard channels in iteration order. Order is
+ * preserved for stable diffing in tests and manifests; the
+ * `ChannelService` itself does not depend on ordering.
+ */
+export declare const STANDARD_CHANNELS: ReadonlyArray<IOChannel>;
+/**
+ * Channel id literals for the platform-standard set. Used by tests
+ * and consumers that need string-literal types.
+ */
+export declare const STANDARD_CHANNEL_IDS: {
+    readonly MAIN: "main";
+    readonly PROMPT: "prompt";
+    readonly LOCATION: "location";
+    readonly SCORE: "score";
+    readonly TURN: "turn";
+    readonly INFO: "info";
+    readonly IFID: "ifid";
+    readonly DEATH: "death";
+    readonly ENDGAME: "endgame";
+    readonly SCORE_NOTIFY: "score_notify";
+    readonly LIFECYCLE: "lifecycle";
+};
+export type StandardChannelId = (typeof STANDARD_CHANNEL_IDS)[keyof typeof STANDARD_CHANNEL_IDS];
+//# sourceMappingURL=standard.d.ts.map

package/channels/standard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard.d.ts","sourceRoot":"","sources":["../../../../../../repos/sharpee/packages/stdlib/src/channels/standard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAuB/D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,uBAAuB;;;;;CAK1B,CAAC;AAwCX;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,CAAC,SAAS,CAkB5C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,CAAC,MAAM,CAa3C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,CAAC,MAAM,CAM7C,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CA0B3E,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,CAAC,MAAM,CAMzC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,CAAC,gBAAgB,CAkBnD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,CAAC,MAAM,CAYzC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,CAAC,MAAM,CAa1C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,CAAC,MAAM,CAgB5C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,CAAC,MAAM,CAahD,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAC1B,aAAa,GACb,gBAAgB,GAChB,mBAAmB,CAAC;AAExB;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA8BD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,CAAC,gBAAgB,CAexD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,SAAS,CAYtD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;CAYvB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAC3B,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC"}