@pie-players/pie-assessment-toolkit 0.3.74 → 1.0.0-beta.0

package/dist/runtime/SectionRuntimeEngine.js

@@ -1,112 +1,52 @@
 /**
- * Section runtime engine — public facade (M7 — Variant C, layered).
+ * Section runtime engine — the section player's stage chain.
  *
- * The facade is the narrow, stable entry point hosts use to mount,
- * drive, and dispose a section runtime. It composes three layers
- * introduced in earlier M7 PRs:
+ * The section player's layout kernel owns one per layout element and drives it
+ * with `dispatchInput`: the cohort it shows (`initialize`, `cohort-change`,
+ * `update-runtime`), the controller resolving (`section-controller-resolved`),
+ * and the readiness signals it derives (`update-readiness-signals`). The pure
+ * FSM core turns those into `pie-stage-change` and `pie-loading-complete`,
+ * which the adapter dispatches on the layout element, bubbling and composed;
+ * `subscribe` receives the same outputs in batches.
  *
- *   - the **registry** (`RuntimeRegistry`) — registered item/passage
- *     shells in document order, used for canonical-id lookup;
- *   - the **adapter** (`SectionEngineAdapter`) — single I/O seam over
- *     the pure FSM core, fanning outputs to the DOM, framework-error
- *     bus, instrumentation hook, and host subscribers;
- *   - the **resolver** (`resolveSectionEngineRuntimeState`) — the
- *     toolkit-side resolution helper that produces the effective
- *     runtime + tools snapshot a host feeds to the FSM core.
+ * The engine is the only stage emitter. It holds no controller and no
+ * registry: the toolkit's `SectionControllerBinding` owns those. The kernel
+ * learns that the controller resolved from the toolkit's `section-ready`, whose
+ * detail carries the controller and its cohort.
  *
- * The facade exposes an engine-side surface for stage/lifecycle inputs and a
- * controller-facing surface for item registration, session updates, and host
- * controller commands:
- *
- *   1. The **engine-side** surface (`attachHost`, `dispatchInput`,
- *      `subscribe`, `getState`, `getEffectiveRuntime`,
- *      `setInstrumentationHook`). This is what the kernel and the
- *      `pie-assessment-toolkit` CE will switch onto in M7 PR 5 and
- *      PR 6. Construction is lazy: `attachHost(...)` builds the
- *      adapter on first call, with the supplied host element,
- *      framework-error bus, and (optional) coordinator. After
- *      construction, host re-attachments (e.g. cohort change with a
- *      new layout shell) update the adapter's host element via
- *      `setHost(...)`.
- *
- *   2. The **controller-side** surface (`initialize`,
- *      `register`, `unregister`, `handleContent*`, `updateItemSession`,
- *      `navigateToItem`, `persist`, `hydrate`, `dispose`). The
- *      `PieAssessmentToolkit.svelte` CE drives section-controller and
- *      item-shell events through this surface.
- *
- * The two surfaces share `RuntimeRegistry` and the resolved
- * `SectionControllerHandle`.
+ * `attachHost(...)` builds the adapter on first call; a later call moves it to
+ * a new host element.
  */
-import { SectionEngineAdapter, } from "./adapter/SectionEngineAdapter.js";
-import { resolveSectionEngineRuntimeState, } from "./core/engine-resolver.js";
+import { SectionEngineAdapter } from "./adapter/SectionEngineAdapter.js";
 import { createInitialEngineState, } from "./core/engine-state.js";
-import { createPieLogger, isGlobalDebugEnabled, } from "@pie-players/pie-players-shared";
-import { RuntimeRegistry } from "./RuntimeRegistry.js";
 import { createRuntimeId } from "./runtime-id.js";
