@limrun/api 0.39.8 → 0.40.1

package/src/internal/android-basis-cache.ts

@@ -4,13 +4,14 @@ import path from 'path';
 
 import { downloadFileToLocalPath } from './download-file';
 import { nodeProxyTransport } from './proxy-transport';
+import { reconstructSeedFromLocalFiles } from './seed-reconstruct';
 
 export type AndroidSyncState = {
   roots?: Array<{
     rootName?: string;
     files?: Array<{ path?: string; sha256?: string; size?: number; mode?: number }>;
   }>;
-  seeds?: Array<{ sha256?: string; size?: number; name?: string; mtime?: number }>;
+  seeds?: Array<{ sha256?: string; size?: number; mtime?: number }>;
 };
 
 type SyncLog = (level: 'debug' | 'info' | 'warn' | 'error', msg: string) => void;
@@ -85,7 +86,7 @@ export async function bootstrapAndroidBasisCache(
   }
   const seeds = [...(state.seeds ?? [])]
     .filter(
-      (seed): seed is { sha256: string; size?: number; name?: string; mtime?: number } =>
+      (seed): seed is { sha256: string; size?: number; mtime?: number } =>
         typeof seed.sha256 === 'string' && /^[0-9a-f]{64}$/i.test(seed.sha256),
     )
     .sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0));
@@ -93,16 +94,16 @@ export async function bootstrapAndroidBasisCache(
     serverShas.add(seed.sha256.toLowerCase());
   }
 
+  let staleBasisPath: string | undefined;
   if (fs.existsSync(basisPath)) {
     const basisSha = (await sha256FileHex(basisPath)).toLowerCase();
     if (serverShas.has(basisSha)) {
       return;
     }
-    // A delta against a basis this instance doesn't have only earns a needFull
-    // round trip and then a full upload (e.g. a warm cache pointed at a fresh
-    // instance), so drop the stale basis and re-seed below.
+    // Keep the stale basis temporarily: even though the instance cannot use it
+    // directly, many of its blocks may be reusable while reconstructing a seed.
     log('debug', `local basis ${basisSha} unknown to instance; re-seeding basis cache`);
-    await fs.promises.rm(basisPath, { force: true });
+    staleBasisPath = basisPath;
   }
 
   const localSha = (await sha256FileHex(apkPath)).toLowerCase();
@@ -116,16 +117,37 @@ export async function bootstrapAndroidBasisCache(
   }
   const seed = seeds[0];
   if (!seed) {
+    if (staleBasisPath) {
+      await fs.promises.rm(staleBasisPath, { force: true });
+    }
     return;
   }
-  // Announce the download before any bytes flow so consumers can react to the
-  // expected size even during connection setup / time-to-first-byte.
-  onBasisDownloadProgress?.(0, seed.size ?? 0);
-  await downloadFileToLocalPath(
-    buildSyncSeedUrl(apiUrl, seed.sha256),
-    token,
-    basisPath,
-    onBasisDownloadProgress,
-  );
-  log('debug', `seeded Android basis cache from instance seed: ${seed.sha256}`);
+  const seedUrl = buildSyncSeedUrl(apiUrl, seed.sha256);
+  try {
+    const result = await reconstructSeedFromLocalFiles({
+      signatureUrl: `${seedUrl}.sig`,
+      seedUrl,
+      token,
+      sourcePaths: staleBasisPath ? [apkPath, staleBasisPath] : [apkPath],
+      outputPath: basisPath,
+      expectedSha256: seed.sha256,
+      ...(onBasisDownloadProgress ? { onProgress: onBasisDownloadProgress } : {}),
+    });
+    log(
+      'debug',
+      `reconstructed Android basis seed ${seed.sha256}: matched=${result.matchedBlocks} downloaded=${result.downloadedBytes}`,
+    );
+  } catch (err) {
+    log(
+      'debug',
+      `basis seed reconstruction unavailable; downloading full seed: ${
+        err instanceof Error ? err.message : String(err)
+      }`,
+    );
+    // A failed reconstruction never replaces basisPath, so it is safe to
+    // truncate the stale basis in place for the full-download fallback.
+    onBasisDownloadProgress?.(0, seed.size ?? 0);
+    await downloadFileToLocalPath(seedUrl, token, basisPath, onBasisDownloadProgress);
+    log('debug', `seeded Android basis cache from full instance seed: ${seed.sha256}`);
+  }
 }

