@vgai/engine 0.5.42 → 0.5.45

package/dist/input/input-manager.js

@@ -379,6 +379,8 @@ export class InputManager {
     // level values feeding the same max-magnitude/sum combine every real
     // binding uses (collectScalarContributions/collectVector2Contributions).
     virtualDigitalHeld = new Set();
+    /** Processed strength attached to a held virtual digital action. */
+    virtualDigitalStrength = new Map();
     virtualDigitalTapQueued = new Set();
     virtualDigitalTapActive = new Set();
     /** pulse-runner friction #4 — the release-edge mirror of
@@ -392,6 +394,9 @@ export class InputManager {
     virtualDigitalJustReleased = new Set();
     virtualScalarValues = new Map();
     virtualVector2Values = new Map();
+    /** Derived digital-pair axes owned by mounted foreign runtimes. Their public GetAxis-shaped
+     * calls remain in compat; only interpolation state and action reads live beside their source. */
+    smoothedAxisSets = new Set();
     // D15/T-D15.5 — tick-indexed input scheduling + post-gate recording.
     //
     // `currentTick` is a FALLBACK, self-incrementing counter, used only when a
@@ -482,8 +487,60 @@ export class InputManager {
     pointerLocked = false;
     /** Element currently wired for click-to-pointer-lock, and its listener. */
     pointerLockElement = null;
+    /** One report per refusal reason: a refused lock is the whole story of
+     *  "the mouse doesn't aim", and it was silent. */
+    reportedPointerLockRefusals = new Set();
+    reportPointerLockRefused(reason) {
+        if (this.reportedPointerLockRefusals.has(reason))
+            return;
+        this.reportedPointerLockRefusals.add(reason);
+        // biome-ignore lint/suspicious/noConsole: the game's own input intent failed in the browser — an error the editor console and a tester's evidence must both carry
+        console.error(`Pointer lock was refused, so mouse look and mouse aim cannot engage: ${reason}. ` +
+            'The browser grants it only to a user gesture on a page it trusts — a page inside a ' +
+            'frame needs allow="pointer-lock", and some extensions block it.');
+    }
+    /** A retry already scheduled for Chrome's post-exit cooldown, if any. */
+    pointerLockRetry = null;
     onPointerLockClick = () => {
-        this.pointerLockElement?.requestPointerLock();
+        // Chrome answers with a promise that REJECTS when the lock is refused (a
+        // sandboxed/automated document, a policy, a frame without the permission).
+        // Three testers in a row reported "the mouse doesn't aim" on the hosted
+        // editor while automation could not lock at all — and the refusal was
+        // caught silently (runhuman passes 122–126). It is reported now, once
+        // per reason, as the error it is.
+        const request = this.pointerLockElement?.requestPointerLock();
+        if (request instanceof Promise) {
+            request.catch((error) => {
+                const reason = error instanceof Error ? error.message : String(error);
+                // CHROME'S COOLDOWN IS NOT A REFUSAL. After Escape ends a lock, a
+                // request in the next ~1.25 s is rejected with "cannot be acquired
+                // immediately after the user has exited the lock" — and a player who
+                // clicks back into the game right away gets no aim and no second
+                // chance (runhuman pass 130: "I can't move the camera with the
+                // mouse"). The click's activation still stands for a few seconds, so
+                // the request is retried once when the cooldown has passed.
+                if (/exited the lock/i.test(reason) && this.pointerLockRetry === null) {
+                    this.pointerLockRetry = setTimeout(() => {
+                        this.pointerLockRetry = null;
+                        const doc = typeof document !== 'undefined' ? document : null;
+                        const activation = typeof navigator !== 'undefined' ? navigator.userActivation : undefined;
+                        if (!this.pointerLockElement || doc?.pointerLockElement === this.pointerLockElement) {
+                            return;
+                        }
+                        if (activation?.isActive) {
+                            this.onPointerLockClick();
+                        }
+                        else {
+                            // The cooldown outlived the click's activation: the retry
+                            // cannot run, and a silent end here is "mouse dead, no error".
+                            this.reportPointerLockRefused(`${reason} (the retry found no user activation left)`);
+                        }
+                    }, 1_300);
+                    return;
+                }
+                this.reportPointerLockRefused(reason);
+            });
+        }
     };
     onPointerLockChange = () => {
         const doc = typeof document !== 'undefined' ? document : null;
@@ -608,6 +665,7 @@ export class InputManager {
             }
         }
         this.virtualDigitalHeld.clear();
+        this.virtualDigitalStrength.clear();
         this.virtualDigitalTapQueued.clear();
         this.virtualDigitalTapActive.clear();
         this.virtualScalarValues.clear();
@@ -742,6 +800,107 @@ export class InputManager {
     actionNames() {
         return [...this.actions.keys()];
     }
+    /**
+     * Create a retained, action-backed set of digital axes. Foreign runtimes keep their public
+     * GetAxis-shaped API in compat, while interpolation and the live action reads stay in the input
+     * owner instead of becoming a parallel compat input store.
+     */
+    createSmoothedAxisSet(definitions) {
+        const byName = new Map();
+        for (const source of definitions) {
+            const definition = { ...source };
+            if (definition.name.length === 0) {
+                throw new Error('InputManager.createSmoothedAxisSet: axis names must not be empty');
+            }
+            if (byName.has(definition.name)) {
+                throw new Error(`InputManager.createSmoothedAxisSet: duplicate axis ${JSON.stringify(definition.name)}`);
+            }
+            if (definition.negativeAction.length === 0 || definition.positiveAction.length === 0) {
+                throw new Error(`InputManager.createSmoothedAxisSet: axis ${JSON.stringify(definition.name)} requires ` +
+                    'both negative and positive actions');
+            }
+            for (const [field, value] of [
+                ['gravity', definition.gravity],
+                ['dead', definition.dead],
+                ['sensitivity', definition.sensitivity],
+            ]) {
+                if (!Number.isFinite(value) || value < 0) {
+                    throw new Error(`InputManager.createSmoothedAxisSet: ${definition.name}.${field} must be a finite ` +
+                        `non-negative number, received ${String(value)}`);
+                }
+            }
+            byName.set(definition.name, Object.freeze(definition));
+        }
+        const state = {
+            definitions: byName,
+            values: new Map(),
+            disposed: false,
+        };
+        this.smoothedAxisSets.add(state);
+        const assertLive = () => {
+            if (state.disposed || this.disposed) {
+                throw new Error('InputManager smoothed axis set has been disposed');
+            }
+        };
+        const definitionOf = (name) => {
+            assertLive();
+            const definition = state.definitions.get(name);
+            if (definition === undefined) {
+                throw new Error(`InputManager smoothed axis set has no axis ${JSON.stringify(name)}`);
+            }
+            return definition;
+        };
+        const rawValue = (definition) => {
+            const negative = this.isPressed(definition.negativeAction) ? -1 : 0;
+            const positive = this.isPressed(definition.positiveAction) ? 1 : 0;
+            return (negative + positive) * (definition.invert ? -1 : 1);
+        };
+        const getAxis = (name) => {
+            const definition = definitionOf(name);
+            const value = state.values.get(name) ?? 0;
+            return Math.abs(value) < definition.dead ? 0 : value;
+        };
+        return {
+            advance: (deltaTime) => {
+                assertLive();
+                if (!Number.isFinite(deltaTime) || deltaTime < 0) {
+                    throw new Error(`InputManager smoothed axis deltaTime must be finite and non-negative, received ` +
+                        String(deltaTime));
+                }
+                for (const definition of state.definitions.values()) {
+                    const target = rawValue(definition);
+                    const current = state.values.get(definition.name) ?? 0;
+                    let next;
+                    if (target === 0) {
+                        const step = definition.gravity * deltaTime;
+                        next = current > 0 ? Math.max(0, current - step) : Math.min(0, current + step);
+                    }
+                    else {
+                        const from = definition.snap && current * target < 0 ? 0 : current;
+                        const step = definition.sensitivity * deltaTime;
+                        next = target > 0 ? Math.min(target, from + step) : Math.max(target, from - step);
+                    }
+                    state.values.set(definition.name, next);
+                }
+            },
+            getAxis,
+            getAxisRaw: (name) => rawValue(definitionOf(name)),
+            snapshot: () => {
+                assertLive();
+                const snapshot = {};
+                for (const name of state.definitions.keys())
+                    snapshot[name] = getAxis(name);
+                return snapshot;
+            },
+            dispose: () => {
+                if (state.disposed)
+                    return;
+                state.disposed = true;
+                state.values.clear();
+                this.smoothedAxisSets.delete(state);
+            },
+        };
+    }
     /**
      * Poll gamepads and virtual look stick (call at start of frame).
      *
@@ -955,10 +1114,12 @@ export class InputManager {
             if (typeof entry.value === 'boolean') {
                 if (entry.value) {
                     this.virtualDigitalHeld.add(entry.action);
+                    this.virtualDigitalStrength.set(entry.action, 1);
                     this.virtualDigitalTapActive.add(entry.action);
                 }
                 else {
                     this.virtualDigitalHeld.delete(entry.action);
+                    this.virtualDigitalStrength.delete(entry.action);
                 }
             }
             else {
@@ -1060,6 +1221,111 @@ export class InputManager {
         }
         return false;
     }
+    /**
+     * Processed strength for a declared digital action without creating a
+     * second action-state store. Digital keys/buttons/touches contribute 1,
+     * while a directional gamepad axis contributes Godot's deadzone-rescaled
+     * magnitude. Multiple bindings combine by greatest strength, matching the
+     * action state that {@link isPressed} reads as a boolean.
+     */
+    getDigitalStrength(actionName) {
+        this.assertValueType(actionName, 'digital', 'getDigitalStrength');
+        if (this.machineInputActive &&
+            (this.virtualDigitalHeld.has(actionName) || this.virtualDigitalTapActive.has(actionName))) {
+            return this.virtualDigitalStrength.get(actionName) ?? 1;
+        }
+        if (!this.inputActive)
+            return 0;
+        const bindings = this.actions.get(actionName);
+        if (!bindings)
+            return 0;
+        let strength = 0;
+        for (const binding of bindings) {
+            switch (binding.type) {
+                case 'key':
+                    if (this.keysDown.has(binding.code))
+                        return 1;
+                    break;
+                case 'mouse_button':
+                    if (this.mouseButtons.has(binding.button))
+                        return 1;
+                    break;
+                case 'gamepad_button':
+                    for (const gp of this.gamepads) {
+                        const button = gp?.buttons[binding.button];
+                        // Pinned InputEventJoypadButton::action_match reports 1 for a
+                        // pressed button and 0 otherwise; GamepadButton.value is not its
+                        // action strength.
+                        if (button?.pressed)
+                            return 1;
+                    }
+                    break;
+                case 'gamepad_axis': {
+                    const deadzone = binding.deadzone ?? GAMEPAD_AXIS_DEFAULT_DEADZONE;
+                    for (const gp of this.gamepads) {
+                        if (!gp)
+                            continue;
+                        const raw = gp.axes[binding.axis] ?? 0;
+                        const directional = binding.direction === 'positive' ? raw : -raw;
+                        if (directional < deadzone)
+                            continue;
+                        strength = Math.max(strength, deadzone === 1
+                            ? 1
+                            : Math.min(1, Math.max(0, (directional - deadzone) / (1 - deadzone))));
+                    }
+                    break;
+                }
+                case 'touch_button':
+                    if (this.touchButtonsDown.has(binding.sourceId))
+                        return 1;
+                    break;
+            }
+        }
+        return strength;
+    }
+    /** Raw (pre-deadzone) strength for a declared digital action. */
+    getDigitalRawStrength(actionName) {
+        this.assertValueType(actionName, 'digital', 'getDigitalRawStrength');
+        if (this.machineInputActive &&
+            (this.virtualDigitalHeld.has(actionName) || this.virtualDigitalTapActive.has(actionName))) {
+            return this.virtualDigitalStrength.get(actionName) ?? 1;
+        }
+        if (!this.inputActive)
+            return 0;
+        const bindings = this.actions.get(actionName);
+        if (!bindings)
+            return 0;
+        let strength = 0;
+        for (const binding of bindings) {
+            switch (binding.type) {
+                case 'key':
+                    if (this.keysDown.has(binding.code))
+                        return 1;
+                    break;
+                case 'mouse_button':
+                    if (this.mouseButtons.has(binding.button))
+                        return 1;
+                    break;
+                case 'gamepad_button':
+                    if (this.gamepads.some((gp) => gp?.buttons[binding.button]?.pressed))
+                        return 1;
+                    break;
+                case 'gamepad_axis':
+                    for (const gp of this.gamepads) {
+                        if (!gp)
+                            continue;
+                        const raw = gp.axes[binding.axis] ?? 0;
+                        strength = Math.max(strength, Math.min(1, Math.max(0, binding.direction === 'positive' ? raw : -raw)));
+                    }
+                    break;
+                case 'touch_button':
+                    if (this.touchButtonsDown.has(binding.sourceId))
+                        return 1;
+                    break;
+            }
+        }
+        return strength;
+    }
     /** Was an action pressed this frame (not held from previous)? */
     isJustPressed(actionName) {
         this.assertValueType(actionName, 'digital', 'isJustPressed');
@@ -1724,6 +1990,18 @@ export class InputManager {
             return false;
         return this.gamepads.some((pad) => pad !== null);
     }
+    /** Connected W3C Gamepad indices in native slot order, gated by the same play/focus state as
+     * every other raw device poll. Foreign-engine adapters use their own collection value type. */
+    getConnectedGamepadIndices() {
+        if (!this.inputActive)
+            return [];
+        const indices = [];
+        for (let index = 0; index < this.gamepads.length; index += 1) {
+            if (this.gamepads[index] !== null)
+                indices.push(index);
+        }
+        return indices;
+    }
     isDeviceGamepadButtonPressed(button) {
         if (!this.inputActive)
             return false;
@@ -1732,6 +2010,15 @@ export class InputManager {
             return false;
         return this.gamepadButtonsDown.has(`${index}:${button}`);
     }
+    /** Raw button state for one explicit native Gamepad slot. */
+    isDeviceGamepadButtonPressedAt(index, button) {
+        if (!this.inputActive)
+            return false;
+        if (!Number.isSafeInteger(index) || index < 0 || !Number.isSafeInteger(button) || button < 0) {
+            return false;
+        }
+        return this.gamepads[index]?.buttons[button]?.pressed ?? false;
+    }
     isDeviceGamepadButtonJustPressed(button) {
         if (!this.inputActive)
             return false;
@@ -1771,6 +2058,15 @@ export class InputManager {
             return 0;
         return this.gamepads[index]?.axes[axis] ?? 0;
     }
+    /** Raw axis value for one explicit native Gamepad slot. */
+    getDeviceGamepadAxisAt(index, axis) {
+        if (!this.inputActive)
+            return 0;
+        if (!Number.isSafeInteger(index) || index < 0 || !Number.isSafeInteger(axis) || axis < 0) {
+            return 0;
+        }
+        return this.gamepads[index]?.axes[axis] ?? 0;
+    }
     firstConnectedGamepadIndex() {
         for (let i = 0; i < this.gamepads.length; i++) {
             if (this.gamepads[i] !== null)
@@ -2181,6 +2477,27 @@ export class InputManager {
         this.applyVirtualActionValue(action, value);
         return { delivered: true };
     }
+    /**
+     * Godot's `Input.action_press(action, strength)` door for a digital action.
+     * This extends the existing virtual held/edge state with its clamped
+     * processed strength instead of maintaining a parallel Godot action map.
+     */
+    setVirtualDigitalStrength(action, strength) {
+        this.assertActionExists(action, 'setVirtualDigitalStrength');
+        this.assertValueType(action, 'digital', 'setVirtualDigitalStrength');
+        if (!Number.isFinite(strength)) {
+            throw new Error('InputManager.setVirtualDigitalStrength: strength must be finite.');
+        }
+        if (!this.machineInputActive) {
+            return { delivered: false, reason: 'input-gated (input disabled by the editor)' };
+        }
+        const clamped = Math.min(1, Math.max(0, strength));
+        // `Input::action_press` sets api_pressed=true even when its clamped
+        // strength is zero; only `action_release` clears the pressed state.
+        this.applyVirtualActionValue(action, true);
+        this.virtualDigitalStrength.set(action, clamped);
+        return { delivered: true };
+    }
     /**
      * The write half of {@link setVirtualAction} — extracted so D15/T-D15.5's
      * `scheduleActionAtTick` can apply a non-boolean (scalar/vector2) queued
@@ -2230,6 +2547,7 @@ export class InputManager {
                     if (this.virtualDigitalHeld.has(action))
                         this.virtualDigitalJustReleased.add(action);
                     this.virtualDigitalHeld.delete(action);
+                    this.virtualDigitalStrength.delete(action);
                 }
                 break;
             case 'scalar':
@@ -2341,17 +2659,34 @@ export class InputManager {
     getInputTrace() {
         return { version: 1, ticks: this.inputTrace.slice() };
     }
-    /** Request pointer lock for FPS-style mouse control */
+    /**
+     * Request pointer lock for FPS-style mouse control.
+     *
+     * Wires `element` for click-to-lock (so a lock released by Escape comes back
+     * on the next click) AND, when the call itself is inside a user gesture,
+     * requests the lock right now. Games call this FROM a click handler
+     * (third-person's Player: canvas click → `requestPointerLock(canvas)`), and
+     * with only the listener wired that first click did nothing — the lock
+     * arrived one click late, with no feedback, which every hosted-editor tester
+     * read as "the mouse doesn't work" (runhuman passes 113–116). Outside a
+     * gesture the browser would refuse and log, so the immediate request is
+     * gated on `navigator.userActivation`.
+     */
     requestPointerLock(element) {
         // Idempotent: never stack duplicate click listeners. Rewire if the element
         // changed, and track it so dispose() can remove the listener.
-        if (this.pointerLockElement === element)
-            return;
-        if (this.pointerLockElement) {
-            this.pointerLockElement.removeEventListener('click', this.onPointerLockClick);
+        if (this.pointerLockElement !== element) {
+            if (this.pointerLockElement) {
+                this.pointerLockElement.removeEventListener('click', this.onPointerLockClick);
+            }
+            this.pointerLockElement = element;
+            element.addEventListener('click', this.onPointerLockClick);
+        }
+        const doc = typeof document !== 'undefined' ? document : null;
+        const activation = typeof navigator !== 'undefined' ? navigator.userActivation : undefined;
+        if (doc && doc.pointerLockElement !== element && activation?.isActive) {
+            this.onPointerLockClick();
         }
-        this.pointerLockElement = element;
-        element.addEventListener('click', this.onPointerLockClick);
     }
     /**
      * Release pointer lock on the element {@link requestPointerLock} wired.
@@ -2366,6 +2701,10 @@ export class InputManager {
      * holding lock on a different element is not ours to drop.
      */
     exitPointerLock() {
+        if (this.pointerLockRetry !== null) {
+            clearTimeout(this.pointerLockRetry);
+            this.pointerLockRetry = null;
+        }
         const el = this.pointerLockElement;
         if (el) {
             el.removeEventListener('click', this.onPointerLockClick);
@@ -2383,6 +2722,16 @@ export class InputManager {
         if (this.disposed)
             return;
         this.disposed = true;
+        // A manager torn down with a key under the hand (Stop while W is held)
+        // kept that key in `keysDown` for good — its listeners went away before
+        // the release arrived, and nothing else clears it. A disposed manager
+        // holds nothing.
+        this.flushHeldState();
+        for (const axes of this.smoothedAxisSets) {
+            axes.disposed = true;
+            axes.values.clear();
+        }
+        this.smoothedAxisSets.clear();
         if (typeof window !== 'undefined') {
             window.removeEventListener('keydown', this.onKeyDown);
             window.removeEventListener('keyup', this.onKeyUp);

package/dist/manifest/configuration-kinds.d.ts

@@ -0,0 +1,97 @@
+/**
+ * THE RUN-CONFIGURATION KIND REGISTRY — the open set of kinds a manifest's
+ * `configurations[]` may declare (ARCHITECTURE-CORE §The project model). A run
+ * configuration is one of the project's ENTRYPOINTS: something the editor,
+ * the CLI or a harness can start by id. The engine registers two kinds
+ * here; a capability registers more through the same door; the manifest
+ * validates each declaration against its kind's own schema at load, and an
+ * unregistered kind refuses loudly naming the registered ones.
+ *
+ * The implicit configuration every project with roots has is `play` — mount
+ * every root in the host — which is never declared and may be named by a
+ * `compound`.
+ */
+import { type ZodType } from 'zod';
+/** The envelope every declaration carries; the rest is the kind's. */
+export interface ConfigurationEnvelope {
+    readonly id: string;
+    readonly kind: string;
+}
+export type ConfigurationRole = 'run' | 'build';
+export interface ConfigurationKindRegistration<T extends ConfigurationEnvelope = ConfigurationEnvelope> {
+    readonly kind: T['kind'];
+    /** Where a configuration of this kind surfaces and which verb starts it:
+     *  `run` (the transport, `vgai run`) or `build` (Export, `vgai build`). */
+    readonly role: ConfigurationRole;
+    /** The declaration's full shape, envelope included; `.strict()`. */
+    readonly schema: ZodType<T>;
+    /** One line for schema output and refusals. */
+    readonly describe: string;
+    /** A build-role kind backed by a project TOOL (the operation catalog):
+     *  the host runs `tool` with `input(configuration)` and reports its
+     *  outcome as the build's. This is how a capability's bake becomes a
+     *  build without the engine knowing what a bake is. */
+    readonly build?: {
+        readonly tool: string;
+        readonly input: (configuration: T) => unknown;
+    };
+}
+/**
+ * What a CONTRIBUTION exports to register a kind — a plain object, so a
+ * project module (evaluated with the project's own copy of the engine)
+ * hands it to the HOST, which registers it in the host's registry. A module
+ * `src/contributions/<name>.kind.ts` exports it as `kind`.
+ */
+export type ConfigurationKindContribution = ConfigurationKindRegistration;
+/** Register a contribution's kind after checking its shape by name. */
+export declare function registerContributedConfigurationKind(value: unknown, source: string): () => void;
+/** Register a kind. A second registration replaces the first (a module
+ *  re-evaluated on save); never throws. */
+export declare function registerConfigurationKind<T extends ConfigurationEnvelope>(registration: ConfigurationKindRegistration<T>): () => void;
+export declare function registeredConfigurationKinds(): readonly string[];
+export declare function configurationKind(kind: string): ConfigurationKindRegistration | undefined;
+/** The id of the implicit configuration: mount every root in the host. */
+export declare const PLAY_CONFIGURATION_ID = "play";
+/** A process the project runs beside the host: an entry module started
+ *  with the project's own toolchain, listening on a port when it has one. */
+export interface ProcessConfiguration extends ConfigurationEnvelope {
+    readonly kind: 'process';
+    /** Project-relative entry module (`server/main.ts`). */
+    readonly entry: string;
+    /** The command that starts it, run in a shell at `cwd`; `npx tsx <entry>`
+     *  when omitted. Declare it when the entry needs its own flags. */
+    readonly command?: string;
+    /** The port it listens on, when readiness means a port. */
+    readonly port?: number;
+    /** Project-relative working directory; the project root when omitted. */
+    readonly cwd?: string;
+    readonly env?: Readonly<Record<string, string>>;
+    /** How a runner knows it is up: the port accepting connections (the
+     *  default when `port` is set), or an HTTP path answering 2xx on it. */
+    readonly ready?: {
+        readonly http?: string;
+    };
+}
+/** Several configurations started together, `play` included by name. */
+export interface CompoundConfiguration extends ConfigurationEnvelope {
+    readonly kind: 'compound';
+    readonly run: readonly string[];
+    /** How many instances of the host mount to run against the rest (the
+     *  editor's Instances picker is this parameter). */
+    readonly instances?: number;
+}
+/** A packaged build of the project's own web bundle: the project's build
+ *  script, then `dist/` packaged as the web artifact. The first build-role
+ *  kind; a capability registers more (a bake, a static site). */
+export interface BundleConfiguration extends ConfigurationEnvelope {
+    readonly kind: 'bundle';
+    /** The package.json script that builds (`build`). */
+    readonly script?: string;
+    /** Extra arguments after `--` (`['--base', './']` for an itch-style relative bundle). */
+    readonly args?: readonly string[];
+}
+export type DeclaredConfiguration = ConfigurationEnvelope & Readonly<Record<string, unknown>>;
+/** Validate `configurations[]` against the registry: every kind registered, every
+ *  declaration its kind's shape, ids unique, compound members declared. */
+export declare function configurationIssues(configurations: readonly ConfigurationEnvelope[]): string[];
+//# sourceMappingURL=configuration-kinds.d.ts.map

package/dist/manifest/configuration-kinds.d.ts.map

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