mustardscript 0.1.0 → 0.1.1

package/dist/lib/runtime.js

@@ -7,71 +7,123 @@ const {
   throwIfAborted,
   withCancellationSignal,
 } = require('./cancellation.js');
+const { resolveExecutionContext } = require('./policy.js');
 const {
-  createExecutionPolicy,
-  encodeSnapshotPolicy,
-  snapshotIdentity,
-  snapshotToken,
-} = require('./policy.js');
-const {
-  encodeResumePayloadCancel,
-  encodeResumePayloadError,
-  encodeResumePayloadValue,
-  encodeStartOptions,
+  encodeResumePayloadCancelBuffer,
+  encodeResumePayloadErrorBuffer,
+  encodeResumePayloadValueBuffer,
+  encodeStartOptionsBuffer,
+  encodeStructuredInputsBuffer,
 } = require('./structured.js');
 
 function createMustardClass({ native, materializeStep, parseStep }) {
+  const programHandleRegistry =
+    typeof FinalizationRegistry === 'function'
+      ? new FinalizationRegistry((programHandle) => {
+          try {
+            callNative(native.releaseProgram, programHandle);
+          } catch {
+            // Best-effort cleanup only; process shutdown can race native teardown.
+          }
+        })
+      : null;
+
   function compileProgram(code) {
     return callNative(native.compileProgram, code);
   }
 
+  function releaseProgram(programHandle) {
+    callNative(native.releaseProgram, programHandle);
+  }
+
   return class Mustard {
     constructor(code, options = {}) {
-      this._program = compileProgram(code);
+      this._programHandle = compileProgram(code);
+      this._program = null;
       this._inputNames = options.inputs ?? [];
+      this._programHandleToken = {};
+      programHandleRegistry?.register(this, this._programHandle, this._programHandleToken);
     }
 
     static validateProgram(code) {
-      compileProgram(code);
+      const programHandle = compileProgram(code);
+      releaseProgram(programHandle);
+    }
+
+    _ensureProgramHandle() {
+      if (this._programHandle !== null) {
+        return this._programHandle;
+      }
+      const programHandle = callNative(native.loadProgram, this._program);
+      this._programHandle = programHandle;
+      this._programHandleToken = {};
+      programHandleRegistry?.register(this, programHandle, this._programHandleToken);
+      return programHandle;
     }
 
     async run(options = {}) {
       const signal = getAbortSignal(options, 'run options');
       throwIfAborted(signal);
-      const { hostHandlers, policy, snapshotKey } = createExecutionPolicy(options);
+      const { hostHandlers, policy, nativeContextHandle } = resolveExecutionContext(
+        options,
+        'run options',
+      );
+      const programHandle = this._ensureProgramHandle();
+      const startProgram =
+        typeof nativeContextHandle === 'string' && nativeContextHandle.length > 0
+          ? native.startProgramWithExecutionContextHandleBuffer
+          : native.startProgramWithSnapshotHandleBuffer;
+      const startArgs =
+        typeof nativeContextHandle === 'string' && nativeContextHandle.length > 0
+          ? [programHandle, nativeContextHandle, encodeStructuredInputsBuffer(options.inputs)]
+          : [programHandle, encodeStartOptionsBuffer(options.inputs, policy)];
       let step = parseStep(
         withCancellationSignal(
           native,
-          native.startProgram,
-          [this._program, encodeStartOptions(options.inputs, policy)],
+          startProgram,
+          startArgs,
           signal,
         ),
       );
       while (step.type === 'suspended') {
-        const capability = hostHandlers[step.capability];
-        if (typeof capability !== 'function') {
-          throw new Error(`Missing capability: ${step.capability}`);
-        }
-        const outcome = await settleCapabilityInvocation(capability, step.args, signal);
-        const snapshotId = snapshotIdentity(step.snapshot);
-        const policyJson = encodeSnapshotPolicy(policy, {
-          snapshotId,
-          snapshotKey,
-          snapshotToken: snapshotToken(step.snapshot, snapshotKey, snapshotId),
-        });
-        if (outcome.type === 'cancelled') {
+        const snapshotHandle = step.snapshotHandle;
+        try {
+          const capability = hostHandlers[step.capability];
+          if (typeof capability !== 'function') {
+            throw new Error(`Missing capability: ${step.capability}`);
+          }
+          const outcome = await settleCapabilityInvocation(capability, step.args, signal);
+          if (outcome.type === 'cancelled') {
+            step = parseStep(
+              callNative(
+                native.resumeSnapshotHandleBuffer,
+                snapshotHandle,
+                encodeResumePayloadCancelBuffer(),
+              ),
+            );
+            continue;
+          }
+          const payload =
+            outcome.type === 'value'
+              ? encodeResumePayloadValueBuffer(outcome.value)
+              : encodeResumePayloadErrorBuffer(outcome.error);
           step = parseStep(
-            callNative(native.resumeProgram, step.snapshot, encodeResumePayloadCancel(), policyJson),
+            withCancellationSignal(
+              native,
+              native.resumeSnapshotHandleBuffer,
+              [snapshotHandle, payload],
+              signal,
+            ),
           );
-          continue;
+        } finally {
+          if (typeof snapshotHandle === 'string' && snapshotHandle.length > 0) {
+            try {
+              callNative(native.releaseSnapshotHandle, snapshotHandle);
+            } catch {
+              // Best-effort cleanup only.
+            }
+          }
         }
-        const payload =
-          outcome.type === 'value'
-            ? encodeResumePayloadValue(outcome.value)
-            : encodeResumePayloadError(outcome.error);
-        step = parseStep(
-          withCancellationSignal(native, native.resumeProgram, [step.snapshot, payload, policyJson], signal),
-        );
       }
       return step.value;
     }
@@ -79,26 +131,43 @@ function createMustardClass({ native, materializeStep, parseStep }) {
     start(options = {}) {
       const signal = getAbortSignal(options, 'start options');
       throwIfAborted(signal);
-      const { policy, snapshotKey } = createExecutionPolicy(options);
+      const { policy, snapshotKey, nativeContextHandle } = resolveExecutionContext(
+        options,
+        'start options',
+      );
+      const programHandle = this._ensureProgramHandle();
+      const startProgram =
+        typeof nativeContextHandle === 'string' && nativeContextHandle.length > 0
+          ? native.startProgramWithExecutionContextHandleBuffer
+          : native.startProgramWithSnapshotHandleBuffer;
+      const startArgs =
+        typeof nativeContextHandle === 'string' && nativeContextHandle.length > 0
+          ? [programHandle, nativeContextHandle, encodeStructuredInputsBuffer(options.inputs)]
+          : [programHandle, encodeStartOptionsBuffer(options.inputs, policy)];
       const step = parseStep(
         withCancellationSignal(
           native,
-          native.startProgram,
-          [this._program, encodeStartOptions(options.inputs, policy)],
+          startProgram,
+          startArgs,
           signal,
         ),
       );
-      return materializeStep(step, policy, snapshotKey);
+      return materializeStep(step, policy, snapshotKey, programHandle);
     }
 
     dump() {
+      if (this._program === null) {
+        this._program = Buffer.from(callNative(native.dumpProgram, this._ensureProgramHandle()));
+      }
       return Buffer.from(this._program);
     }
 
     static load(buffer) {
       const instance = Object.create(Mustard.prototype);
       instance._program = Buffer.from(buffer);
+      instance._programHandle = null;
       instance._inputNames = [];
+      instance._programHandleToken = {};
       return instance;
     }
   };

package/dist/lib/structured.js

@@ -4,6 +4,104 @@ const { types } = require('node:util');
 
 const HOST_BOUNDARY_MAX_DEPTH = 128;
 const HOST_BOUNDARY_MAX_ARRAY_LENGTH = 1_000_000;
+const encodedStartOptionsSuffixCache = new WeakMap();
+const encodedStartOptionsBinarySuffixCache = new WeakMap();
+const BOUNDARY_BINARY_MAGIC = Buffer.from([0x4d, 0x53, 0x42, 0x01]);
+const BOUNDARY_BINARY_KIND = Object.freeze({
+  START_OPTIONS: 1,
+  STRUCTURED_INPUTS: 2,
+  RESUME_PAYLOAD: 3,
+});
+const STRUCTURED_BINARY_TAG = Object.freeze({
+  UNDEFINED: 0,
+  NULL: 1,
+  HOLE: 2,
+  BOOL_FALSE: 3,
+  BOOL_TRUE: 4,
+  STRING: 5,
+  NUMBER_FINITE: 6,
+  NUMBER_NAN: 7,
+  NUMBER_INFINITY: 8,
+  NUMBER_NEG_INFINITY: 9,
+  NUMBER_NEG_ZERO: 10,
+  ARRAY: 11,
+  OBJECT: 12,
+});
+const RESUME_BINARY_TAG = Object.freeze({
+  VALUE: 0,
+  ERROR: 1,
+  CANCELLED: 2,
+});
+const LIMIT_FIELD_LAYOUT = Object.freeze([
+  ['instruction_budget', 1 << 0],
+  ['heap_limit_bytes', 1 << 1],
+  ['allocation_budget', 1 << 2],
+  ['call_depth_limit', 1 << 3],
+  ['max_outstanding_host_calls', 1 << 4],
+]);
+
+class BinaryWriter {
+  constructor(initialSize = 256) {
+    this._buffer = Buffer.allocUnsafe(initialSize);
+    this._offset = 0;
+  }
+
+  _ensureCapacity(additionalBytes) {
+    const required = this._offset + additionalBytes;
+    if (required <= this._buffer.length) {
+      return;
+    }
+    let nextLength = this._buffer.length;
+    while (nextLength < required) {
+      nextLength *= 2;
+    }
+    const nextBuffer = Buffer.allocUnsafe(nextLength);
+    this._buffer.copy(nextBuffer, 0, 0, this._offset);
+    this._buffer = nextBuffer;
+  }
+
+  writeHeader(kind) {
+    this.writeBuffer(BOUNDARY_BINARY_MAGIC);
+    this.writeU8(kind);
+  }
+
+  writeBuffer(value) {
+    const buffer = Buffer.from(value);
+    this._ensureCapacity(buffer.length);
+    buffer.copy(this._buffer, this._offset);
+    this._offset += buffer.length;
+  }
+
+  writeU8(value) {
+    this._ensureCapacity(1);
+    this._buffer.writeUInt8(value, this._offset);
+    this._offset += 1;
+  }
+
+  writeU32(value) {
+    this._ensureCapacity(4);
+    this._buffer.writeUInt32LE(value >>> 0, this._offset);
+    this._offset += 4;
+  }
+
+  writeF64(value) {
+    this._ensureCapacity(8);
+    this._buffer.writeDoubleLE(value, this._offset);
+    this._offset += 8;
+  }
+
+  writeString(value) {
+    const byteLength = Buffer.byteLength(value, 'utf8');
+    this.writeU32(byteLength);
+    this._ensureCapacity(byteLength);
+    this._buffer.write(value, this._offset, byteLength, 'utf8');
+    this._offset += byteLength;
+  }
+
+  toBuffer() {
+    return Buffer.from(this._buffer.subarray(0, this._offset));
+  }
+}
 
 function assertBoundaryDepth(depth, label) {
   if (depth > HOST_BOUNDARY_MAX_DEPTH) {
@@ -73,15 +171,22 @@ function isAccessorDescriptor(descriptor) {
 
 function enumerateDataProperties(value) {
   assertNotProxy(value);
-  return Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => {
-    if (!descriptor.enumerable) {
-      return false;
+  const keys = Object.keys(value);
+  const entries = new Array(keys.length);
+  let entryCount = 0;
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor === undefined) {
+      continue;
     }
     if (isAccessorDescriptor(descriptor)) {
       throw new TypeError('host objects with accessors cannot cross the host boundary');
     }
-    return true;
-  });
+    entries[entryCount] = [key, descriptor];
+    entryCount += 1;
+  }
+  entries.length = entryCount;
+  return entries;
 }
 
 function enterStructuredTraversal(value, traversal) {
@@ -218,16 +323,178 @@ function decodeStructured(value, depth = 1) {
   throw new TypeError(`Unsupported structured value: ${JSON.stringify(value)}`);
 }
 
-function encodeStartOptions(inputs = {}, policy) {
+function getEncodedStartOptionsSuffix(policy) {
+  let cached = encodedStartOptionsSuffixCache.get(policy);
+  if (cached !== undefined) {
+    return cached;
+  }
+  cached =
+    `,"capabilities":${JSON.stringify(policy.capabilities)}` +
+    `,"limits":${JSON.stringify(policy.limits)}}`;
+  encodedStartOptionsSuffixCache.set(policy, cached);
+  return cached;
+}
+
+function writeLimitValue(writer, value) {
+  writer.writeF64(value);
+}
+
+function writeEncodedLimits(writer, limits = {}) {
+  let mask = 0;
+  for (const [field, bit] of LIMIT_FIELD_LAYOUT) {
+    if (limits[field] !== undefined) {
+      mask |= bit;
+    }
+  }
+  writer.writeU8(mask);
+  for (const [field, bit] of LIMIT_FIELD_LAYOUT) {
+    if ((mask & bit) !== 0) {
+      writeLimitValue(writer, limits[field]);
+    }
+  }
+}
+
+function writeEncodedCapabilities(writer, capabilities = []) {
+  writer.writeU32(capabilities.length);
+  for (const capability of capabilities) {
+    writer.writeString(capability);
+  }
+}
+
+function getEncodedStartOptionsBinarySuffix(policy) {
+  let cached = encodedStartOptionsBinarySuffixCache.get(policy);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const writer = new BinaryWriter();
+  writeEncodedCapabilities(writer, policy.capabilities);
+  writeEncodedLimits(writer, policy.limits);
+  cached = writer.toBuffer();
+  encodedStartOptionsBinarySuffixCache.set(policy, cached);
+  return cached;
+}
+
+function writeStructured(value, writer, traversal = { active: new WeakSet() }, depth = 1) {
+  assertBoundaryDepth(depth, 'host boundary');
+  if (value === undefined) {
+    writer.writeU8(STRUCTURED_BINARY_TAG.UNDEFINED);
+    return;
+  }
+  if (value === null) {
+    writer.writeU8(STRUCTURED_BINARY_TAG.NULL);
+    return;
+  }
+  if (typeof value === 'boolean') {
+    writer.writeU8(value ? STRUCTURED_BINARY_TAG.BOOL_TRUE : STRUCTURED_BINARY_TAG.BOOL_FALSE);
+    return;
+  }
+  if (typeof value === 'number') {
+    if (Number.isNaN(value)) {
+      writer.writeU8(STRUCTURED_BINARY_TAG.NUMBER_NAN);
+      return;
+    }
+    if (Object.is(value, -0)) {
+      writer.writeU8(STRUCTURED_BINARY_TAG.NUMBER_NEG_ZERO);
+      return;
+    }
+    if (value === Infinity) {
+      writer.writeU8(STRUCTURED_BINARY_TAG.NUMBER_INFINITY);
+      return;
+    }
+    if (value === -Infinity) {
+      writer.writeU8(STRUCTURED_BINARY_TAG.NUMBER_NEG_INFINITY);
+      return;
+    }
+    writer.writeU8(STRUCTURED_BINARY_TAG.NUMBER_FINITE);
+    writer.writeF64(value);
+    return;
+  }
+  if (typeof value === 'string') {
+    writer.writeU8(STRUCTURED_BINARY_TAG.STRING);
+    writer.writeString(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    assertNotProxy(value);
+    assertBoundaryArrayLength(value.length, 'host boundary');
+    writer.writeU8(STRUCTURED_BINARY_TAG.ARRAY);
+    writer.writeU32(value.length);
+    const leave = enterStructuredTraversal(value, traversal);
+    try {
+      for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (descriptor === undefined) {
+          writer.writeU8(STRUCTURED_BINARY_TAG.HOLE);
+          continue;
+        }
+        if (isAccessorDescriptor(descriptor)) {
+          throw new TypeError('host objects with accessors cannot cross the host boundary');
+        }
+        writeStructured(descriptor.value, writer, traversal, depth + 1);
+      }
+    } finally {
+      leave();
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    if (!isPlainStructuredObject(value)) {
+      throw new TypeError(
+        'Unsupported host value: only plain objects and arrays can cross the host boundary',
+      );
+    }
+    writer.writeU8(STRUCTURED_BINARY_TAG.OBJECT);
+    const entries = enumerateDataProperties(value);
+    writer.writeU32(entries.length);
+    const leave = enterStructuredTraversal(value, traversal);
+    try {
+      for (const [key, descriptor] of entries) {
+        writer.writeString(key);
+        writeStructured(descriptor.value, writer, traversal, depth + 1);
+      }
+    } finally {
+      leave();
+    }
+    return;
+  }
+  throw new TypeError('Unsupported host value');
+}
+
+function writeStructuredInputEntries(writer, inputs = {}) {
+  const entries = enumerateDataProperties(inputs);
+  writer.writeU32(entries.length);
+  for (const [key, descriptor] of entries) {
+    writer.writeString(key);
+    writeStructured(descriptor.value, writer);
+  }
+}
+
+function encodeStructuredInputs(inputs = {}) {
   const encodedInputs = {};
   for (const [key, descriptor] of enumerateDataProperties(inputs)) {
     defineEnumerableProperty(encodedInputs, key, encodeStructured(descriptor.value));
   }
-  return JSON.stringify({
-    inputs: encodedInputs,
-    capabilities: policy.capabilities,
-    limits: policy.limits,
-  });
+  return JSON.stringify(encodedInputs);
+}
+
+function encodeStartOptions(inputs = {}, policy) {
+  const encodedInputs = encodeStructuredInputs(inputs);
+  return `{"inputs":${encodedInputs}${getEncodedStartOptionsSuffix(policy)}`;
+}
+
+function encodeStructuredInputsBuffer(inputs = {}) {
+  const writer = new BinaryWriter();
+  writer.writeHeader(BOUNDARY_BINARY_KIND.STRUCTURED_INPUTS);
+  writeStructuredInputEntries(writer, inputs);
+  return writer.toBuffer();
+}
+
+function encodeStartOptionsBuffer(inputs = {}, policy) {
+  const writer = new BinaryWriter();
+  writer.writeHeader(BOUNDARY_BINARY_KIND.START_OPTIONS);
+  writeStructuredInputEntries(writer, inputs);
+  writer.writeBuffer(getEncodedStartOptionsBinarySuffix(policy));
+  return writer.toBuffer();
 }
 
 function encodeResumePayloadValue(value) {
@@ -237,6 +504,14 @@ function encodeResumePayloadValue(value) {
   });
 }
 
+function encodeResumePayloadValueBuffer(value) {
+  const writer = new BinaryWriter();
+  writer.writeHeader(BOUNDARY_BINARY_KIND.RESUME_PAYLOAD);
+  writer.writeU8(RESUME_BINARY_TAG.VALUE);
+  writeStructured(value, writer);
+  return writer.toBuffer();
+}
+
 function readOwnDataProperty(value, key, label) {
   const descriptor = Object.getOwnPropertyDescriptor(value, key);
   if (descriptor === undefined) {
@@ -266,19 +541,60 @@ function encodeResumePayloadError(error) {
   });
 }
 
+function encodeResumePayloadErrorBuffer(error) {
+  const source = error instanceof Error ? error : Object(error);
+  assertNotProxy(source);
+  const name = readOwnDataProperty(source, 'name', 'host errors');
+  const message = readOwnDataProperty(source, 'message', 'host errors');
+  const code = readOwnDataProperty(source, 'code', 'host errors');
+  const details = readOwnDataProperty(source, 'details', 'host errors');
+  const writer = new BinaryWriter();
+  writer.writeHeader(BOUNDARY_BINARY_KIND.RESUME_PAYLOAD);
+  writer.writeU8(RESUME_BINARY_TAG.ERROR);
+  writer.writeString(typeof name === 'string' ? name : 'Error');
+  writer.writeString(typeof message === 'string' ? message : '');
+  if (typeof code === 'string') {
+    writer.writeU8(1);
+    writer.writeString(code);
+  } else {
+    writer.writeU8(0);
+  }
+  if (details === undefined) {
+    writer.writeU8(0);
+  } else {
+    writer.writeU8(1);
+    writeStructured(details, writer);
+  }
+  return writer.toBuffer();
+}
+
 function encodeResumePayloadCancel() {
   return JSON.stringify({
     type: 'cancelled',
   });
 }
 
+function encodeResumePayloadCancelBuffer() {
+  const writer = new BinaryWriter();
+  writer.writeHeader(BOUNDARY_BINARY_KIND.RESUME_PAYLOAD);
+  writer.writeU8(RESUME_BINARY_TAG.CANCELLED);
+  return writer.toBuffer();
+}
+
 module.exports = {
+  BOUNDARY_BINARY_KIND,
   decodeStructured,
   defineEnumerableProperty,
   encodeResumePayloadCancel,
+  encodeResumePayloadCancelBuffer,
   encodeResumePayloadError,
+  encodeResumePayloadErrorBuffer,
   encodeResumePayloadValue,
+  encodeResumePayloadValueBuffer,
   encodeStartOptions,
+  encodeStartOptionsBuffer,
+  encodeStructuredInputs,
+  encodeStructuredInputsBuffer,
   encodeStructured,
   enumerateDataProperties,
   hasOwnProperty,

package/dist/native-loader.js

@@ -13,7 +13,7 @@ const PREBUILT_TARGETS = Object.freeze([
     platform: 'win32',
     arch: 'x64',
     platformArchABI: 'win32-x64-msvc',
-    packageName: 'mustardscript-win32-x64-msvc',
+    packageName: '@mustardscript/binding-win32-x64-msvc',
     localFile: 'index.win32-x64-msvc.node',
     os: ['win32'],
     cpu: ['x64'],
@@ -23,7 +23,7 @@ const PREBUILT_TARGETS = Object.freeze([
     platform: 'darwin',
     arch: 'x64',
     platformArchABI: 'darwin-x64',
-    packageName: 'mustardscript-darwin-x64',
+    packageName: '@mustardscript/binding-darwin-x64',
     localFile: 'index.darwin-x64.node',
     os: ['darwin'],
     cpu: ['x64'],
@@ -33,7 +33,7 @@ const PREBUILT_TARGETS = Object.freeze([
     platform: 'darwin',
     arch: 'arm64',
     platformArchABI: 'darwin-arm64',
-    packageName: 'mustardscript-darwin-arm64',
+    packageName: '@mustardscript/binding-darwin-arm64',
     localFile: 'index.darwin-arm64.node',
     os: ['darwin'],
     cpu: ['arm64'],
@@ -43,7 +43,7 @@ const PREBUILT_TARGETS = Object.freeze([
     platform: 'linux',
     arch: 'x64',
     platformArchABI: 'linux-x64-gnu',
-    packageName: 'mustardscript-linux-x64-gnu',
+    packageName: '@mustardscript/binding-linux-x64-gnu',
     localFile: 'index.linux-x64-gnu.node',
     os: ['linux'],
     cpu: ['x64'],
@@ -90,11 +90,7 @@ function getCurrentPrebuiltTarget() {
 }
 
 function getLocalBuildOutputFile() {
-  return getCurrentPrebuiltTarget()?.localFile ?? 'index.node';
-}
-
-function getLocalBinaryFilenames() {
-  return [...new Set([getLocalBuildOutputFile(), 'index.node'])];
+  return getCurrentPrebuiltTarget()?.localFile ?? null;
 }
 
 function validatePrebuiltPackageManifest(manifest, target, packageJsonPath) {
@@ -155,7 +151,11 @@ function localBinaryCandidates(searchRoot = packageRoot()) {
       continue;
     }
 
-    for (const filename of getLocalBinaryFilenames()) {
+    const localFile = getLocalBuildOutputFile();
+    if (!localFile) {
+      continue;
+    }
+    for (const filename of [localFile]) {
       const candidate = path.join(root, filename);
       const stats = fs.statSync(candidate, { throwIfNoEntry: false });
       if (stats?.isFile()) {
@@ -211,14 +211,13 @@ function loadNative(options = {}) {
     : `${process.platform}-${process.arch}`;
   throw new AggregateError(
     loadErrors,
-    `Unable to locate a MustardScript native addon for ${platformHint}. Install a matching optional prebuilt package or allow the source build to run.`,
+    `Unable to locate a MustardScript native addon for ${platformHint}. Install a matching prebuilt package for this platform.`,
   );
 }
 
 module.exports = {
   PREBUILT_TARGETS,
   getCurrentPrebuiltTarget,
-  getLocalBinaryFilenames,
   getLocalBuildOutputFile,
   localBinaryCandidates,
   resolveNativeAddonPath,