package/src/internal/seed-reconstruct.ts

@@ -0,0 +1,533 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { Readable } from 'stream';
+
+import { nodeProxyTransport } from './proxy-transport';
+
+const SIGNATURE_VERSION = 1;
+const STRONG_HASH_HEX_LENGTH = 32;
+const SCAN_CHUNK_SIZE = 1024 * 1024;
+const MAX_ALIGNED_MISS_BYTES = 32 * 1024 * 1024;
+const SHA256_PATTERN = /^[0-9a-f]{64}$/i;
+const STRONG_HASH_PATTERN = /^[0-9a-f]{32}$/i;
+
+export type SeedSignatureBlock = {
+  w: number;
+  s: string;
+};
+
+export type SeedSignature = {
+  version: number;
+  blockSize: number;
+  fileSize: number;
+  sha256: string;
+  blocks: SeedSignatureBlock[];
+};
+
+export type SeedBlockMatch = {
+  sourcePath: string;
+  sourceOffset: number;
+};
+
+export type SeedByteRange = {
+  start: number;
+  end: number;
+};
+
+type BlockSpan = {
+  offset: number;
+  length: number;
+};
+
+type SourceFile = {
+  path: string;
+  size: number;
+};
+
+type ReconstructSeedOptions = {
+  signatureUrl: string;
+  seedUrl: string;
+  token: string;
+  sourcePaths: string[];
+  outputPath: string;
+  expectedSha256: string;
+  onProgress?: (downloadedBytes: number, totalBytes: number) => void;
+};
+
+function strongHash(buffer: Uint8Array): string {
+  return crypto.createHash('sha256').update(buffer).digest('hex').slice(0, STRONG_HASH_HEX_LENGTH);
+}
+
+function blockSpan(signature: SeedSignature, index: number): BlockSpan {
+  const offset = index * signature.blockSize;
+  return {
+    offset,
+    length: Math.min(signature.blockSize, signature.fileSize - offset),
+  };
+}
+
+async function sha256FileHex(filePath: string): Promise<string> {
+  return await new Promise((resolve, reject) => {
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath);
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('error', reject);
+    stream.on('end', () => resolve(hash.digest('hex')));
+  });
+}
+
+export function weakRollingChecksum(buffer: Uint8Array): number {
+  let a = 0;
+  let b = 0;
+  for (let i = 0; i < buffer.byteLength; i++) {
+    const value = buffer[i]!;
+    a = (a + value) & 0xffff;
+    b = (b + (buffer.byteLength - i) * value) & 0xffff;
+  }
+  return b * 0x10000 + a;
+}
+
+function validateSignature(value: unknown, expectedSha256: string): SeedSignature {
+  if (!value || typeof value !== 'object') {
+    throw new Error('Invalid seed signature: expected an object');
+  }
+  const candidate = value as Partial<SeedSignature>;
+  if (candidate.version !== SIGNATURE_VERSION) {
+    throw new Error(`Unsupported seed signature version: ${String(candidate.version)}`);
+  }
+  if (!Number.isSafeInteger(candidate.blockSize) || candidate.blockSize! <= 0) {
+    throw new Error('Invalid seed signature blockSize');
+  }
+  if (!Number.isSafeInteger(candidate.fileSize) || candidate.fileSize! < 0) {
+    throw new Error('Invalid seed signature fileSize');
+  }
+  if (
+    typeof candidate.sha256 !== 'string' ||
+    !SHA256_PATTERN.test(candidate.sha256) ||
+    candidate.sha256.toLowerCase() !== expectedSha256.toLowerCase()
+  ) {
+    throw new Error('Seed signature sha256 does not match the requested seed');
+  }
+  if (!Array.isArray(candidate.blocks)) {
+    throw new Error('Invalid seed signature blocks');
+  }
+  const expectedBlocks = Math.ceil(candidate.fileSize! / candidate.blockSize!);
+  if (candidate.blocks.length !== expectedBlocks) {
+    throw new Error(
+      `Invalid seed signature block count: got ${candidate.blocks.length}, expected ${expectedBlocks}`,
+    );
+  }
+  const blocks = candidate.blocks.map((block, index) => {
+    if (
+      !block ||
+      !Number.isInteger(block.w) ||
+      block.w < 0 ||
+      block.w > 0xffffffff ||
+      typeof block.s !== 'string' ||
+      !STRONG_HASH_PATTERN.test(block.s)
+    ) {
+      throw new Error(`Invalid seed signature block at index ${index}`);
+    }
+    return { w: block.w, s: block.s.toLowerCase() };
+  });
+  return {
+    version: candidate.version,
+    blockSize: candidate.blockSize!,
+    fileSize: candidate.fileSize!,
+    sha256: candidate.sha256.toLowerCase(),
+    blocks,
+  };
+}
+
+export async function fetchSeedSignature(
+  signatureUrl: string,
+  token: string,
+  expectedSha256: string,
+): Promise<SeedSignature> {
+  const response = await nodeProxyTransport.fetch(signatureUrl, {
+    method: 'GET',
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Seed signature download failed: ${response.status} ${body}`);
+  }
+  return validateSignature(await response.json(), expectedSha256);
+}
+
+async function readExactly(
+  handle: fs.promises.FileHandle,
+  buffer: Buffer,
+  length: number,
+  position: number,
+): Promise<void> {
+  let offset = 0;
+  while (offset < length) {
+    const { bytesRead } = await handle.read(buffer, offset, length - offset, position + offset);
+    if (bytesRead <= 0) {
+      throw new Error(`Unexpected EOF at offset ${position + offset}`);
+    }
+    offset += bytesRead;
+  }
+}
+
+async function scanSourceForFullBlocks(
+  source: SourceFile,
+  candidatesByWeak: Map<number, number[]>,
+  signature: SeedSignature,
+  matches: Map<number, SeedBlockMatch>,
+  unmatched: Set<number>,
+): Promise<void> {
+  const blockLength = signature.blockSize;
+  const handle = await fs.promises.open(source.path, 'r');
+  try {
+    if (source.size < blockLength || unmatched.size === 0) {
+      return;
+    }
+
+    const ring = Buffer.allocUnsafe(blockLength);
+    await readExactly(handle, ring, blockLength, 0);
+    let a = 0;
+    let b = 0;
+    for (let i = 0; i < blockLength; i++) {
+      const value = ring[i]!;
+      a = (a + value) & 0xffff;
+      b = (b + (blockLength - i) * value) & 0xffff;
+    }
+
+    let ringPosition = 0;
+    let sourceOffset = 0;
+    let candidateBuffer: Buffer | undefined;
+    const confirmCandidate = async (candidateIndexes: number[]) => {
+      candidateBuffer ??= Buffer.allocUnsafe(blockLength);
+      await readExactly(handle, candidateBuffer, blockLength, sourceOffset);
+      const strong = strongHash(candidateBuffer);
+      for (const index of candidateIndexes) {
+        if (unmatched.has(index) && signature.blocks[index]!.s === strong) {
+          matches.set(index, { sourcePath: source.path, sourceOffset });
+          unmatched.delete(index);
+        }
+      }
+    };
+
+    let candidateIndexes = candidatesByWeak.get(b * 0x10000 + a);
+    if (candidateIndexes?.some((index) => unmatched.has(index))) {
+      await confirmCandidate(candidateIndexes);
+    }
+    const incoming = Buffer.allocUnsafe(SCAN_CHUNK_SIZE);
+    let readPosition = blockLength;
+    while (readPosition < source.size && unmatched.size > 0) {
+      const requested = Math.min(incoming.byteLength, source.size - readPosition);
+      const { bytesRead } = await handle.read(incoming, 0, requested, readPosition);
+      if (bytesRead <= 0) {
+        break;
+      }
+      for (let i = 0; i < bytesRead && unmatched.size > 0; i++) {
+        const outgoingValue = ring[ringPosition]!;
+        const incomingValue = incoming[i]!;
+        ring[ringPosition] = incomingValue;
+        ringPosition++;
+        if (ringPosition === blockLength) {
+          ringPosition = 0;
+        }
+        a = (a - outgoingValue + incomingValue) & 0xffff;
+        b = (b - ((blockLength * outgoingValue) & 0xffff) + a) & 0xffff;
+        sourceOffset++;
+        candidateIndexes = candidatesByWeak.get(b * 0x10000 + a);
+        if (candidateIndexes?.some((index) => unmatched.has(index))) {
+          await confirmCandidate(candidateIndexes);
+        }
+      }
+      readPosition += bytesRead;
+    }
+  } finally {
+    await handle.close();
+  }
+}
+
+async function existingSourceFiles(sourcePaths: string[]): Promise<SourceFile[]> {
+  const sources: SourceFile[] = [];
+  for (const sourcePath of sourcePaths) {
+    const stat = await fs.promises.stat(sourcePath).catch(() => undefined);
+    if (stat?.isFile()) {
+      sources.push({ path: sourcePath, size: stat.size });
+    }
+  }
+  return sources;
+}
+
+async function matchAlignedBlocks(
+  sources: SourceFile[],
+  signature: SeedSignature,
+  matches: Map<number, SeedBlockMatch>,
+): Promise<void> {
+  for (const source of sources) {
+    const handle = await fs.promises.open(source.path, 'r');
+    const block = Buffer.allocUnsafe(signature.blockSize);
+    try {
+      for (let index = 0; index < signature.blocks.length; index++) {
+        if (matches.has(index)) {
+          continue;
+        }
+        const span = blockSpan(signature, index);
+        if (span.offset + span.length > source.size) {
+          continue;
+        }
+        await readExactly(handle, block, span.length, span.offset);
+        if (strongHash(block.subarray(0, span.length)) === signature.blocks[index]!.s) {
+          matches.set(index, { sourcePath: source.path, sourceOffset: span.offset });
+        }
+      }
+    } finally {
+      await handle.close();
+    }
+  }
+}
+
+async function matchTrailingPartialBlock(
+  sources: SourceFile[],
+  signature: SeedSignature,
+  matches: Map<number, SeedBlockMatch>,
+): Promise<void> {
+  if (signature.fileSize === 0 || signature.fileSize % signature.blockSize === 0) {
+    return;
+  }
+  const index = signature.blocks.length - 1;
+  if (matches.has(index)) {
+    return;
+  }
+  const span = blockSpan(signature, index);
+  const expectedStrongHash = signature.blocks[index]!.s;
+  const block = Buffer.allocUnsafe(span.length);
+  for (const source of sources) {
+    if (source.size < span.length) {
+      continue;
+    }
+    const sourceOffset = source.size - span.length;
+    if (sourceOffset === span.offset) {
+      continue; // The aligned pass already checked this offset.
+    }
+    const handle = await fs.promises.open(source.path, 'r');
+    try {
+      await readExactly(handle, block, span.length, sourceOffset);
+      if (strongHash(block) === expectedStrongHash) {
+        matches.set(index, { sourcePath: source.path, sourceOffset });
+        return;
+      }
+    } finally {
+      await handle.close();
+    }
+  }
+}
+
+function shouldSkipRollingScan(
+  signature: SeedSignature,
+  matches: ReadonlyMap<number, SeedBlockMatch>,
+): boolean {
+  let missingBytes = 0;
+  for (let index = 0; index < signature.blocks.length; index++) {
+    if (!matches.has(index)) {
+      missingBytes += blockSpan(signature, index).length;
+    }
+  }
+  const matchRatio = signature.blocks.length === 0 ? 1 : matches.size / signature.blocks.length;
+  return matchRatio >= 0.8 && missingBytes <= MAX_ALIGNED_MISS_BYTES;
+}
+
+async function matchShiftedFullBlocks(
+  sources: SourceFile[],
+  signature: SeedSignature,
+  matches: Map<number, SeedBlockMatch>,
+): Promise<void> {
+  const fullBlockCount = Math.floor(signature.fileSize / signature.blockSize);
+  const unmatched = new Set<number>();
+  const candidatesByWeak = new Map<number, number[]>();
+  for (let index = 0; index < fullBlockCount; index++) {
+    if (matches.has(index)) {
+      continue;
+    }
+    unmatched.add(index);
+    const weak = signature.blocks[index]!.w;
+    const candidates = candidatesByWeak.get(weak) ?? [];
+    candidates.push(index);
+    candidatesByWeak.set(weak, candidates);
+  }
+  for (const source of sources) {
+    if (unmatched.size === 0) {
+      return;
+    }
+    await scanSourceForFullBlocks(source, candidatesByWeak, signature, matches, unmatched);
+  }
+}
+
+export async function findSeedBlockMatches(
+  sourcePaths: string[],
+  signature: SeedSignature,
+): Promise<Map<number, SeedBlockMatch>> {
+  const sources = await existingSourceFiles(sourcePaths);
+  const matches = new Map<number, SeedBlockMatch>();
+  await matchAlignedBlocks(sources, signature, matches);
+  await matchTrailingPartialBlock(sources, signature, matches);
+  if (!shouldSkipRollingScan(signature, matches)) {
+    await matchShiftedFullBlocks(sources, signature, matches);
+  }
+  return matches;
+}
+
+export function missingSeedRanges(
+  signature: SeedSignature,
+  matches: ReadonlyMap<number, SeedBlockMatch>,
+): SeedByteRange[] {
+  const ranges: SeedByteRange[] = [];
+  let startBlock: number | undefined;
+  for (let index = 0; index <= signature.blocks.length; index++) {
+    const missing = index < signature.blocks.length && !matches.has(index);
+    if (missing && startBlock === undefined) {
+      startBlock = index;
+    } else if (!missing && startBlock !== undefined) {
+      const first = blockSpan(signature, startBlock);
+      const last = blockSpan(signature, index - 1);
+      ranges.push({
+        start: first.offset,
+        end: last.offset + last.length - 1,
+      });
+      startBlock = undefined;
+    }
+  }
+  return ranges;
+}
+
+async function copyMatchedBlocks(
+  output: fs.promises.FileHandle,
+  signature: SeedSignature,
+  matches: ReadonlyMap<number, SeedBlockMatch>,
+): Promise<void> {
+  const sourceHandles = new Map<string, fs.promises.FileHandle>();
+  try {
+    for (const [index, match] of matches) {
+      let source = sourceHandles.get(match.sourcePath);
+      if (!source) {
+        source = await fs.promises.open(match.sourcePath, 'r');
+        sourceHandles.set(match.sourcePath, source);
+      }
+      const span = blockSpan(signature, index);
+      const block = Buffer.allocUnsafe(span.length);
+      await readExactly(source, block, span.length, match.sourceOffset);
+      await writeExactly(output, block, span.offset);
+    }
+  } finally {
+    await Promise.all([...sourceHandles.values()].map((handle) => handle.close()));
+  }
+}
+
+async function writeExactly(handle: fs.promises.FileHandle, buffer: Buffer, position: number): Promise<void> {
+  let offset = 0;
+  while (offset < buffer.byteLength) {
+    const { bytesWritten } = await handle.write(
+      buffer,
+      offset,
+      buffer.byteLength - offset,
+      position + offset,
+    );
+    if (bytesWritten <= 0) {
+      throw new Error(`Unable to write reconstructed seed at offset ${position + offset}`);
+    }
+    offset += bytesWritten;
+  }
+}
+
+async function downloadRange(
+  seedUrl: string,
+  token: string,
+  range: SeedByteRange,
+  fileSize: number,
+  output: fs.promises.FileHandle,
+  reportBytes: (bytes: number) => void,
+): Promise<void> {
+  const response = await nodeProxyTransport.fetch(seedUrl, {
+    method: 'GET',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Range: `bytes=${range.start}-${range.end}`,
+    },
+  });
+  if (response.status !== 206 || !response.body) {
+    const body = await response.text();
+    throw new Error(`Seed range download failed: ${response.status} ${body}`);
+  }
+  const expectedContentRange = `bytes ${range.start}-${range.end}/${fileSize}`;
+  if (response.headers.get('content-range') !== expectedContentRange) {
+    throw new Error(
+      `Invalid Content-Range for seed: ${response.headers.get('content-range') ?? '<missing>'}`,
+    );
+  }
+
+  const expectedLength = range.end - range.start + 1;
+  let received = 0;
+  const source = Readable.fromWeb(response.body as any);
+  for await (const value of source) {
+    const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value as Uint8Array);
+    if (received + chunk.byteLength > expectedLength) {
+      throw new Error('Seed range response exceeded the requested length');
+    }
+    await writeExactly(output, chunk, range.start + received);
+    received += chunk.byteLength;
+    reportBytes(chunk.byteLength);
+  }
+  if (received !== expectedLength) {
+    throw new Error(`Seed range response was truncated: got ${received}, expected ${expectedLength}`);
+  }
+}
+
+export async function reconstructSeedFromLocalFiles(options: ReconstructSeedOptions): Promise<{
+  downloadedBytes: number;
+  totalDownloadBytes: number;
+  matchedBlocks: number;
+}> {
+  const expectedSha256 = options.expectedSha256.toLowerCase();
+  const signature = await fetchSeedSignature(options.signatureUrl, options.token, expectedSha256);
+  const uniqueSources = [...new Set(options.sourcePaths.map((sourcePath) => path.resolve(sourcePath)))];
+  const matches = await findSeedBlockMatches(uniqueSources, signature);
+  const ranges = missingSeedRanges(signature, matches);
+  const totalDownloadBytes = ranges.reduce((total, range) => total + range.end - range.start + 1, 0);
+  let downloadedBytes = 0;
+  options.onProgress?.(0, totalDownloadBytes);
+
+  await fs.promises.mkdir(path.dirname(options.outputPath), { recursive: true });
+  const temporaryPath = `${options.outputPath}.reconstruct-${process.pid}-${crypto
+    .randomBytes(6)
+    .toString('hex')}`;
+  const output = await fs.promises.open(temporaryPath, 'wx');
+  let outputClosed = false;
+  let installed = false;
+  try {
+    await output.truncate(signature.fileSize);
+    await copyMatchedBlocks(output, signature, matches);
+    for (const range of ranges) {
+      await downloadRange(options.seedUrl, options.token, range, signature.fileSize, output, (bytes) => {
+        downloadedBytes += bytes;
+        options.onProgress?.(downloadedBytes, totalDownloadBytes);
+      });
+    }
+    await output.close();
+    outputClosed = true;
+
+    const actualSha256 = await sha256FileHex(temporaryPath);
+    if (actualSha256 !== expectedSha256) {
+      throw new Error(`Reconstructed seed SHA-256 mismatch: got ${actualSha256}, expected ${expectedSha256}`);
+    }
+    await fs.promises.rm(options.outputPath, { force: true });
+    await fs.promises.rename(temporaryPath, options.outputPath);
+    installed = true;
+  } finally {
+    if (!outputClosed) {
+      await output.close().catch(() => undefined);
+    }
+    if (!installed) {
+      await fs.promises.rm(temporaryPath, { force: true });
+    }
+  }
+
+  return { downloadedBytes, totalDownloadBytes, matchedBlocks: matches.size };
+}

package/src/resources/ios-instances.ts

@@ -170,6 +170,13 @@ export namespace IosInstanceCreateParams {
   export interface Spec {
     clues?: Array<Spec.Clue>;
 
+    /**
+     * Keeps this app in the foreground after it is first observed there. This does not
+     * launch the app when the simulator starts. Once armed, closing or backgrounding
+     * the app causes it to be brought back to the foreground.
+     */
+    forceBundleId?: string;
+
     /**
      * After how many minutes should the instance be terminated. Example values 1m,
      * 10m, 3h. Default is "0" which means no hard timeout.

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.39.8'; // x-release-please-version
+export const VERSION = '0.40.1'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.39.8";
+export declare const VERSION = "0.40.1";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.39.8";
+export declare const VERSION = "0.40.1";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.39.8'; // x-release-please-version
+exports.VERSION = '0.40.1'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.39.8'; // x-release-please-version
+export const VERSION = '0.40.1'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map