@midnight-ntwrk/midnight-js-protocol 5.0.0-beta.7 → 5.0.0-beta.8

package/dist/engine.js

@@ -0,0 +1,519 @@
+import * as ledgerV9 from '@midnightntwrk/ledger-v9';
+import { ComposeOptionError, Ledger8RuntimeInvalidError, DownConvertFailedError, MerkleNotRehashedError, UnknownLedger8AxisError, Ledger8InstanceMismatchError } from './errors.js';
+import { a as assembleCallPrototype, e as executeConstructor } from './shared/deploy-D6yyn9P7.js';
+import '@midnight-ntwrk/compact-js';
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Re-expresses a retained-era contract's entry points as a CURRENT-era contract state.
+ *
+ * WHY THIS EXISTS. The fork does not rewrite a contract's stored state: a contract deployed before
+ * it and dormant across it is served, indefinitely, carrying its retained-era envelope. The current
+ * ledger's composer cannot deserialize those bytes — it accepts only its own envelope — so a
+ * keep-state call had nothing to hand it and could not be composed at all.
+ *
+ * WHAT THE COMPOSER ACTUALLY WANTS. The `contractState` a composition takes is NOT the state being
+ * proven. `assembleCallPrototype` uses it for exactly one thing: looking up the `ContractOperation`
+ * for the circuit, to read its verifier key. The state the call is bound to travels separately, as
+ * the transcript's `preState`. So what has to cross the era boundary here is the OPERATION
+ * REGISTRY, not the state.
+ *
+ * WHY THIS IS FAITHFUL, NOT A SUBSTITUTION. The verifier keys come from the chain's own state, read
+ * through the retained decoder, and the caller has already checked its local artifact against them.
+ * The current ledger models retained-era operations natively — `ContractOperationVersion` carries a
+ * `'v3'` arm precisely for them — so a key preserved across the fork is a value this ledger is built
+ * to hold. Nothing is minted here: every key written out is one the chain already holds.
+ *
+ * The primary state is deliberately left at its default. A caller that needed the state itself would
+ * be reading it from {@link ContractStatePojo.state}, not from this registry.
+ *
+ * @param entryPoints The entry points a retained-era contract state declared, as the retained
+ * decoder read them.
+ * @returns The serialized current-era contract state, carrying those entry points and their keys.
+ * @throws ComposeOptionError if no entry point carries a key, since the registry would then answer
+ * for nothing and the composer's own refusal would name a circuit rather than the empty state.
+ */
+const reexpressOperationsForCurrentEra = (entryPoints) => {
+    const state = new ledgerV9.ContractState();
+    let registered = 0;
+    for (const entryPoint of entryPoints) {
+        // A blank slot is carried as `undefined` rather than as empty bytes -- see the fail-closed
+        // decoding note on ContractEntryPointPojo. Skipped rather than refused one by one: if the
+        // circuit being called is the one missing a key, the composer names it precisely, and a
+        // contract may legitimately declare an entry point this call does not touch.
+        if (entryPoint.verifierKey === undefined) {
+            continue;
+        }
+        const operation = new ledgerV9.ContractOperation();
+        operation.verifierKey = entryPoint.verifierKey;
+        state.setOperation(entryPoint.circuitId, operation);
+        registered += 1;
+    }
+    if (registered === 0) {
+        throw new ComposeOptionError('v9', 'contractState');
+    }
+    return state.serialize();
+};
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Wraps a {@link TranscriptPojo} — the output of {@link executeCircuit}
+ * (`./execute.ts`) — into a v9-native `ContractCallPrototype`, ready for
+ * `Intent.new(ttl).addCall(...)`, via {@link assembleCallPrototype}
+ * (`./assemble-call.ts`) against the ledger-v9 module.
+ *
+ * `options.contractState` is the migrated, post-fork v9 `ContractState` —
+ * read from chain, or otherwise carrying the contract's real registered
+ * operations. It must already carry the operation for the circuit: a
+ * keep-state call registers no new verifier key.
+ *
+ * @param options The transcript to wrap, the contract's address, and the
+ * migrated post-fork state to resolve the circuit's operation against.
+ * @returns The v9-native call prototype.
+ * @throws ComposeFailedError at stage `'wrap-call'` if `contractState`
+ * registers no operation for the circuit, and at `'call-verifier-key'` if the
+ * registered operation carries no verifier key — rather than falling back to a
+ * blank, unverifiable operation.
+ * @see {@link RetainedEraExecution}
+ */
+const wrapKeepStateCall = (options) => {
+    const { transcript, contractAddress, contractState, ledgerParameters } = options;
+    return assembleCallPrototype(ledgerV9, {
+        circuitId: transcript.circuitId,
+        contractAddress,
+        // The retained execution leg partitions nothing: it always submits the raw
+        // op sequence as `'unpartitioned'` -- see RetainedEraExecution.
+        transcript: {
+            kind: 'unpartitioned',
+            preState: transcript.preContractState.data.state.encode(),
+            publicTranscript: transcript.publicTranscript,
+            partitionContext: transcript.partitionContext
+        },
+        privateTranscriptOutputs: transcript.privateTranscriptOutputs,
+        input: transcript.input,
+        output: transcript.output,
+        operations: contractState,
+        ledgerParameters,
+        stage: 'wrap-call',
+        version: 'v9'
+    });
+};
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Structural equality over the `EncodedStateValue` algebra — plain objects,
+ * arrays, `Map`s, `Uint8Array`s and primitives.
+ *
+ * `Map`s are compared pairwise in iteration order, deliberately, and that order
+ * is not ascending by key — do not reason about it as sorted.
+ *
+ * @param a One value in the algebra.
+ * @param b The value to compare it against.
+ * @returns `true` when the two are structurally equal.
+ * @see {@link RetainedEraExecution}
+ */
+const structurallyEqual = (a, b) => {
+    if (a === b) {
+        return true;
+    }
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) {
+        return false;
+    }
+    if (a instanceof Uint8Array || b instanceof Uint8Array) {
+        return (a instanceof Uint8Array && b instanceof Uint8Array && a.length === b.length && a.every((byte, i) => byte === b[i]));
+    }
+    if (a instanceof Map || b instanceof Map) {
+        if (!(a instanceof Map) || !(b instanceof Map) || a.size !== b.size) {
+            return false;
+        }
+        const bEntries = Array.from(b);
+        return Array.from(a).every(([key, value], i) => {
+            const bEntry = bEntries[i];
+            return bEntry !== undefined && structurallyEqual(key, bEntry[0]) && structurallyEqual(value, bEntry[1]);
+        });
+    }
+    if (Array.isArray(a) || Array.isArray(b)) {
+        return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, i) => structurallyEqual(item, b[i]));
+    }
+    const aRecord = { ...a };
+    const bRecord = { ...b };
+    const aKeys = Object.keys(aRecord);
+    // `key in bRecord`, not just a matching key count, and a partial guard only --
+    // see RetainedEraExecution and SharedTableDiscipline.
+    return (aKeys.length === Object.keys(bRecord).length &&
+        aKeys.every((key) => key in bRecord && structurallyEqual(aRecord[key], bRecord[key])));
+};
+/**
+ * Reads a bounded Merkle tree's root, failing with
+ * {@link MerkleNotRehashedError} when the tree has not been rehashed.
+ *
+ * Three shapes of "no root" are treated alike: `undefined`, `null`, and a
+ * throw out of the wasm-bindgen shim for `root()`.
+ *
+ * @param tree The bounded Merkle tree to read.
+ * @returns The tree's root.
+ * @throws MerkleNotRehashedError If the tree has no readable root, in any of
+ *   those three shapes.
+ * @see {@link RetainedEraExecution}
+ */
+const checkRoot = (tree) => {
+    let root;
+    try {
+        root = tree.root();
+    }
+    catch (cause) {
+        throw new MerkleNotRehashedError(cause);
+    }
+    if (root == null) {
+        throw new MerkleNotRehashedError();
+    }
+    return root;
+};
+/**
+ * Asserts that every bounded Merkle tree in a `StateValue` tree already has
+ * its node hashes computed, recursing through the only two container variants
+ * in the algebra (`array` and `map`) and ignoring the leaf variants (`cell`,
+ * `null`, and `boundedMerkleTree`'s own contents).
+ *
+ * Does not mutate or rebuild the state: a rootless tree is refused, never
+ * repaired.
+ *
+ * @param sv The `StateValue` tree to walk.
+ * @throws MerkleNotRehashedError On the first tree without a readable root,
+ *   via {@link checkRoot}.
+ * @throws DownConvertFailedError If the walk meets a `StateValue` variant the
+ *   pinned typings do not declare.
+ * @see {@link RetainedEraExecution}
+ */
+const assertMerkleTreesRehashed = (sv) => {
+    const variant = sv.type();
+    switch (variant) {
+        case 'boundedMerkleTree':
+            checkRoot(sv.asBoundedMerkleTree());
+            return;
+        case 'array':
+            sv.asArray().forEach((element) => assertMerkleTreesRehashed(element));
+            return;
+        case 'map': {
+            const map = sv.asMap();
+            map.keys().forEach((key) => assertMerkleTreesRehashed(map.get(key)));
+            return;
+        }
+        case 'cell':
+        case 'null':
+            return;
+        default: {
+            // Compile-time exhaustiveness plus a runtime throw; neither is redundant
+            // with the other -- see SharedTableDiscipline.
+            const unhandled = variant;
+            throw new DownConvertFailedError('state down-convert', new Error(`unhandled StateValue variant '${String(unhandled)}' in the Merkle rehash walk`));
+        }
+    }
+};
+/**
+ * Down-converts an already-extracted (post-fork) {@link EncodedStateValue}
+ * into the pre-fork {@link DownConvertedState} a v8-era circuit executes
+ * against, decoding it through `ledger8Runtime` and asserting (via
+ * {@link assertMerkleTreesRehashed}) that every bounded Merkle tree it
+ * contains already has its hashes computed.
+ *
+ * Never returns a silently empty or partial state: every failure leaves as a
+ * coded error. Structural integrity is checked by re-encoding the decoded value
+ * and comparing it to the input, which costs one extra encode plus a deep
+ * comparison per call.
+ *
+ * `ledger8Runtime` is checked before anything is decoded. Only the two members
+ * this function actually calls are checked; `ContractState` is on
+ * {@link Ledger8CompactRuntime} to pin the era, and is never dereferenced here.
+ *
+ * @param state The already-extracted post-fork encoded state value.
+ * @param ledger8Runtime The injected pre-fork runtime slice.
+ * @returns The pre-fork state a v8-era circuit executes against.
+ * @throws Ledger8RuntimeInvalidError If `ledger8Runtime` is missing
+ *   `StateValue.decode` or `ChargedState`.
+ * @throws DownConvertFailedError If the state cannot be decoded, does not
+ *   re-encode to its source, or the Merkle walk meets an undeclared variant —
+ *   carrying the underlying failure on `cause`.
+ * @throws MerkleNotRehashedError If any bounded Merkle tree in the state has no
+ *   readable root.
+ * @see {@link RetainedEraExecution}
+ * @see {@link FailClosedDecoding}
+ */
+const downConvertForExecution = (state, ledger8Runtime) => {
+    if (typeof ledger8Runtime?.StateValue?.decode !== 'function') {
+        throw new Ledger8RuntimeInvalidError('StateValue.decode');
+    }
+    if (typeof ledger8Runtime.ChargedState !== 'function') {
+        throw new Ledger8RuntimeInvalidError('ChargedState');
+    }
+    try {
+        const decoded = ledger8Runtime.StateValue.decode(state);
+        if (!structurallyEqual(decoded.encode(), state)) {
+            throw new DownConvertFailedError('state down-convert', new Error(`decoded StateValue did not re-encode to its source (source tag '${state.tag}')`));
+        }
+        assertMerkleTreesRehashed(decoded);
+        return { data: new ledger8Runtime.ChargedState(decoded) };
+    }
+    catch (cause) {
+        if (cause instanceof DownConvertFailedError || cause instanceof MerkleNotRehashedError) {
+            throw cause;
+        }
+        throw new DownConvertFailedError('state down-convert', cause);
+    }
+};
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Runs one impure circuit on a pre-fork (`compact-runtime@0.16`) contract
+ * instance and packages every artifact {@link wrapKeepStateCall} needs into a
+ * {@link TranscriptPojo}.
+ *
+ * A circuit that moved coins runs like any other: its post-call Zswap local
+ * state leaves on {@link TranscriptPojo}, decoded through the injected runtime,
+ * for the caller to turn into the transaction's Zswap offer.
+ *
+ * @param options The contract module, circuit id, arguments, down-converted
+ *   state, contract address, coin public key and private state.
+ * @param ledger8Runtime The injected pre-fork glue slice.
+ * @returns Every artifact a v9-native call prototype needs.
+ * @throws Error A plain `Error` — not a {@link PROTOCOL_ERROR_CODES}-carrying
+ *   class — when `circuitId` names no entry point on
+ *   `contract.impureCircuits`.
+ * @see {@link RetainedEraExecution}
+ */
+const executeCircuit = (options, ledger8Runtime) => {
+    const { contract, circuitId, args, state, address, coinPk, privateState } = options;
+    const circuit = Object.hasOwn(contract.impureCircuits, circuitId) ? contract.impureCircuits[circuitId] : undefined;
+    if (typeof circuit !== 'function') {
+        throw new Error(`No impure circuit named '${circuitId}' on this pre-fork contract instance. ` +
+            `Available circuits: ${Object.keys(contract.impureCircuits).join(', ') || '(none)'}.`);
+    }
+    const ctx = ledger8Runtime.createCircuitContext(address, coinPk, state.data, privateState, undefined, ledger8Runtime.CostModel.initialCostModel());
+    // Read BEFORE the circuit runs. The glue swaps `currentQueryContext` for a
+    // new context on every coin it registers, so after the call this object no
+    // longer answers for the context the call started from.
+    const preCallBlock = ctx.currentQueryContext.block;
+    const preCallEffects = ctx.currentQueryContext.effects;
+    const res = circuit(ctx, ...args);
+    return {
+        circuitId,
+        result: res.result,
+        input: res.proofData.input,
+        output: res.proofData.output,
+        publicTranscript: res.proofData.publicTranscript,
+        privateTranscriptOutputs: res.proofData.privateTranscriptOutputs,
+        preContractState: state,
+        postContractState: { data: res.context.currentQueryContext.state },
+        // Encoded HERE, where the retained runtime is in scope, rather than by the
+        // caller: `.encode()` is on the pre-fork `StateValue` this module already
+        // holds, and a caller reaching for it would be reaching through a handle
+        // whose type it cannot name.
+        postContractStateEncoded: res.context.currentQueryContext.state.state.encode(),
+        privateStateAfter: res.context.currentPrivateState,
+        partitionContext: {
+            block: preCallBlock,
+            effects: preCallEffects,
+            comIndices: res.context.currentQueryContext.comIndices
+        },
+        zswapLocalState: ledger8Runtime.decodeZswapLocalState(res.context.currentZswapLocalState)
+    };
+};
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * The closed set of axes this guard will run on, as a lookup rather than a
+ * comparison chain.
+ *
+ * Kept here rather than exported from `errors.ts`, which is a build entry:
+ * nothing outside this module needs to test an axis, and the engine's whole
+ * design is to stay off the public surface.
+ *
+ * @see {@link SharedTableDiscipline}
+ */
+const KNOWN_AXES = Object.freeze(Object.assign(Object.create(null), {
+    'onchain-runtime-v3': true
+}));
+const isKnownAxis = (axis) => KNOWN_AXES[axis] === true;
+/**
+ * Fails fast on a dual-instantiation of a WASM package the down-convert
+ * engine depends on, along one named `axis`.
+ *
+ * Pass a **shared binding** — a class the package exports, such as
+ * `ChargedState` or `StateValue` — never a module namespace object.
+ *
+ * The two probes are compared symmetrically, so they are interchangeable, but
+ * they must be obtained from **two different acquisition paths** (two distinct
+ * import specifiers, or an import versus a caller-supplied module). Passing the
+ * same binding twice satisfies the check trivially and proves nothing; the
+ * caller owns that, because nothing in the signature can enforce it.
+ *
+ * @param axis The physical-copy axis to check, validated against
+ *   {@link Ledger8InstanceAxis} before either probe is looked at.
+ * @param probeA A shared binding, obtained through one acquisition path.
+ * @param probeB The same binding, obtained through a different acquisition
+ *   path.
+ * @throws UnknownLedger8AxisError If `axis` is not a member of
+ *   {@link Ledger8InstanceAxis}.
+ * @throws Ledger8RuntimeInvalidError If either probe is `null` or `undefined`.
+ *   A missing probe is a binding the caller did not hand over, so it is not
+ *   reported as a mismatch.
+ * @throws Ledger8InstanceMismatchError If the two probes are not
+ *   reference-equal, i.e. the package resolved to two physically distinct
+ *   copies in this process.
+ * @example
+ * ```typescript
+ * const [glue, ocrt3] = await Promise.all([
+ *   import('compact-runtime-ledger8'),
+ *   import('@midnight-ntwrk/onchain-runtime-v3')
+ * ]);
+ * // Two acquisition paths to the same binding, never a namespace object.
+ * assertSharedLedger8Instance('onchain-runtime-v3', ocrt3.ChargedState, glue.ChargedState);
+ * ```
+ * @see {@link DualInstantiationGuard}
+ */
+const assertSharedLedger8Instance = (axis, probeA, probeB) => {
+    if (!isKnownAxis(axis)) {
+        throw new UnknownLedger8AxisError(String(axis));
+    }
+    if (probeA == null || probeB == null) {
+        throw new Ledger8RuntimeInvalidError(`${axis} instance probe`);
+    }
+    if (probeA !== probeB) {
+        throw new Ledger8InstanceMismatchError(axis);
+    }
+};
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Acquires the retained pre-fork toolchain — the `compact-runtime@0.16` glue
+ * and `@midnight-ntwrk/onchain-runtime-v3` — and builds a {@link Ledger8Engine}
+ * bound to it.
+ *
+ * Runs {@link assertSharedLedger8Instance} exactly once, on the
+ * `onchain-runtime-v3` axis. Any acquisition failure surfaces through the
+ * facade (`lib/v8/load-engine.ts`) as `Ledger8RuntimeMissingError`
+ * (`../../errors.ts`).
+ *
+ * Does NOT acquire the v8 ledger module: a consumer that only executes
+ * circuits and binds them onto v9 never instantiates the multi-megabyte v8
+ * WASM, and never hard-depends on ledger-v8 resolving.
+ *
+ * @returns The engine surface, with the acquired runtime captured in closure.
+ * @throws Ledger8InstanceMismatchError If `onchain-runtime-v3` resolved to two
+ *   physically distinct copies in this process.
+ * @see {@link EraSeam}
+ * @see {@link DualInstantiationGuard}
+ * @see {@link ModuleGraphAndLazyLoading}
+ */
+const createLedger8Engine = async () => {
+    const [glue, ocrt3] = await Promise.all([
+        import('compact-runtime-ledger8'),
+        import('@midnight-ntwrk/onchain-runtime-v3')
+    ]);
+    assertSharedLedger8Instance('onchain-runtime-v3', ocrt3.ChargedState, glue.ChargedState);
+    // `ContractState` from ocrt3, the other two from the glue: sound only because
+    // of the assertion above -- see DualInstantiationGuard. The member is what
+    // pins this object to the pre-fork era -- see `Ledger8CompactRuntime`.
+    const ledger8CompactRuntime = {
+        ContractState: ocrt3.ContractState,
+        StateValue: glue.StateValue,
+        ChargedState: glue.ChargedState
+    };
+    const ledger8ExecutionRuntime = {
+        decodeZswapLocalState: glue.decodeZswapLocalState,
+        createCircuitContext: glue.createCircuitContext,
+        CostModel: glue.CostModel
+    };
+    const ledger8ConstructorRuntime = {
+        createConstructorContext: glue.createConstructorContext,
+        decodeZswapLocalState: glue.decodeZswapLocalState
+    };
+    return {
+        downConvertForExecution: (state) => downConvertForExecution(state, ledger8CompactRuntime),
+        executeCircuit: (options) => executeCircuit(options, ledger8ExecutionRuntime),
+        wrapKeepStateCall,
+        reexpressOperationsForCurrentEra,
+        executeConstructor: (options) => executeConstructor(options, ledger8ConstructorRuntime)
+    };
+};
+
+export { createLedger8Engine };
+//# sourceMappingURL=engine.js.map

package/dist/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sources":["../src/lib/v9/operations.ts","../src/lib/v9/wrap.ts","../src/lib/v8/down-convert.ts","../src/lib/v8/execute.ts","../src/lib/v8/instance-guard.ts","../src/lib/v8/engine.ts"],"sourcesContent":[null,null,null,null,null,null],"names":[],"mappings":"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"}