voltaire-effect 0.2.23 → 0.2.24

package/src/primitives/BloomFilter/hash.ts

@@ -0,0 +1,43 @@
+/**
+ * @module hash
+ * @description BloomFilter hash functions (pure)
+ * @since 0.1.0
+ */
+import * as BloomFilterModule from "@tevm/voltaire/BloomFilter";
+
+/**
+ * Hash an item for BloomFilter insertion/lookup
+ *
+ * @param item - Item to hash
+ * @param seed - Hash function seed
+ * @param m - Filter size in bits
+ * @returns Hash value (bit position)
+ * @example
+ * ```typescript
+ * import * as BloomFilter from 'voltaire-effect/primitives/BloomFilter'
+ *
+ * const pos = BloomFilter.hash(item, 0, 2048)
+ * ```
+ */
+export const hash = (item: Uint8Array, seed: number, m: number): number =>
+	BloomFilterModule.hash(item, seed, m);
+
+/**
+ * Hash from pre-computed keccak hash
+ *
+ * @param keccakHash - Pre-computed keccak hash
+ * @param seed - Hash function seed
+ * @param m - Filter size in bits
+ * @returns Hash value (bit position)
+ * @example
+ * ```typescript
+ * import * as BloomFilter from 'voltaire-effect/primitives/BloomFilter'
+ *
+ * const pos = BloomFilter.hashFromKeccak(keccakResult, 0, 2048)
+ * ```
+ */
+export const hashFromKeccak = (
+	keccakHash: Uint8Array,
+	seed: number,
+	m: number,
+): number => BloomFilterModule.hashFromKeccak(keccakHash, seed, m);

package/src/primitives/BloomFilter/index.ts

@@ -1,25 +1,42 @@
 /**
- * @fileoverview BloomFilter module for Ethereum log bloom filters.
  * @module BloomFilter
- * @since 0.0.1
+ * @description Effect Schemas and functions for Ethereum bloom filters.
  *
- * @description
  * Bloom filters are probabilistic data structures used in Ethereum for efficient
  * log searching. Each block contains a logs bloom filter (2048 bits, 3 hash functions)
  * that allows quick checking of whether a block might contain relevant logs.
  *
- * Key properties:
- * - False positives possible: "maybe in set" could be wrong
- * - False negatives impossible: "not in set" is always correct
- * - Space efficient: Compact representation of set membership
- * - Fast lookups: O(k) where k is number of hash functions
+ * ## Type Declarations
  *
- * This module provides:
- * - Creation of bloom filters with configurable parameters
- * - Adding items to filters
- * - Probabilistic membership testing
- * - Serialization to/from hex
- * - Effect Schema for validation
+ * ```typescript
+ * import * as BloomFilter from 'voltaire-effect/primitives/BloomFilter'
+ *
+ * function checkLogs(filter: BloomFilter.BloomFilterType) {
+ *   // ...
+ * }
+ * ```
+ *
+ * ## Constructors (Effect-wrapped)
+ *
+ * ```typescript
+ * BloomFilter.create(m, k)           // Effect<BloomFilterType, InvalidBloomFilterParameterError>
+ * BloomFilter.fromHex(hex, m, k)     // Effect<BloomFilterType, InvalidBloomFilterLengthError>
+ * ```
+ *
+ * ## Pure Functions
+ *
+ * ```typescript
+ * BloomFilter.add(filter, item)      // void (mutates in place)
+ * BloomFilter.contains(filter, item) // boolean
+ * BloomFilter.combine(...filters)    // BloomFilterType
+ * BloomFilter.merge(f1, f2)          // BloomFilterType
+ * BloomFilter.toHex(filter)          // string
+ * BloomFilter.isEmpty(filter)        // boolean
+ * BloomFilter.density(filter)        // number
+ * BloomFilter.expectedFalsePositiveRate(filter, n) // number
+ * BloomFilter.hash(item, seed, m)    // number
+ * BloomFilter.hashFromKeccak(hash, seed, m) // number
+ * ```
  *
  * @example
  * ```typescript
@@ -27,38 +44,43 @@
  * import * as Effect from 'effect/Effect'
  *
  * const program = Effect.gen(function* () {
- *   // Create a filter (Ethereum uses 2048 bits, 3 hash functions)
  *   const filter = yield* BloomFilter.create(2048, 3)
+ *   BloomFilter.add(filter, transferEventTopic)
  *
- *   // Add items
- *   yield* BloomFilter.add(filter, transferEventTopic)
- *   yield* BloomFilter.add(filter, contractAddress)
- *
- *   // Check membership
  *   if (BloomFilter.contains(filter, searchTopic)) {
  *     console.log('Topic might be in filter')
  *   }
  *
- *   // Check if empty
- *   console.log(BloomFilter.isEmpty(filter))  // false
- *
- *   // Serialize for storage
- *   const hex = BloomFilter.toHex(filter)
- *
- *   // Restore later
- *   const restored = yield* BloomFilter.fromHex(hex, 2048, 3)
- *
- *   return filter
+ *   return BloomFilter.toHex(filter)
  * })
  * ```
  *
- * @see {@link create} for creating new filters
- * @see {@link add} for adding items
- * @see {@link contains} for membership testing
- * @see {@link BloomFilterSchema} for Effect Schema validation
+ * @since 0.1.0
  */
 
