@relayflows/sdk 2.0.28 → 2.0.30

package/src/plugin-store.ts

@@ -1,6 +1,25 @@
-import { lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { mkdir, mkdtemp, rename, rm, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { payloadManifest, safePath, sha256 } from './bundle.js';
+import {
+  closeDescriptor,
+  closeDirectory,
+  descriptorIsDirectory,
+  descriptorIsFile,
+  directoryEntryIsDirectory,
+  directoryEntryIsFile,
+  lstatPath,
+  openDirectory,
+  openDescriptor,
+  readDescriptor,
+  readDirectoryEntry,
+  statDescriptor,
+} from './fs-descriptor.js';
+import { frozenHostedPromiseValue, hostedPromiseValue } from './hosted-promise-safety.js';
+import { appendIntrinsicArray } from './intrinsic-array.js';
+import { snapshotJsonValue, type JsonValue } from './json-value.js';
+import { MAX_PLUGIN_FILE_BYTES, MAX_PLUGIN_FILES, MAX_PLUGIN_TOTAL_BYTES } from './plugin-github.js';
 import { PluginError } from './plugin-manifest.js';
 
 /**
@@ -13,93 +32,341 @@ import { PluginError } from './plugin-manifest.js';
  * refusal, not a surprise.
  */
 export const PLUGIN_STORE = '.flows/plugins';
+const MKDIR = mkdir;
+const MKDTEMP = mkdtemp;
+const RENAME = rename;
+const RM = rm;
+const WRITE_FILE = writeFile;
+const PATH_DIRNAME = dirname;
+const PATH_JOIN = join;
+const PATH_RESOLVE = resolve;
+const PROCESS_PLATFORM = process.platform;
+const ERROR = Error;
+const MAX_PLUGIN_MANIFEST_BYTES = 4_000_000;
+const MAX_PLUGIN_STORE_ENTRIES = 10_000;
+const ARRAY_IS_ARRAY = Array.isArray;
+const BIG_INT = BigInt;
+const BUFFER_ALLOC_UNSAFE = Buffer.allocUnsafe;
+const BUFFER_TO_STRING = Function.prototype.call.bind(Buffer.prototype.toString) as (
+  value: Buffer,
+  encoding: BufferEncoding,
+) => string;
+const JSON_PARSE = JSON.parse;
+const NUMBER = Number;
+const NUMBER_IS_SAFE_INTEGER = Number.isSafeInteger;
+const OBJECT_CREATE = Object.create;
+const OBJECT_FREEZE = Object.freeze;
+const OBJECT_GET_OWN_PROPERTY_DESCRIPTOR = Object.getOwnPropertyDescriptor;
+const REGEXP_TEST = Function.prototype.call.bind(RegExp.prototype.test) as (pattern: RegExp, value: string) => boolean;
+const SET = Set;
+const SET_ADD = Function.prototype.call.bind(Set.prototype.add) as <T>(set: Set<T>, value: T) => Set<T>;
+const SET_FOR_EACH = Function.prototype.call.bind(Set.prototype.forEach) as <T>(
+  set: Set<T>,
+  callback: (value: T) => void,
+) => void;
+const SET_HAS = Function.prototype.call.bind(Set.prototype.has) as <T>(set: Set<T>, value: T) => boolean;
+const STRING_SPLIT = Function.prototype.call.bind(String.prototype.split) as (
+  value: string,
+  separator: string,
+) => string[];
+const STRING_STARTS_WITH = Function.prototype.call.bind(String.prototype.startsWith) as (
+  value: string,
+  search: string,
+) => boolean;
+const READ_FLAGS = constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0);
 
 export function pluginStoreDirectory(root: string, name: string, digest: string): string {
-  return join(resolve(root), PLUGIN_STORE, `${name}@sha256:${digest}`);
+  return PATH_JOIN(PATH_RESOLVE(root), PLUGIN_STORE, `${name}@sha256:${digest}`);
 }
 
-export interface StoredPluginFile { readonly path: string; readonly data: Uint8Array }
+export interface StoredPluginFile {
+  readonly path: string;
+  readonly data: Uint8Array;
+}
+
+/** @internal Deterministic race seams for the bounded store reader. */
+export interface StoredPluginReadTestHooks {
+  readonly beforeOpen?: (path: string) => Promise<void>;
+  readonly afterStat?: (path: string) => Promise<void>;
+  readonly beforeDirectoryStat?: () => Promise<void>;
+}
+
+const EMPTY_STORED_PLUGIN_HOOKS = OBJECT_FREEZE(
+  OBJECT_CREATE(null),
+) as StoredPluginReadTestHooks;
 
 /** Write the files atomically; an existing directory is verified instead of overwritten. */
-export async function materializePlugin(root: string, name: string, files: readonly StoredPluginFile[]): Promise<{ directory: string; digest: string }> {
+export async function materializePlugin(
+  root: string,
+  name: string,
+  files: readonly StoredPluginFile[],
+): Promise<{ directory: string; digest: string }> {
   const manifest = payloadManifest(files);
   const digest = sha256(manifest);
   const directory = pluginStoreDirectory(root, name, digest);
   let exists = false;
-  try { await lstat(directory); exists = true; }
-  catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
-  if (exists) { await verifyStoredPlugin(directory, digest); return { directory, digest }; }
-  const parent = dirname(directory);
-  await mkdir(parent, { recursive: true });
-  const staging = await mkdtemp(join(parent, '.install-'));
   try {
-    for (const file of files) {
-      if (!safePath(file.path) || file.path === 'manifest.json') throw new PluginError('plugin_path_invalid', `${file.path}: invalid plugin path.`);
-      await mkdir(dirname(join(staging, file.path)), { recursive: true });
-      await writeFile(join(staging, file.path), file.data, { mode: 0o644 });
+    await lstatPath(directory);
+    exists = true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+  }
+  if (exists) {
+    await verifyStoredPlugin(directory, digest);
+    return frozenHostedPromiseValue({ directory, digest });
+  }
+  const parent = PATH_DIRNAME(directory);
+  await MKDIR(parent, { recursive: true });
+  const staging = await MKDTEMP(PATH_JOIN(parent, '.install-'));
+  try {
+    for (let index = 0; index < files.length; index += 1) {
+      const file = files[index]!;
+      if (!safePath(file.path) || file.path === 'manifest.json')
+        throw new PluginError('plugin_path_invalid', `${file.path}: invalid plugin path.`);
+      await MKDIR(PATH_DIRNAME(PATH_JOIN(staging, file.path)), {
+        recursive: true,
+      });
+      await WRITE_FILE(PATH_JOIN(staging, file.path), file.data, {
+        mode: 0o644,
+      });
     }
-    await writeFile(join(staging, 'manifest.json'), manifest);
-    try { await rename(staging, directory); }
-    catch (error) {
-      if (!['EEXIST', 'ENOTEMPTY'].includes((error as NodeJS.ErrnoException).code ?? '')) throw error;
+    await WRITE_FILE(PATH_JOIN(staging, 'manifest.json'), manifest);
+    try {
+      await RENAME(staging, directory);
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code !== 'EEXIST' && code !== 'ENOTEMPTY') throw error;
       await verifyStoredPlugin(directory, digest);
     }
-  } finally { await rm(staging, { recursive: true, force: true }); }
-  return { directory, digest };
+  } finally {
+    await RM(staging, { recursive: true, force: true });
+  }
+  return frozenHostedPromiseValue({ directory, digest });
 }
 
-async function regularFile(root: string, path: string): Promise<Buffer> {
-  const parts = path.split('/');
-  for (let i = 1; i <= parts.length; i++) {
-    const stat = await lstat(join(root, ...parts.slice(0, i)));
-    if (i === parts.length ? !stat.isFile() : !stat.isDirectory()) throw new PluginError('plugin_source_drift', `${path}: expected a regular file, without symlinks.`);
+async function regularFile(
+  root: string,
+  path: string,
+  maxBytes: number,
+  expectedBytes?: number,
+  hooks: StoredPluginReadTestHooks = EMPTY_STORED_PLUGIN_HOOKS,
+): Promise<Buffer> {
+  const absolute = PATH_JOIN(root, path);
+  const handle = await openStoredFile(root, path, hooks);
+  try {
+    const before = await statDescriptor(handle, { bigint: true });
+    if (
+      !descriptorIsFile(before) ||
+      before.size < 0n ||
+      before.size > BIG_INT(maxBytes) ||
+      (expectedBytes !== undefined && before.size !== BIG_INT(expectedBytes))
+    ) {
+      throw new PluginError('plugin_source_drift', `${path}: expected a bounded regular file.`);
+    }
+    await ownHook(hooks, 'afterStat')?.(absolute);
+    const size = NUMBER(before.size);
+    const bytes = BUFFER_ALLOC_UNSAFE(size);
+    let offset = 0;
+    while (offset < size) {
+      const bytesRead = await readDescriptor(handle, bytes, offset, size - offset, offset);
+      if (bytesRead === 0) {
+        throw new PluginError('plugin_source_drift', `${path}: changed while reading.`);
+      }
+      offset += bytesRead;
+    }
+    const extra = BUFFER_ALLOC_UNSAFE(1);
+    if ((await readDescriptor(handle, extra, 0, 1, size)) !== 0) {
+      throw new PluginError('plugin_source_drift', `${path}: changed while reading.`);
+    }
+    const after = await statDescriptor(handle, { bigint: true });
+    if (after.size !== before.size || after.mtimeNs !== before.mtimeNs || after.ctimeNs !== before.ctimeNs) {
+      throw new PluginError('plugin_source_drift', `${path}: changed while reading.`);
+    }
+    return hostedPromiseValue(bytes);
+  } finally {
+    await closeDescriptor(handle);
+  }
+}
+
+async function openStoredFile(root: string, path: string, hooks: StoredPluginReadTestHooks): Promise<number> {
+  const parts = STRING_SPLIT(path, '/');
+  if (PROCESS_PLATFORM !== 'linux') {
+    for (let i = 1; i < parts.length; i++) {
+      let parent = root;
+      for (let index = 0; index < i; index += 1) parent = PATH_JOIN(parent, parts[index]!);
+      if (!descriptorIsDirectory(await lstatPath(parent))) {
+        throw new PluginError('plugin_source_drift', `${path}: expected a regular file, without symlinks.`);
+      }
+    }
+    await ownHook(hooks, 'beforeOpen')?.(PATH_JOIN(root, path));
+    return await openDescriptor(PATH_JOIN(root, path), READ_FLAGS);
+  }
+  let directory = await openDescriptor(PATH_RESOLVE(root), READ_FLAGS);
+  try {
+    if (!descriptorIsDirectory(await statDescriptor(directory, { bigint: true }))) {
+      throw new PluginError('plugin_source_drift', `${path}: plugin store root is not a directory.`);
+    }
+    for (let index = 0; index < parts.length - 1; index += 1) {
+      const part = parts[index]!;
+      const child = await openDescriptor(`/proc/self/fd/${directory}/${part}`, READ_FLAGS);
+      let adopted = false;
+      try {
+        await ownHook(hooks, 'beforeDirectoryStat')?.();
+        if (!descriptorIsDirectory(await statDescriptor(child, { bigint: true }))) {
+          throw new PluginError('plugin_source_drift', `${path}: expected a regular file, without symlinks.`);
+        }
+        await closeDescriptor(directory);
+        directory = child;
+        adopted = true;
+      } finally {
+        if (!adopted) await closeDescriptor(child);
+      }
+    }
+    await ownHook(hooks, 'beforeOpen')?.(PATH_JOIN(root, path));
+    return await openDescriptor(`/proc/self/fd/${directory}/${parts[parts.length - 1]!}`, READ_FLAGS);
+  } finally {
+    await closeDescriptor(directory);
   }
-  return readFile(join(root, path));
 }
 
 /** Re-hash a materialized plugin and compare with the digest the lockfile recorded. */
-export async function verifyStoredPlugin(directory: string, expectedDigest: string): Promise<void> {
-  const drift = (message: string): never => { throw new PluginError('plugin_source_drift', `${directory}: ${message}`); };
-  let raw: string;
+export async function verifyStoredPlugin(
+  directory: string,
+  expectedDigest: string,
+  hooks: StoredPluginReadTestHooks = EMPTY_STORED_PLUGIN_HOOKS,
+): Promise<void> {
+  await readVerifiedStoredPluginFiles(directory, expectedDigest, hooks);
+}
+
+async function readVerifiedStoredPluginFiles(
+  directory: string,
+  expectedDigest: string,
+  hooks: StoredPluginReadTestHooks,
+): Promise<readonly { path: string; data: Buffer }[]> {
+  const drift = (message: string): never => {
+    throw new PluginError('plugin_source_drift', `${directory}: ${message}`);
+  };
+  let manifest: Buffer;
   try {
-    if (!(await lstat(directory)).isDirectory()) return drift('not a directory');
-    raw = (await regularFile(directory, 'manifest.json')).toString('utf8');
-  } catch (error) { return drift(error instanceof PluginError ? error.message : 'manifest.json is missing'); }
+    if (!descriptorIsDirectory(await lstatPath(directory))) return drift('not a directory');
+    manifest = await regularFile(directory, 'manifest.json', MAX_PLUGIN_MANIFEST_BYTES, undefined, hooks);
+  } catch (error) {
+    return drift(error instanceof PluginError ? error.message : 'manifest.json is missing');
+  }
+  const raw = BUFFER_TO_STRING(manifest, 'utf8');
   if (sha256(raw) !== expectedDigest) return drift('manifest.json digest differs from the lockfile');
-  let entries: { path: string; sha256: string; bytes: number }[];
-  try { entries = JSON.parse(raw); if (!Array.isArray(entries)) throw new Error(); }
-  catch { return drift('manifest.json is not a manifest'); }
-  const paths = new Set<string>();
-  for (const entry of entries) {
-    if (typeof entry?.path !== 'string' || !safePath(entry.path)) return drift('manifest.json lists an invalid path');
+  let entries: JsonValue[];
+  try {
+    const value = snapshotJsonValue(JSON_PARSE(raw), 'stored plugin manifest', {
+      maxBytes: MAX_PLUGIN_MANIFEST_BYTES,
+      maxDepth: 3,
+      maxNodes: 1 + MAX_PLUGIN_FILES * 4,
+    });
+    if (!ARRAY_IS_ARRAY(value)) throw new ERROR();
+    entries = value;
+  } catch {
+    return drift('manifest.json is not a manifest');
+  }
+  if (entries.length > MAX_PLUGIN_FILES) return drift(`manifest.json lists more than ${MAX_PLUGIN_FILES} files`);
+  const paths = new SET<string>();
+  const files = [{ path: 'manifest.json', data: manifest }];
+  let totalBytes = 0;
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index]!;
+    if (
+      typeof entry !== 'object' ||
+      entry === null ||
+      ARRAY_IS_ARRAY(entry)
+    )
+      return drift('manifest.json lists an invalid file');
+    const path = entry.path;
+    const digest = entry.sha256;
+    const bytes = entry.bytes;
+    if (
+      typeof path !== 'string' ||
+      !safePath(path) ||
+      typeof digest !== 'string' ||
+      !REGEXP_TEST(/^[a-f0-9]{64}$/, digest) ||
+      typeof bytes !== 'number' ||
+      !NUMBER_IS_SAFE_INTEGER(bytes) ||
+      bytes < 0 ||
+      bytes > MAX_PLUGIN_FILE_BYTES ||
+      SET_HAS(paths, path)
+    )
+      return drift('manifest.json lists an invalid file');
+    totalBytes += bytes;
+    if (totalBytes > MAX_PLUGIN_TOTAL_BYTES) return drift(`plugin exceeds ${MAX_PLUGIN_TOTAL_BYTES} bytes`);
     let data: Buffer;
-    try { data = await regularFile(directory, entry.path); }
-    catch (error) { return drift(error instanceof PluginError ? error.message : `${entry.path} is missing`); }
-    if (data.length !== entry.bytes || sha256(data) !== entry.sha256) return drift(`${entry.path} changed since installation`);
-    paths.add(entry.path);
+    try {
+      data = await regularFile(directory, path, MAX_PLUGIN_FILE_BYTES, bytes, hooks);
+    } catch (error) {
+      return drift(error instanceof PluginError ? error.message : `${path} is missing`);
+    }
+    if (sha256(data) !== digest) return drift(`${path} changed since installation`);
+    SET_ADD(paths, path);
+    appendIntrinsicArray(files, { path, data });
+  }
+  SET_ADD(paths, 'manifest.json');
+  await rejectExtras(directory, '', paths, drift);
+  const frozen: Readonly<{ path: string; data: Buffer }>[] = [];
+  for (let index = 0; index < files.length; index += 1) {
+    appendIntrinsicArray(frozen, OBJECT_FREEZE(files[index]!));
   }
-  await rejectExtras(directory, '', new Set([...paths, 'manifest.json']), drift);
+  return frozenHostedPromiseValue(frozen);
 }
 
 /** Re-verify, then return every stored file including the payload `manifest.json`. */
-export async function readStoredPluginFiles(directory: string, expectedDigest: string): Promise<readonly { path: string; data: Buffer }[]> {
-  await verifyStoredPlugin(directory, expectedDigest);
-  const manifest = await regularFile(directory, 'manifest.json');
-  const entries = JSON.parse(manifest.toString('utf8')) as { path: string }[];
-  const files = [{ path: 'manifest.json', data: manifest }];
-  for (const entry of entries) files.push({ path: entry.path, data: await regularFile(directory, entry.path) });
-  return files;
+export async function readStoredPluginFiles(
+  directory: string,
+  expectedDigest: string,
+  hooks: StoredPluginReadTestHooks = EMPTY_STORED_PLUGIN_HOOKS,
+): Promise<readonly { path: string; data: Buffer }[]> {
+  return await readVerifiedStoredPluginFiles(directory, expectedDigest, hooks);
+}
+
+function ownHook(
+  hooks: StoredPluginReadTestHooks,
+  name: keyof StoredPluginReadTestHooks,
+): ((...args: unknown[]) => Promise<void>) | undefined {
+  const descriptor = OBJECT_GET_OWN_PROPERTY_DESCRIPTOR(hooks, name);
+  return descriptor !== undefined && 'value' in descriptor && typeof descriptor.value === 'function'
+    ? descriptor.value as (...args: unknown[]) => Promise<void>
+    : undefined;
 }
 
 /** Drop a materialized plugin directory. Missing is a no-op. */
 export async function removeStoredPlugin(directory: string): Promise<void> {
-  await rm(directory, { recursive: true, force: true });
+  await RM(directory, { recursive: true, force: true });
 }
 
-async function rejectExtras(root: string, prefix: string, paths: Set<string>, drift: (m: string) => never): Promise<void> {
-  for (const entry of await readdir(join(root, prefix), { withFileTypes: true })) {
-    const path = prefix + entry.name;
-    if (entry.isDirectory() && [...paths].some(file => file.startsWith(`${path}/`))) await rejectExtras(root, `${path}/`, paths, drift);
-    else if (!entry.isFile() || !paths.has(path)) drift(`${path}: unlisted file or unsupported file type`);
+async function rejectExtras(
+  root: string,
+  prefix: string,
+  paths: Set<string>,
+  drift: (m: string) => never,
+): Promise<void> {
+  let entries = 0;
+  async function visit(currentPrefix: string): Promise<void> {
+    const directory = await openDirectory(PATH_JOIN(root, currentPrefix));
+    try {
+      for (;;) {
+        const entry = await readDirectoryEntry(directory);
+        if (entry === null) break;
+        entries += 1;
+        if (entries > MAX_PLUGIN_STORE_ENTRIES) drift('plugin store contains too many entries');
+        const path = currentPrefix + entry.name;
+        let declaredDescendant = false;
+        SET_FOR_EACH(paths, file => {
+          if (STRING_STARTS_WITH(file, `${path}/`)) declaredDescendant = true;
+        });
+        if (directoryEntryIsDirectory(entry) && declaredDescendant) await visit(`${path}/`);
+        else if (!directoryEntryIsFile(entry) || !SET_HAS(paths, path)) {
+          drift(`${path}: unlisted file or unsupported file type`);
+        }
+      }
+    } finally {
+      await closeDirectory(directory);
+    }
   }
+  await visit(prefix);
 }

package/src/semver-range.ts

@@ -9,19 +9,41 @@
  */
 const VERSION = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
 const RANGE = /^(\*|(?:[\^~]|>=)?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?: <\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)?)$/;
+const MATH_MAX = Math.max;
+const NUMBER = Number;
+const NUMBER_IS_SAFE_INTEGER = Number.isSafeInteger;
+const REGEXP_EXEC = Function.prototype.call.bind(RegExp.prototype.exec) as (
+  regexp: RegExp,
+  value: string,
+) => RegExpExecArray | null;
+const REGEXP_TEST = Function.prototype.call.bind(RegExp.prototype.test) as (
+  regexp: RegExp,
+  value: string,
+) => boolean;
+const STRING_SLICE = Function.prototype.call.bind(String.prototype.slice) as (
+  value: string,
+  start: number,
+  end?: number,
+) => string;
+const STRING_SPLIT = Function.prototype.call.bind(String.prototype.split) as (
+  value: string,
+  separator: string,
+) => string[];
 
 interface Parsed { readonly triple: readonly [number, number, number]; readonly pre?: string }
 
 export function parseVersion(value: string): Parsed | undefined {
-  const m = VERSION.exec(value);
+  const m = REGEXP_EXEC(VERSION, value);
   if (!m) return undefined;
-  const triple = [Number(m[1]), Number(m[2]), Number(m[3])] as const;
-  if (triple.some(n => !Number.isSafeInteger(n))) return undefined;
+  const triple = [NUMBER(m[1]), NUMBER(m[2]), NUMBER(m[3])] as const;
+  for (let index = 0; index < triple.length; index += 1) {
+    if (!NUMBER_IS_SAFE_INTEGER(triple[index])) return undefined;
+  }
   return m[4] === undefined ? { triple } : { triple, pre: m[4] };
 }
 
 export function isVersionRange(value: string): boolean {
-  return RANGE.test(value);
+  return REGEXP_TEST(RANGE, value);
 }
 
 function compare(a: Parsed, b: Parsed): number {
@@ -33,16 +55,16 @@ function compare(a: Parsed, b: Parsed): number {
 }
 
 function comparePrerelease(a: string, b: string): number {
-  const as = a.split('.');
-  const bs = b.split('.');
-  const n = Math.max(as.length, bs.length);
+  const as = STRING_SPLIT(a, '.');
+  const bs = STRING_SPLIT(b, '.');
+  const n = MATH_MAX(as.length, bs.length);
   for (let i = 0; i < n; i++) {
     const left = as[i];
     const right = bs[i];
     if (left === undefined) return -1;
     if (right === undefined) return 1;
-    const leftNum = /^\d+$/.test(left) ? Number(left) : undefined;
-    const rightNum = /^\d+$/.test(right) ? Number(right) : undefined;
+    const leftNum = REGEXP_TEST(/^\d+$/, left) ? NUMBER(left) : undefined;
+    const rightNum = REGEXP_TEST(/^\d+$/, right) ? NUMBER(right) : undefined;
     if (leftNum !== undefined && rightNum !== undefined) {
       if (leftNum !== rightNum) return leftNum - rightNum;
       continue;
@@ -59,15 +81,18 @@ export function satisfiesRange(version: string, range: string): boolean {
   const v = parseVersion(version);
   if (v === undefined || !isVersionRange(range)) return false;
   if (range === '*') return true;
-  const [lowerText, upperText] = range.split(' ') as [string, string | undefined];
-  const operator = /^[\^~]|^>=/.exec(lowerText)?.[0] ?? '';
-  const lower = parseVersion(lowerText.slice(operator.length))!;
+  const parts = STRING_SPLIT(range, ' ');
+  const lowerText = parts[0]!;
+  const upperText = parts[1];
+  const operator = REGEXP_EXEC(/^[\^~]|^>=/, lowerText)?.[0] ?? '';
+  const lower = parseVersion(STRING_SLICE(lowerText, operator.length))!;
   if (compare(v, lower) < 0) return false;
   if (operator === '') return compare(v, lower) === 0;
   let upper: Parsed | undefined;
-  if (upperText !== undefined) upper = parseVersion(upperText.slice(1));
+  if (upperText !== undefined) upper = parseVersion(STRING_SLICE(upperText, 1));
   else if (operator === '^') {
-    const [major, minor] = lower.triple;
+    const major = lower.triple[0];
+    const minor = lower.triple[1];
     upper = major > 0 ? { triple: [major + 1, 0, 0] } : minor > 0 ? { triple: [0, minor + 1, 0] } : { triple: [0, 0, lower.triple[2] + 1] };
   } else if (operator === '~') upper = { triple: [lower.triple[0], lower.triple[1] + 1, 0] };
   return upper === undefined || compare(v, upper) < 0;