-const logger = createPieLogger("section-runtime-engine", () => isGlobalDebugEnabled());
 export class SectionRuntimeEngine {
-    registry = new RuntimeRegistry();
     runtimeId = createRuntimeId("section-engine");
-    // Engine-side state (PR 3+).
     adapter = null;
-    // Controller-side state.
-    controller = null;
-    coordinator = null;
-    sectionId = "";
-    attemptId;
-    unsubscribeController = null;
-    activeInitToken = 0;
-    /**
-     * Tracks which `(canonicalItemId, contentKind)` pairs have already
-     * fired `handleContentLoaded` on this engine. Mirrored alongside
-     * `RuntimeRegistry`'s registered set so a cohort handoff can
-     * replay the persistent shells' loaded state into the new
-     * controller — see `replayRegisteredShellsIntoController` and the
-     * PIE-512 Phase B regression test.
-     *
-     * Cleared in lockstep with `handleContentUnregistered` and on
-     * `dispose`. Not exposed publicly: the registry alone is the
-     * external surface; the loaded set exists only to seed cohort B's
-     * controller with the live state cohort A's shells produced.
-     */
-    loadedRenderableKeys = new Set();
-    // ============================================================
-    // Engine-side surface (PR 3+; driven by the kernel from PR 5,
-    // by the toolkit CE from PR 6, and by the facade smoke test today).
-    // ============================================================
     /**
-     * Attach the host element + framework-error bus + sourceCe so the
-     * adapter can dispatch DOM events and bus errors. Required before
-     * `dispatchInput` / `subscribe` produce observable effects.
+     * Attach the host element and `sourceCe` the adapter dispatches DOM events
+     * with. Required before `dispatchInput` / `subscribe` produce observable
+     * effects.
      *
-     * Constructs the adapter on the first call. Subsequent calls keep
-     * the adapter and update its host element / instrumentation hook
-     * (used by layout-shell rollovers and instrumentation reconfig).
+     * Constructs the adapter on the first call. Subsequent calls keep the
+     * adapter and update its host element.
      */
     attachHost(args) {
         if (this.adapter) {
             this.adapter.setHost(args.host);
-            if (args.instrumentationHook !== undefined) {
-                this.adapter.setInstrumentationHook(args.instrumentationHook);
-            }
             return;
         }
         this.adapter = new SectionEngineAdapter({
             host: args.host,
             runtimeId: this.runtimeId,
             sourceCe: args.sourceCe,
-            frameworkErrorBus: args.frameworkErrorBus,
-            coordinator: args.coordinator,
-            instrumentationHook: args.instrumentationHook,
             now: args.now,
         });
     }
     /**
      * Forward a host-constructed input to the FSM core via the adapter.
      * Returns the outputs the transition produced (subscribers and the
-     * DOM/framework-error/instrumentation bridges have already
-     * received them).
+     * DOM bridge have already received them).
      *
      * No-op (returns `[]`) before `attachHost(...)` so callers that
      * dispatch optimistically during teardown do not throw.
@@ -132,304 +72,22 @@ export class SectionRuntimeEngine {
         return this.adapter?.getState() ?? createInitialEngineState();
     }
     /**
-     * Resolve the effective runtime + tools snapshot for the given
-     * two-tier inputs. This is a pure function over the resolver — it
-     * does not depend on adapter state — so callers can use it both
-     * pre- and post-`attachHost`. The kernel uses it to seed
-     * `dispatchInput({ kind: "initialize", effectiveRuntime, ... })`.
-     */
-    getEffectiveRuntime(args, deps) {
-        return resolveSectionEngineRuntimeState(args, deps).effectiveRuntime;
-    }
-    /**
-     * Update the adapter's instrumentation hook. No-op pre-attach.
-     * Hosts that always want a hook should pass it via `attachHost`.
-     */
-    setInstrumentationHook(hook) {
-        this.adapter?.setInstrumentationHook(hook);
-    }
-    /**
-     * Stable per-engine runtime id used to scope DOM-event details and
-     * registry telemetry. Exposed so tests and instrumentation can pin
-     * the value the bridges emit.
+     * Stable per-engine runtime id, the `runtimeId` of every event detail the
+     * engine dispatches.
      */
     getRuntimeId() {
         return this.runtimeId;
     }
-    // ============================================================
-    // Controller-side surface.
-    // ============================================================
-    async initialize(args) {
-        this.activeInitToken += 1;
-        const token = this.activeInitToken;
-        this.coordinator = args.coordinator;
-        this.sectionId = args.sectionId;
-        this.attemptId = args.attemptId;
-        const resolved = (await args.coordinator.getOrCreateSectionController({
-            sectionId: args.sectionId,
-            attemptId: args.attemptId,
-            input: {
-                section: args.section,
-                sectionId: args.sectionId,
-                assessmentId: args.assessmentId,
-                view: args.view,
-            },
-            updateExisting: true,
-            createDefaultController: args.createDefaultController,
-        }));
-        if (token !== this.activeInitToken)
-            return;
-        this.unsubscribeController?.();
-        this.controller = resolved;
-        // PIE-512 Phase C: always re-feed the registry's currently
-        // registered shells (and their loaded state) into the resolved
-        // controller. We do NOT gate on `resolved !== previousController`
-        // any more.
-        //
-        // Why the gate had to go:
-        //   - Cohort flip resolving to a fresh controller — replay seeds
-        //     the new controller, which is the original Phase B fix.
-        //   - Same-cohort `updateInput` resolving to the existing
-        //     controller — the coordinator's
-        //     `resolveExistingSectionController` calls
-        //     `existingController.updateInput(input)` (engine always
-        //     passes `updateExisting: true`), and pre-Phase-C
-        //     `SectionController.initialize` wiped lifecycle tracking
-        //     unconditionally. A subscriber attaching between the wipe
-        //     and the next live event saw an empty
-        //     `loadedRenderables` snapshot.
-        //
-        // Phase C makes this re-feed safe by combining (a) the
-        // section-identity gate around `resetLifecycleTracking()` in
-        // `SectionController.initialize` (so same-cohort `updateInput`
-        // preserves tracking) with (b) idempotent
-        // `handleContentRegistered` / `handleContentLoaded` on the
-        // controller (so re-feeding the same registry entries is a
-        // no-op if the controller already knows about them, but
-        // re-seeds the controller in the post-`updateInput`-wipe case
-        // that pre-Phase-C used to encounter).
-        this.replayRegisteredShellsIntoController(resolved);
-        args.onCompositionChanged?.(resolved.getCompositionModel?.());
-        this.unsubscribeController =
-            resolved.subscribe?.((event) => {
-                // Isolated deliberately: the controller's emit loop catches per
-                // listener, so a diagnostic handler that throws would take the
-                // composition republish down with it and every cue and Try would stop
-                // reaching the cards — a failure with no symptom except a warning.
-                try {
-                    args.onControllerEvent?.(event);
-                }
-                catch (error) {
-                    logger.warn("onControllerEvent handler threw", error);
-                }
-                args.onCompositionChanged?.(resolved.getCompositionModel?.());
-            }) || null;
-    }
-    /**
-     * Re-feed the engine's `RuntimeRegistry` and loaded-set into the
-     * resolved controller. Call site: `initialize(...)` — runs on
-     * EVERY initialize, both cohort-flip-resolves-fresh-controller
-     * and same-cohort-resolves-existing-controller cases. Phase C
-     * dropped the `resolved !== previousController` gate; see the
-     * comment at the call site for why.
-     *
-     * Two-pass order — register every shell in document order, then
-     * issue `handleContentLoaded` for each shell whose load already
-     * fired on this engine. The two-pass shape prevents
-     * `evaluateSectionLoadingState` from flapping
-     * `section-loading-complete` `false→true→false→…` while replay is
-     * mid-walk: any subscriber wired before the engine's own
-     * `controller.subscribe` (no such caller today, but cheap defense
-     * for future wiring) sees one clean `false→true` transition.
-     *
-     * Idempotent on the controller side — Phase C makes
-     * `SectionController.handleContentRegistered` and
-     * `handleContentLoaded` early-return on duplicates so re-feeding
-     * the same shells into a controller that already tracks them is
-     * a true no-op (no spurious re-emits, no re-evaluation of
-     * `section-loading-complete`). At the call site no listener is
-     * attached during the replay window, so `emitChange` side effects
-     * fire into a void on this pass anyway, but the controller-side
-     * idempotence is what makes the replay safe to run on every
-     * initialize regardless of whether the controller is fresh.
-     */
-    replayRegisteredShellsIntoController(controller) {
-        if (!controller.handleContentRegistered)
-            return;
-        const shells = this.registry.getOrderedShells();
-        if (shells.length === 0)
-            return;
-        for (const shell of shells) {
-            const canonicalItemId = shell.canonicalItemId || shell.itemId;
-            controller.handleContentRegistered({
-                itemId: shell.itemId,
-                canonicalItemId,
-                contentKind: shell.contentKind || shell.kind,
-            });
-        }
-        const now = Date.now();
-        for (const shell of shells) {
-            const canonicalItemId = shell.canonicalItemId || shell.itemId;
-            const key = this.getLoadedKey(canonicalItemId, shell.contentKind);
-            if (this.loadedRenderableKeys.has(key)) {
-                controller.handleContentLoaded?.({
-                    itemId: shell.itemId,
-                    canonicalItemId,
-                    contentKind: shell.contentKind || shell.kind,
-                    timestamp: now,
-                });
-            }
-        }
-    }
-    /**
-     * Stable key for the engine's `loadedRenderableKeys` set. Mirrors
-     * the `(canonicalItemId, contentKind)` shape `SectionController`
-     * uses internally (see `getRenderableKey`); we only need
-     * consistent add/check semantics on this side, not byte-identical
-     * normalization with the controller.
-     */
-    getLoadedKey(canonicalItemId, contentKind) {
-        return `${contentKind ?? ""}:${canonicalItemId}`;
-    }
-    register(detail) {
-        return this.registry.register(detail);
-    }
-    unregister(element) {
-        return this.registry.unregister(element);
-    }
-    getCompositionModel() {
-        return this.controller?.getCompositionModel?.() ?? null;
-    }
-    getCanonicalItemId(itemId) {
-        const map = this.registry.getCanonicalIdMap();
-        return (map[itemId] || this.controller?.getCanonicalItemId?.(itemId) || itemId);
-    }
-    handleContentRegistered(detail) {
-        this.controller?.handleContentRegistered?.({
-            itemId: detail.itemId,
-            canonicalItemId: detail.canonicalItemId || detail.itemId,
-            contentKind: detail.contentKind || detail.kind,
-        });
-    }
-    handleContentUnregistered(detail) {
-        const canonicalItemId = detail.canonicalItemId || detail.itemId;
-        // Key the load-set delete with the same `contentKind`-only
-        // shape that `handleContentLoaded` and
-        // `replayRegisteredShellsIntoController` use, so add/check/
-        // delete keys round-trip identically. The `|| detail.kind`
-        // fallback is preserved for the controller-forwarded payload
-        // because the controller normalizes via `toSectionContentKind`
-        // and the `kind` field remains meaningful there.
-        this.loadedRenderableKeys.delete(this.getLoadedKey(canonicalItemId, detail.contentKind));
-        this.controller?.handleContentUnregistered?.({
-            itemId: detail.itemId,
-            canonicalItemId,
-            contentKind: detail.contentKind || detail.kind,
-        });
-    }
-    handleContentLoaded(args) {
-        const canonicalItemId = args.canonicalItemId || args.itemId;
-        this.loadedRenderableKeys.add(this.getLoadedKey(canonicalItemId, args.contentKind));
-        this.controller?.handleContentLoaded?.(args);
-    }
-    handleItemPlayerError(args) {
-        this.controller?.handleItemPlayerError?.(args);
-    }
-    reportSectionError(args) {
-        this.controller?.reportSectionError?.(args);
-    }
-    updateItemSession(itemId, session) {
-        const canonicalId = this.getCanonicalItemId(itemId);
-        return this.controller?.updateItemSession?.(canonicalId, session) ?? null;
-    }
-    navigateToItem(index) {
-        return this.controller?.navigateToItem?.(index) ?? null;
-    }
     /**
-     * Route a learner's formative action to the controller.
-     *
-     * Canonicalized here for the same reason `updateItemSession` is: the runtime
-     * id a card dispatches with is not necessarily the identifier the controller
-     * keys state by.
+     * Emit `disposed` for the active cohort and detach. Idempotent; inputs
+     * after it are ignored.
      */
-    handleFormativeAction(action) {
-        if (!action?.itemId)
-            return;
-        const canonicalId = this.getCanonicalItemId(action.itemId);
-        if (action.action === "retry") {
-            this.controller?.retryFormativeItem?.({ itemId: canonicalId });
+    dispose() {
+        const adapter = this.adapter;
+        if (!adapter)
             return;
-        }
-        this.controller?.recordFormativeTry?.({
-            itemId: canonicalId,
-            outcomes: action.outcomes,
-        });
-    }
-    /**
-     * Bind or release the section's Media Time Source.
-     *
-     * A pass-through, like `handleFormativeAction`: the engine routes, the
-     * controller decides. `renderableId` travels with the attach because whether the
-     * registering renderable is the one `stimulusRef` names is the controller's call
-     * — it validated `stimulusRef` in the first place.
-     */
-    handleMediaTimeSource(action) {
-        if (action?.action === "detach") {
-            this.controller?.detachMediaTimeSource?.({
-                origin: action.origin ?? "host",
-            });
-            return;
-        }
-        if (!action?.source)
-            return;
-        this.controller?.attachMediaTimeSource?.(action.source, {
-            origin: action.origin ?? "host",
-            renderableId: action.renderableId,
-        });
-    }
-    /**
-     * Silence media audio because something else is about to speak.
-     *
-     * A pass-through like `handleMediaTimeSource`, and for the same reason: which
-     * source is authoritative and whether it reports `canPause` are the controller's
-     * to know. Returns whether media audio is now silent, or `true` where there is
-     * no timed-media controller to ask — nothing is playing.
-     */
-    requestMediaPauseForCompetingAudio() {
-        return this.controller?.pauseMediaForCompetingAudio?.() ?? true;
-    }
-    async persist() {
-        await this.controller?.persist?.();
-    }
-    async hydrate() {
-        await this.controller?.hydrate?.();
-    }
-    getRegistry() {
-        return this.registry;
-    }
-    async dispose() {
-        this.activeInitToken += 1;
-        this.unsubscribeController?.();
-        this.unsubscribeController = null;
-        if (this.coordinator && this.sectionId) {
-            await this.coordinator.disposeSectionController({
-                sectionId: this.sectionId,
-                attemptId: this.attemptId,
-            });
-        }
-        this.registry.clear();
-        this.loadedRenderableKeys.clear();
-        this.controller = null;
-        this.coordinator = null;
-        // Tear down the engine-side adapter (if attached) last so any
-        // `dispose` FSM input flows through the bridges before they
-        // detach. Adapter disposal is idempotent and safe even when
-        // nothing is attached.
-        if (this.adapter) {
-            const adapter = this.adapter;
-            this.adapter = null;
-            await adapter.dispose();
-        }
+        this.adapter = null;
+        adapter.dispose();
     }
 }
 const noopDispose = () => { };

package/dist/runtime/adapter/SectionEngineAdapter.d.ts

@@ -1,55 +1,30 @@
 /**
- * Section runtime engine adapter (M7 — Variant C, layered).
+ * Section runtime engine adapter.
  *
  * The adapter is the single I/O seam between the pure FSM core
- * (`SectionEngineCore`) and the rest of the world (DOM, coordinator,
- * framework-error bus, host subscribers, instrumentation). It does
- * exactly two jobs:
+ * (`SectionEngineCore`) and the rest of the world (the DOM and host
+ * subscribers). It does exactly two jobs:
  *
- *   1. Translate **host inputs** (from kernels, the toolkit CE, or
- *      direct facade callers) into `SectionEngineInput`s and forward
- *      them to the core via `core.dispatch(input)`.
+ *   1. Forward host-constructed `SectionEngineInput`s to the core via
+ *      `core.dispatch(input)`.
  *
- *   2. Subscribe to the core's output stream and **route each output**
- *      through the bridges in a deterministic order so the public DOM
- *      surface, framework-error bus, instrumentation hook, and host
- *      subscribers all see exactly the same fan-out with
- *      byte-identical detail shapes.
+ *   2. Subscribe to the core's output stream and route each batch, in
+ *      order, to the DOM-event bridge (`pie-stage-change`,
+ *      `pie-loading-complete`) and then to the subscriber fan-out (one
+ *      batch per `core.dispatch`).
  *
- * Output routing is a single exhaustive `switch` (`assertNever` on
- * the default branch) so adding a new `SectionEngineOutput` kind in
- * `engine-output.ts` is a compile error here until the adapter knows
- * what to do with it.
+ * Output routing is a single exhaustive `switch`, so a new
+ * `SectionEngineOutput` kind is a compile error here until the adapter
+ * routes it.
  *
- * **Routing order per output:**
- *   - canonical DOM event (`pie-stage-change`, `pie-loading-complete`,
- *     `framework-error`)
- *   - framework-error bus (single fan-out for in-process subscribers)
- *   - instrumentation hook
- *   - public subscriber fan-out (batched, runs once per
- *     `core.dispatch`)
- *
- * The `readiness-change` / `interaction-ready` / `ready`
- * DOM events and their event bridge were removed in the
- * broad architecture review compat sweep; the corresponding output
- * kinds are gone from `engine-output.ts`.
- *
- * **Layering constraint.** The adapter is plain TS. It must not
- * import `svelte` — the M7 implementation plan and
- * `scripts/check-engine-core-purity.mjs` enforce the core's purity;
- * the adapter follows the same constraint by convention so it stays
- * usable from non-Svelte hosts (Node tests, Storybook, or future
- * non-Svelte consumers). `bun run check:custom-elements:dist`
- * already blocks `.svelte` imports in published `dist`; adding a
- * Svelte dependency here would also leak through that gate.
+ * **Layering constraint.** The adapter is plain TS and must not import
+ * `svelte`; `scripts/check-engine-core-purity.mjs` enforces it, so the
+ * adapter stays usable from non-Svelte hosts and Node tests.
  */
-import type { FrameworkErrorReporter } from "../../services/framework-error-bus.js";
 import { SectionEngineCore } from "../core/SectionEngineCore.js";
 import type { SectionEngineInput } from "../core/engine-input.js";
 import type { SectionEngineOutput } from "../core/engine-output.js";
 import type { SectionEngineState } from "../core/engine-state.js";
-import { type CoordinatorPort, type ResolveSectionControllerArgs } from "./coordinator-bridge.js";
-import { type InstrumentationHook } from "./instrumentation-bridge.js";
 import { type EngineOutputListener } from "./subscriber-fanout.js";
 export interface SectionEngineAdapterOptions {
     /** Element on which DOM events are dispatched. */
@@ -60,22 +35,6 @@ export interface SectionEngineAdapterOptions {
      * Tag name of the host CE without the `--version-<encoded>` suffix.
      */
     sourceCe: string;
-    /**
-     * Framework-error bus (write side). Shared with the toolkit CE so
-     * subscribers via `coordinator.subscribeFrameworkErrors` see the
-     * same fan-out.
-     */
-    frameworkErrorBus: FrameworkErrorReporter;
-    /**
-     * Optional toolkit coordinator. When supplied, the adapter wires
-     * its framework-error subscription, controller resolution, and
-     * disposal through the coordinator-bridge. Standalone callers (no
-     * coordinator) can omit this and feed `framework-error` and
-     * `section-controller-resolved` inputs directly.
-     */
-    coordinator?: CoordinatorPort;
-    /** Optional one-shot observability hook. */
-    instrumentationHook?: InstrumentationHook;
     /** Clock injection for the DOM bridge. Defaults to `Date.now()`. */
     now?: () => string;
     /**
@@ -88,10 +47,7 @@ export interface SectionEngineAdapterOptions {
 export declare class SectionEngineAdapter {
     private readonly core;
     private readonly domEventBridge;
-    private readonly frameworkErrorBridge;
-    private readonly instrumentationBridge;
     private readonly subscriberFanout;
-    private readonly coordinatorBridge;
     private readonly unsubscribeCore;
     private disposed;
     constructor(options: SectionEngineAdapterOptions);
@@ -116,28 +72,11 @@ export declare class SectionEngineAdapter {
      */
     setHost(host: EventTarget): void;
     /**
-     * Update the instrumentation hook at runtime.
-     */
-    setInstrumentationHook(hook: InstrumentationHook | undefined): void;
-    /**
-     * Resolve a section controller through the configured coordinator.
-     *
-     * Throws if the adapter was constructed without a coordinator.
-     * Standalone callers should manually feed
-     * `{ kind: "section-controller-resolved" }` after their own
-     * controller resolution path completes.
-     */
-    resolveSectionController(args: ResolveSectionControllerArgs): Promise<void>;
-    /**
-     * Tear the adapter down. Safe to call more than once. Disposes the
-     * coordinator bridge (which in turn disposes the section
-     * controller for the current cohort), detaches the core
-     * subscription, and clears subscribers.
-     *
-     * Does **not** dispose the framework-error bus — its lifetime is
-     * owned by the toolkit CE / host.
+     * Tear the adapter down. Safe to call more than once. Emits `disposed`
+     * for the active cohort, then detaches the core subscription and
+     * clears subscribers.
      */
-    dispose(): Promise<void>;
+    dispose(): void;
     private routeOutputs;
     private routeOne;
 }