+// Re-export type
+export type { BloomFilterType } from "@tevm/voltaire/BloomFilter";
+
+// Re-export errors
 export {
-	BloomFilterSchema,
-	BloomFilterSchema as Schema,
-} from "./BloomFilterSchema.js";
+	InvalidBloomFilterLengthError,
+	InvalidBloomFilterParameterError,
+} from "@tevm/voltaire/BloomFilter";
+
+// Schema
+export { BloomFilterSchema, BloomFilterSchema as Schema } from "./BloomFilterSchema.js";
+
+// Constructors (Effect-wrapped)
+export { create } from "./create.js";
+export { fromHex } from "./fromHex.js";
+
+// Pure functions
+export { add } from "./add.js";
+export { combine } from "./combine.js";
+export { contains } from "./contains.js";
+export { density } from "./density.js";
+export { expectedFalsePositiveRate } from "./expectedFalsePositiveRate.js";
+export { hash, hashFromKeccak } from "./hash.js";
+export { isEmpty } from "./isEmpty.js";
+export { merge } from "./merge.js";
+export { toHex } from "./toHex.js";

package/src/primitives/BloomFilter/isEmpty.ts

@@ -0,0 +1,22 @@
+/**
+ * @module isEmpty
+ * @description Check if BloomFilter is empty (pure predicate)
+ * @since 0.1.0
+ */
+import { BloomFilter, type BloomFilterType } from "@tevm/voltaire/BloomFilter";
+
+/**
+ * Check if a BloomFilter is empty (all bits are zero)
+ *
+ * @param filter - The bloom filter
+ * @returns true if filter is empty
+ * @example
+ * ```typescript
+ * import * as BloomFilter from 'voltaire-effect/primitives/BloomFilter'
+ *
+ * const filter = await Effect.runPromise(BloomFilter.create(2048, 3))
+ * BloomFilter.isEmpty(filter) // true
+ * ```
+ */
+export const isEmpty = (filter: BloomFilterType): boolean =>
+	BloomFilter.isEmpty(filter);

package/src/primitives/BloomFilter/merge.ts

@@ -0,0 +1,24 @@
+/**
+ * @module merge
+ * @description Merge two BloomFilters into one (pure)
+ * @since 0.1.0
+ */
+import { BloomFilter, type BloomFilterType } from "@tevm/voltaire/BloomFilter";
+
+/**
+ * Merge two BloomFilters into a single filter
+ *
+ * @param filter1 - First filter
+ * @param filter2 - Second filter
+ * @returns Merged bloom filter
+ * @example
+ * ```typescript
+ * import * as BloomFilter from 'voltaire-effect/primitives/BloomFilter'
+ *
+ * const merged = BloomFilter.merge(filter1, filter2)
+ * ```
+ */
+export const merge = (
+	filter1: BloomFilterType,
+	filter2: BloomFilterType,
+): BloomFilterType => BloomFilter.merge(filter1, filter2);

package/src/primitives/BloomFilter/toHex.ts

@@ -0,0 +1,22 @@
+/**
+ * @module toHex
+ * @description Convert BloomFilter to hex string (pure)
+ * @since 0.1.0
+ */
+import { BloomFilter, type BloomFilterType } from "@tevm/voltaire/BloomFilter";
+
+/**
+ * Convert BloomFilter to hex string
+ *
+ * @param filter - The bloom filter
+ * @returns Hex string representation
+ * @example
+ * ```typescript
+ * import * as BloomFilter from 'voltaire-effect/primitives/BloomFilter'
+ *
+ * const hex = BloomFilter.toHex(filter)
+ * console.log(hex) // '0x00...'
+ * ```
+ */
+export const toHex = (filter: BloomFilterType): string =>
+	BloomFilter.toHex(filter);

package/src/primitives/Bytecode/analyze.ts

@@ -0,0 +1,58 @@
+/**
+ * @module analyze
+ * @description Bytecode analysis functions (pure)
+ * @since 0.1.0
+ */
+import {
+	analyze as _analyze,
+	analyzeBlocks as _analyzeBlocks,
+	analyzeGas as _analyzeGas,
+	analyzeJumpDestinations as _analyzeJumpDestinations,
+	analyzeStack as _analyzeStack,
+} from "@tevm/voltaire/Bytecode";
+import type {
+	BrandedBytecode,
+	Analysis,
+	BasicBlock,
+	BlockAnalysisOptions,
+	GasAnalysis,
+	GasAnalysisOptions,
+	StackAnalysis,
+	StackAnalysisOptions,
+} from "./types.js";
+
+/**
+ * Analyze bytecode for jump destinations and instructions
+ */
+export const analyze = (code: BrandedBytecode): Analysis => _analyze(code);
+
+/**
+ * Analyze bytecode into basic blocks
+ */
+export const analyzeBlocks = (
+	bytecode: BrandedBytecode,
+	options?: BlockAnalysisOptions,
+): BasicBlock[] => _analyzeBlocks(bytecode, options);
+
+/**
+ * Analyze gas costs in bytecode
+ */
+export const analyzeGas = (
+	bytecode: BrandedBytecode,
+	options?: GasAnalysisOptions,
+): GasAnalysis => _analyzeGas(bytecode, options);
+
+/**
+ * Analyze jump destinations in bytecode
+ */
+export const analyzeJumpDestinations = (
+	code: BrandedBytecode,
+): ReadonlySet<number> => _analyzeJumpDestinations(code);
+
+/**
+ * Analyze stack effects in bytecode
+ */
+export const analyzeStack = (
+	bytecode: BrandedBytecode,
+	options?: StackAnalysisOptions,
+): StackAnalysis => _analyzeStack(bytecode, options);

package/src/primitives/Bytecode/detectFusions.ts

@@ -0,0 +1,10 @@
+/**
+ * @module detectFusions
+ * @description Detect fusion patterns in bytecode (pure)
+ * @since 0.1.0
+ */
+import { detectFusions as _detectFusions } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const detectFusions = (code: BrandedBytecode): unknown =>
+	_detectFusions(code);

package/src/primitives/Bytecode/equals.ts

@@ -0,0 +1,10 @@
+/**
+ * @module equals
+ * @description Bytecode equality check (pure)
+ * @since 0.1.0
+ */
+import { equals as _equals } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const equals = (a: BrandedBytecode, b: BrandedBytecode): boolean =>
+	_equals(a, b);

package/src/primitives/Bytecode/extractRuntime.ts

@@ -0,0 +1,12 @@
+/**
+ * @module extractRuntime
+ * @description Extract runtime bytecode from deploy bytecode (pure)
+ * @since 0.1.0
+ */
+import { extractRuntime as _extractRuntime } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const extractRuntime = (
+	code: BrandedBytecode,
+	offset: number,
+): BrandedBytecode => _extractRuntime(code, offset);

package/src/primitives/Bytecode/format.ts

@@ -0,0 +1,16 @@
+/**
+ * @module format
+ * @description Format bytecode instructions (pure)
+ * @since 0.1.0
+ */
+import {
+	formatInstruction as _formatInstruction,
+	formatInstructions as _formatInstructions,
+} from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode, Instruction } from "./types.js";
+
+export const formatInstruction = (inst: Instruction): string =>
+	_formatInstruction(inst);
+
+export const formatInstructions = (code: BrandedBytecode): string[] =>
+	_formatInstructions(code);

package/src/primitives/Bytecode/from.ts

@@ -0,0 +1,16 @@
+/**
+ * @module from
+ * @description Create Bytecode from various input types with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { from as _from } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const from = (
+	value: string | Uint8Array,
+): Effect.Effect<BrandedBytecode, Error> =>
+	Effect.try({
+		try: () => _from(value),
+		catch: (e) => e as Error,
+	});

package/src/primitives/Bytecode/fromHex.ts

@@ -0,0 +1,14 @@
+/**
+ * @module fromHex
+ * @description Create Bytecode from hex string with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { fromHex as _fromHex } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const fromHex = (hex: string): Effect.Effect<BrandedBytecode, Error> =>
+	Effect.try({
+		try: () => _fromHex(hex),
+		catch: (e) => e as Error,
+	});

package/src/primitives/Bytecode/getBlock.ts

@@ -0,0 +1,12 @@
+/**
+ * @module getBlock
+ * @description Get basic block at program counter (pure)
+ * @since 0.1.0
+ */
+import { getBlock as _getBlock } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode, BasicBlock } from "./types.js";
+
+export const getBlock = (
+	code: BrandedBytecode,
+	pc: number,
+): BasicBlock | undefined => _getBlock(code, pc);

package/src/primitives/Bytecode/getNextPc.ts

@@ -0,0 +1,12 @@
+/**
+ * @module getNextPc
+ * @description Get next program counter after instruction (pure)
+ * @since 0.1.0
+ */
+import { _getNextPc as __getNextPc } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const _getNextPc = (
+	code: BrandedBytecode,
+	currentPc: number,
+): number => __getNextPc(code, currentPc) ?? currentPc + 1;

package/src/primitives/Bytecode/getPushSize.ts

@@ -0,0 +1,8 @@
+/**
+ * @module getPushSize
+ * @description Get PUSH instruction size (pure)
+ * @since 0.1.0
+ */
+import { getPushSize as _getPushSize } from "@tevm/voltaire/Bytecode";
+
+export const getPushSize = (opcode: number): number => _getPushSize(opcode);

package/src/primitives/Bytecode/hasMetadata.ts

@@ -0,0 +1,10 @@
+/**
+ * @module hasMetadata
+ * @description Check if bytecode has CBOR metadata (pure)
+ * @since 0.1.0
+ */
+import { hasMetadata as _hasMetadata } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const hasMetadata = (code: BrandedBytecode): boolean =>
+	_hasMetadata(code);

package/src/primitives/Bytecode/hash.ts

@@ -0,0 +1,9 @@
+/**
+ * @module hash
+ * @description Compute bytecode hash (pure)
+ * @since 0.1.0
+ */
+import { hash as _hash } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const hash = (code: BrandedBytecode): string => _hash(code);

package/src/primitives/Bytecode/index.ts

@@ -1,6 +1,6 @@
 /**
  * @module Bytecode
- * @description Effect Schemas for EVM contract bytecode.
+ * @description Effect Schemas and functions for EVM contract bytecode.
  *
  * Bytecode is the compiled machine code executed by the EVM.
  *
@@ -9,7 +9,7 @@
  * ```typescript
  * import * as Bytecode from 'voltaire-effect/primitives/Bytecode'
  *
- * function deployContract(code: Bytecode.BytecodeType) {
+ * function deployContract(code: Bytecode.BrandedBytecode) {
  *   // ...
  * }
  * ```
@@ -18,28 +18,118 @@
  *
  * | Schema | Input | Output |
  * |--------|-------|--------|
- * | `Bytecode.Hex` | hex string | BytecodeType |
- * | `Bytecode.Bytes` | Uint8Array | BytecodeType |
+ * | `Bytecode.Hex` | hex string | BrandedBytecode |
+ * | `Bytecode.Bytes` | Uint8Array | BrandedBytecode |
+ * | `Bytecode.Schema` | string or Uint8Array | BrandedBytecode |
  *
- * ## Usage
+ * ## Constructors (Effect-wrapped)
  *
  * ```typescript
- * import * as Bytecode from 'voltaire-effect/primitives/Bytecode'
- * import * as S from 'effect/Schema'
+ * Bytecode.from(value)    // Effect<BrandedBytecode, Error>
+ * Bytecode.fromHex(hex)   // Effect<BrandedBytecode, Error>
+ * ```
+ *
+ * ## Pure Functions
+ *
+ * ```typescript
+ * // Analysis
+ * Bytecode.analyze(code)                    // Analysis
+ * Bytecode.analyzeBlocks(code, opts)        // BasicBlock[]
+ * Bytecode.analyzeGas(code, opts)           // GasAnalysis
+ * Bytecode.analyzeJumpDestinations(code)    // ReadonlySet<number>
+ * Bytecode.analyzeStack(code, opts)         // StackAnalysis
+ * Bytecode.detectFusions(code)              // fusion patterns
+ *
+ * // Comparison
+ * Bytecode.equals(a, b)                     // boolean
+ *
+ * // Extraction
+ * Bytecode.extractRuntime(code, offset)     // BrandedBytecode
+ * Bytecode.stripMetadata(code)              // BrandedBytecode
+ * Bytecode.toAbi(code)                      // BrandedAbi
  *
- * // From hex string
- * const code = S.decodeSync(Bytecode.Hex)('0x6080604052...')
+ * // Formatting
+ * Bytecode.formatInstruction(inst)          // string
+ * Bytecode.formatInstructions(code)         // string[]
+ * Bytecode.prettyPrint(code, opts)          // string
  *
- * // From bytes
- * const code2 = S.decodeSync(Bytecode.Bytes)(bytes)
+ * // Navigation
+ * Bytecode.getBlock(code, pc)               // BasicBlock | undefined
+ * Bytecode._getNextPc(code, pc)             // number
+ * Bytecode.scan(code, opts)                 // Generator
  *
- * // Encode back to hex
- * const hex = S.encodeSync(Bytecode.Hex)(code)
+ * // Predicates
+ * Bytecode.getPushSize(opcode)              // number
+ * Bytecode.hasMetadata(code)                // boolean
+ * Bytecode.isPush(opcode)                   // boolean
+ * Bytecode.isTerminator(opcode)             // boolean
+ * Bytecode.isValidJumpDest(code, offset)    // boolean
+ * Bytecode.validate(code)                   // boolean
+ *
+ * // Conversion
+ * Bytecode.hash(code)                       // string
+ * Bytecode.parseInstructions(code)          // Instruction[]
+ * Bytecode.size(code)                       // number
+ * Bytecode.toHex(code, prefix?)             // string
  * ```
  *
  * @since 0.1.0
  */
 
+// Re-export types
+export type {
+	BrandedBytecode,
+	BrandedAbi,
+	Analysis,
+	BasicBlock,
+	BlockAnalysisOptions,
+	GasAnalysis,
+	GasAnalysisOptions,
+	Instruction,
+	PrettyPrintOptions,
+	ScanOptions,
+	StackAnalysis,
+	StackAnalysisOptions,
+} from "@tevm/voltaire/Bytecode";
+
 export type { BytecodeType } from "./BytecodeSchema.js";
+
+// Schemas
 export { Bytes } from "./Bytes.js";
 export { Hex } from "./Hex.js";
+export { Schema } from "./BytecodeSchema.js";
+
+// Constructors (Effect-wrapped)
+export { from } from "./from.js";
+export { fromHex } from "./fromHex.js";
+
+// Analysis functions (pure)
+export {
+	analyze,
+	analyzeBlocks,
+	analyzeGas,
+	analyzeJumpDestinations,
+	analyzeStack,
+} from "./analyze.js";
+
+// Transformation functions (pure)
+export { detectFusions } from "./detectFusions.js";
+export { equals } from "./equals.js";
+export { extractRuntime } from "./extractRuntime.js";
+export { formatInstruction, formatInstructions } from "./format.js";
+export { getBlock } from "./getBlock.js";
+export { _getNextPc } from "./getNextPc.js";
+export { getPushSize } from "./getPushSize.js";
+export { hash } from "./hash.js";
+export { hasMetadata } from "./hasMetadata.js";
+export { isPush } from "./isPush.js";
+export { isTerminator } from "./isTerminator.js";
+export { isValidJumpDest } from "./isValidJumpDest.js";
+export { parseInstructions } from "./parseInstructions.js";
+export { prettyPrint } from "./prettyPrint.js";
+export { scan } from "./scan.js";
+export { size } from "./size.js";
+export { stripMetadata } from "./stripMetadata.js";
+export { toAbi } from "./toAbi.js";
+export { toHex } from "./toHex.js";
+export { validate } from "./validate.js";

package/src/primitives/Bytecode/isPush.ts

@@ -0,0 +1,8 @@
+/**
+ * @module isPush
+ * @description Check if opcode is a PUSH instruction (pure)
+ * @since 0.1.0
+ */
+import { isPush as _isPush } from "@tevm/voltaire/Bytecode";
+
+export const isPush = (opcode: number): boolean => _isPush(opcode);

package/src/primitives/Bytecode/isTerminator.ts

@@ -0,0 +1,8 @@
+/**
+ * @module isTerminator
+ * @description Check if opcode is a block terminator (pure)
+ * @since 0.1.0
+ */
+import { isTerminator as _isTerminator } from "@tevm/voltaire/Bytecode";
+
+export const isTerminator = (opcode: number): boolean => _isTerminator(opcode);

package/src/primitives/Bytecode/isValidJumpDest.ts

@@ -0,0 +1,12 @@
+/**
+ * @module isValidJumpDest
+ * @description Check if offset is a valid jump destination (pure)
+ * @since 0.1.0
+ */
+import { isValidJumpDest as _isValidJumpDest } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const isValidJumpDest = (
+	code: BrandedBytecode,
+	offset: number,
+): boolean => _isValidJumpDest(code, offset);

package/src/primitives/Bytecode/parseInstructions.ts

@@ -0,0 +1,10 @@
+/**
+ * @module parseInstructions
+ * @description Parse bytecode into instructions (pure)
+ * @since 0.1.0
+ */
+import { parseInstructions as _parseInstructions } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode, Instruction } from "./types.js";
+
+export const parseInstructions = (code: BrandedBytecode): Instruction[] =>
+	_parseInstructions(code);

package/src/primitives/Bytecode/prettyPrint.ts

@@ -0,0 +1,12 @@
+/**
+ * @module prettyPrint
+ * @description Pretty print bytecode disassembly (pure)
+ * @since 0.1.0
+ */
+import { prettyPrint as _prettyPrint } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode, PrettyPrintOptions } from "./types.js";
+
+export const prettyPrint = (
+	bytecode: BrandedBytecode,
+	options?: PrettyPrintOptions,
+): string => _prettyPrint(bytecode, options);

package/src/primitives/Bytecode/scan.ts

@@ -0,0 +1,20 @@
+/**
+ * @module scan
+ * @description Iterator over bytecode instructions (pure)
+ * @since 0.1.0
+ */
+import { scan as _scan } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode, ScanOptions } from "./types.js";
+
+export const scan = (
+	bytecode: BrandedBytecode,
+	options?: ScanOptions,
+): Generator<{
+	pc: number;
+	opcode: number;
+	type: "push" | "regular";
+	size: number;
+	value?: bigint;
+	gas?: number;
+	stackEffect?: { pop: number; push: number };
+}> => _scan(bytecode, options);