@limrun/api 0.47.2 → 0.48.0

package/src/destination-tunnel.ts

@@ -0,0 +1,354 @@
+import net from 'net';
+
+export const DESTINATION_TUNNEL_VERSION = 1;
+export const DESTINATION_TUNNEL_MAX_ROUTES = 10;
+export const DESTINATION_TUNNEL_CONN_ID_HEADER_BYTES = 4;
+
+export interface DestinationTunnelRoute {
+  host: string;
+  port: number;
+}
+
+export type DestinationTunnelOpenFailureReason =
+  | 'dns_not_found'
+  | 'dns_temporary_failure'
+  | 'connection_refused'
+  | 'connection_reset'
+  | 'connection_timed_out'
+  | 'unreachable'
+  | 'permission_denied'
+  | 'resource_exhausted'
+  | 'route_not_allowed'
+  | 'cancelled'
+  | 'internal'
+  | (string & {});
+
+export type DestinationTunnelResetReason =
+  | 'cancelled'
+  | 'connection_error'
+  | 'protocol_error'
+  | 'resource_exhausted'
+  | 'internal'
+  | (string & {});
+
+export type DestinationTunnelSessionErrorCode =
+  | 'unsupported_version'
+  | 'invalid_message'
+  | 'invalid_route'
+  | 'route_capacity'
+  | 'already_active'
+  | 'unavailable'
+  | 'internal'
+  | (string & {});
+
+export type DestinationTunnelClientMessage =
+  | { type: 'start'; version: number; routes: DestinationTunnelRoute[] }
+  | { type: 'openOk'; connId: number }
+  | {
+      type: 'openFail';
+      connId: number;
+      reason: DestinationTunnelOpenFailureReason;
+      osCode?: string;
+    }
+  | { type: 'fin'; connId: number }
+  | { type: 'reset'; connId: number; reason: DestinationTunnelResetReason; osCode?: string };
+
+export type DestinationTunnelServerMessage =
+  | { type: 'ready'; version: number; tunnelId: string }
+  | {
+      type: 'open';
+      connId: number;
+      routeId: string;
+      host: string;
+      port: number;
+      proto: 'tcp';
+    }
+  | { type: 'fin'; connId: number }
+  | { type: 'reset'; connId: number; reason: DestinationTunnelResetReason; osCode?: string }
+  | { type: 'error'; code: DestinationTunnelSessionErrorCode };
+
+export type DestinationTunnelRouteErrorCode =
+  | 'empty'
+  | 'too_many'
+  | 'invalid_host'
+  | 'invalid_port'
+  | 'duplicate';
+
+export class DestinationTunnelRouteError extends Error {
+  constructor(
+    readonly code: DestinationTunnelRouteErrorCode,
+    message: string,
+  ) {
+    super(message);
+    this.name = 'DestinationTunnelRouteError';
+  }
+}
+
+export class DestinationTunnelProtocolError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'DestinationTunnelProtocolError';
+  }
+}
+
+export function encodeDestinationTunnelDataFrame(connId: number, payload: Buffer): Buffer {
+  validateConnectionId(connId);
+  if (payload.length === 0) {
+    throw new DestinationTunnelProtocolError('tunnel data frame must include a payload');
+  }
+  const frame = Buffer.allocUnsafe(DESTINATION_TUNNEL_CONN_ID_HEADER_BYTES + payload.length);
+  frame.writeUInt32BE(connId, 0);
+  payload.copy(frame, DESTINATION_TUNNEL_CONN_ID_HEADER_BYTES);
+  return frame;
+}
+
+export function decodeDestinationTunnelDataFrame(frame: Buffer): {
+  connId: number;
+  payload: Buffer;
+} {
+  if (frame.length <= DESTINATION_TUNNEL_CONN_ID_HEADER_BYTES) {
+    throw new DestinationTunnelProtocolError('tunnel data frame must include a payload');
+  }
+  return {
+    connId: frame.readUInt32BE(0),
+    payload: frame.subarray(DESTINATION_TUNNEL_CONN_ID_HEADER_BYTES),
+  };
+}
+
+export function validateDestinationTunnelRoutes(
+  routes: readonly DestinationTunnelRoute[],
+): DestinationTunnelRoute[] {
+  if (routes.length === 0) {
+    throw new DestinationTunnelRouteError('empty', 'at least one tunnel route is required');
+  }
+  if (routes.length > DESTINATION_TUNNEL_MAX_ROUTES) {
+    throw new DestinationTunnelRouteError(
+      'too_many',
+      `at most ${DESTINATION_TUNNEL_MAX_ROUTES} tunnel routes are allowed`,
+    );
+  }
+
+  const canonicalRoutes: DestinationTunnelRoute[] = [];
+  const seen = new Set<string>();
+  for (const route of routes) {
+    const canonical = canonicalizeDestinationTunnelRoute(route);
+    const key = `${canonical.host}\0${canonical.port}`;
+    if (seen.has(key)) {
+      throw new DestinationTunnelRouteError(
+        'duplicate',
+        `duplicate tunnel route ${canonical.host}:${canonical.port}`,
+      );
+    }
+    seen.add(key);
+    canonicalRoutes.push(canonical);
+  }
+  return canonicalRoutes;
+}
+
+export function assertDestinationTunnelOpenAllowed(
+  message: Extract<DestinationTunnelServerMessage, { type: 'open' }>,
+  routes: readonly DestinationTunnelRoute[],
+): void {
+  const index = parseRouteId(message.routeId);
+  const route = routes[index];
+  if (!route || message.host !== route.host || message.port !== route.port || message.proto !== 'tcp') {
+    throw new DestinationTunnelProtocolError(
+      `server requested undeclared route ${message.routeId} ${message.host}:${message.port}/${message.proto}`,
+    );
+  }
+}
+
+export function assertDestinationTunnelReady(
+  message: Extract<DestinationTunnelServerMessage, { type: 'ready' }>,
+): void {
+  if (message.version !== DESTINATION_TUNNEL_VERSION) {
+    throw new DestinationTunnelProtocolError(`unsupported tunnel version ${message.version}`);
+  }
+}
+
+export function encodeDestinationTunnelClientMessage(message: DestinationTunnelClientMessage): string {
+  const record = readRecord(message, 'tunnel control message');
+  const type = readString(record, 'type');
+
+  switch (type) {
+    case 'start': {
+      const version = readInteger(record, 'version');
+      if (version !== DESTINATION_TUNNEL_VERSION) {
+        throw new DestinationTunnelProtocolError(`unsupported tunnel version ${version}`);
+      }
+      const routes = validateDestinationTunnelRoutes(readArray(record, 'routes').map(readRoute));
+      return JSON.stringify({ type, version, routes });
+    }
+    case 'openOk':
+    case 'fin':
+      return JSON.stringify({ type, connId: readConnectionId(record) });
+    case 'openFail':
+    case 'reset':
+      return JSON.stringify({
+        type,
+        connId: readConnectionId(record),
+        reason: readString(record, 'reason'),
+        ...readOptionalString(record, 'osCode'),
+      });
+    default:
+      throw new DestinationTunnelProtocolError(`unknown tunnel control message type ${type}`);
+  }
+}
+
+export function decodeDestinationTunnelServerMessage(value: unknown): DestinationTunnelServerMessage {
+  const message = readRecord(value, 'tunnel control message');
+  const type = readString(message, 'type');
+
+  switch (type) {
+    case 'ready':
+      return {
+        type,
+        version: readInteger(message, 'version'),
+        tunnelId: readString(message, 'tunnelId'),
+      };
+    case 'open':
+      return {
+        type,
+        connId: readConnectionId(message),
+        routeId: readString(message, 'routeId'),
+        host: readString(message, 'host'),
+        port: readPort(message, 'port'),
+        proto: readTCP(message),
+      };
+    case 'fin':
+      return { type, connId: readConnectionId(message) };
+    case 'reset':
+      return {
+        type,
+        connId: readConnectionId(message),
+        reason: readString(message, 'reason'),
+        ...readOptionalString(message, 'osCode'),
+      };
+    case 'error':
+      return { type, code: readString(message, 'code') };
+    default:
+      throw new DestinationTunnelProtocolError(`unknown tunnel control message type ${type}`);
+  }
+}
+
+function canonicalizeDestinationTunnelRoute(route: DestinationTunnelRoute): DestinationTunnelRoute {
+  if (!Number.isInteger(route.port) || route.port < 1 || route.port > 65_535 || route.port === 53) {
+    throw new DestinationTunnelRouteError('invalid_port', `invalid tunnel route port ${route.port}`);
+  }
+
+  const asciiHost = Buffer.byteLength(route.host, 'utf8') === route.host.length;
+  if (asciiHost && route.host.toLowerCase() === 'localhost') {
+    return { host: 'localhost', port: route.port };
+  }
+
+  const ipVersion = net.isIP(route.host);
+  if (ipVersion === 4) {
+    return { host: route.host, port: route.port };
+  }
+  if (ipVersion === 6) {
+    const hostname = new URL(`http://[${route.host}]/`).hostname;
+    const canonical = hostname.slice(1, -1);
+    if (canonical !== '::1' && /^::(?:[0-9a-f]{1,4}:)?[0-9a-f]{1,4}$/.test(canonical)) {
+      throw new DestinationTunnelRouteError('invalid_host', `invalid tunnel route host ${route.host}`);
+    }
+    return { host: canonicalizeIPv6(canonical), port: route.port };
+  }
+
+  throw new DestinationTunnelRouteError('invalid_host', `invalid tunnel route host ${route.host}`);
+}
+
+function canonicalizeIPv6(host: string): string {
+  const mappedIPv4 = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(host);
+  if (!mappedIPv4?.[1] || !mappedIPv4[2]) {
+    return host;
+  }
+  const high = Number.parseInt(mappedIPv4[1], 16);
+  const low = Number.parseInt(mappedIPv4[2], 16);
+  return `${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`;
+}
+
+function parseRouteId(routeId: string): number {
+  const match = /^route-([1-9]\d*)$/.exec(routeId);
+  if (!match?.[1]) {
+    return -1;
+  }
+  return Number(match[1]) - 1;
+}
+
+function readRoute(value: unknown): DestinationTunnelRoute {
+  const route = readRecord(value, 'tunnel route');
+  return {
+    host: readString(route, 'host'),
+    port: readPort(route, 'port'),
+  };
+}
+
+function readRecord(value: unknown, name: string): Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    throw new DestinationTunnelProtocolError(`${name} must be an object`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function readArray(record: Record<string, unknown>, key: string): unknown[] {
+  const value = record[key];
+  if (!Array.isArray(value)) {
+    throw new DestinationTunnelProtocolError(`${key} must be an array`);
+  }
+  return value;
+}
+
+function readString(record: Record<string, unknown>, key: string): string {
+  const value = record[key];
+  if (typeof value !== 'string') {
+    throw new DestinationTunnelProtocolError(`${key} must be a string`);
+  }
+  return value;
+}
+
+function readOptionalString(record: Record<string, unknown>, key: string): { [K in typeof key]?: string } {
+  const value = record[key];
+  if (value === undefined) {
+    return {};
+  }
+  if (typeof value !== 'string') {
+    throw new DestinationTunnelProtocolError(`${key} must be a string`);
+  }
+  return { [key]: value };
+}
+
+function readInteger(record: Record<string, unknown>, key: string): number {
+  const value = record[key];
+  if (!Number.isInteger(value)) {
+    throw new DestinationTunnelProtocolError(`${key} must be an integer`);
+  }
+  return value as number;
+}
+
+function readPort(record: Record<string, unknown>, key: string): number {
+  const value = readInteger(record, key);
+  if (value < 1 || value > 65_535) {
+    throw new DestinationTunnelProtocolError(`${key} must be between 1 and 65535`);
+  }
+  return value;
+}
+
+function readConnectionId(record: Record<string, unknown>): number {
+  const value = readInteger(record, 'connId');
+  validateConnectionId(value);
+  return value;
+}
+
+function validateConnectionId(value: number): void {
+  if (!Number.isInteger(value) || value < 0 || value > 0xffff_ffff) {
+    throw new DestinationTunnelProtocolError('connId must be an unsigned 32-bit integer');
+  }
+}
+
+function readTCP(record: Record<string, unknown>): 'tcp' {
+  const value = readString(record, 'proto');
+  if (value !== 'tcp') {
+    throw new DestinationTunnelProtocolError(`unsupported tunnel transport ${value}`);
+  }
+  return value;
+}

package/src/internal/destination-tunnel-management.ts

@@ -0,0 +1,154 @@
+import { nodeProxyTransport } from './proxy-transport';
+import { deriveDestinationTunnelStatusURL, deriveDestinationTunnelStopURL } from './destination-tunnel-url';
+import { validateDestinationTunnelRoutes, type DestinationTunnelRoute } from '../destination-tunnel';
+
+export interface DestinationTunnelStatus {
+  active?: {
+    tunnelId: string;
+    state: 'starting' | 'ready' | 'stopping';
+    routes: DestinationTunnelRoute[];
+  };
+  lastFailure?: {
+    tunnelId: string;
+    code: string;
+  };
+  lastDialFailure?: {
+    tunnelId: string;
+    connectionId: number;
+    routeId: string;
+    reason: string;
+    osCode?: string;
+  };
+}
+
+export async function getDestinationTunnelStatus(
+  apiUrl: string,
+  token: string,
+): Promise<DestinationTunnelStatus> {
+  const response = await nodeProxyTransport.fetch(deriveDestinationTunnelStatusURL(apiUrl).toString(), {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  if (!response.ok) {
+    throw new Error(`getTunnelStatus failed: ${response.status} ${await response.text()}`);
+  }
+  return decodeDestinationTunnelStatus(await response.json());
+}
+
+export async function stopDestinationTunnel(apiUrl: string, token: string, tunnelId: string): Promise<void> {
+  if (!tunnelId.trim()) {
+    throw new Error('tunnelId must not be empty');
+  }
+  const response = await nodeProxyTransport.fetch(
+    deriveDestinationTunnelStopURL(apiUrl, tunnelId).toString(),
+    {
+      method: 'DELETE',
+      headers: { Authorization: `Bearer ${token}` },
+    },
+  );
+  if (!response.ok) {
+    throw new Error(`stopTunnel failed: ${response.status} ${await response.text()}`);
+  }
+}
+
+export function decodeDestinationTunnelStatus(value: unknown): DestinationTunnelStatus {
+  const status = readRecord(value, 'tunnel status');
+  const decodedStatus: DestinationTunnelStatus = {};
+  if (status['active'] !== undefined) {
+    decodedStatus.active = readActiveTunnel(status['active']);
+  }
+  if (status['lastFailure'] !== undefined) {
+    decodedStatus.lastFailure = readTunnelFailure(status['lastFailure']);
+  }
+  if (status['lastDialFailure'] !== undefined) {
+    decodedStatus.lastDialFailure = readTunnelDialFailure(status['lastDialFailure']);
+  }
+  return decodedStatus;
+}
+
+function readActiveTunnel(value: unknown): NonNullable<DestinationTunnelStatus['active']> {
+  const active = readRecord(value, 'active tunnel');
+  const state = readString(active, 'state');
+  if (state !== 'starting' && state !== 'ready' && state !== 'stopping') {
+    throw new Error(`invalid tunnel state ${state}`);
+  }
+  return {
+    tunnelId: readNonEmptyString(active, 'tunnelId'),
+    state,
+    routes: validateDestinationTunnelRoutes(readArray(active, 'routes').map(readTunnelRoute)),
+  };
+}
+
+function readTunnelRoute(value: unknown): DestinationTunnelRoute {
+  const route = readRecord(value, 'tunnel route');
+  const port = route['port'];
+  if (typeof port !== 'number' || !Number.isInteger(port) || port < 1 || port > 65_535) {
+    throw new Error('tunnel route port must be an integer from 1 to 65535');
+  }
+  return {
+    host: readNonEmptyString(route, 'host'),
+    port,
+  };
+}
+
+function readTunnelFailure(value: unknown): NonNullable<DestinationTunnelStatus['lastFailure']> {
+  const failure = readRecord(value, 'tunnel failure');
+  return {
+    tunnelId: readNonEmptyString(failure, 'tunnelId'),
+    code: readNonEmptyString(failure, 'code'),
+  };
+}
+
+function readTunnelDialFailure(value: unknown): NonNullable<DestinationTunnelStatus['lastDialFailure']> {
+  const failure = readRecord(value, 'tunnel dial failure');
+  const connectionId = failure['connectionId'];
+  if (
+    typeof connectionId !== 'number' ||
+    !Number.isInteger(connectionId) ||
+    connectionId < 0 ||
+    connectionId > 0xffff_ffff
+  ) {
+    throw new Error('tunnel dial failure connectionId must be an unsigned 32-bit integer');
+  }
+  const osCode = failure['osCode'];
+  if (osCode !== undefined && typeof osCode !== 'string') {
+    throw new Error('tunnel dial failure osCode must be a string');
+  }
+  return {
+    tunnelId: readNonEmptyString(failure, 'tunnelId'),
+    connectionId,
+    routeId: readNonEmptyString(failure, 'routeId'),
+    reason: readNonEmptyString(failure, 'reason'),
+    ...(osCode === undefined ? {} : { osCode }),
+  };
+}
+
+function readRecord(value: unknown, name: string): Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    throw new Error(`${name} must be an object`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function readArray(record: Record<string, unknown>, key: string): unknown[] {
+  const value = record[key];
+  if (!Array.isArray(value)) {
+    throw new Error(`${key} must be an array`);
+  }
+  return value;
+}
+
+function readString(record: Record<string, unknown>, key: string): string {
+  const value = record[key];
+  if (typeof value !== 'string') {
+    throw new Error(`${key} must be a string`);
+  }
+  return value;
+}
+
+function readNonEmptyString(record: Record<string, unknown>, key: string): string {
+  const value = readString(record, key);
+  if (value.length === 0) {
+    throw new Error(`${key} must not be empty`);
+  }
+  return value;
+}

package/src/internal/destination-tunnel-url.ts

@@ -0,0 +1,25 @@
+function deriveDestinationTunnelEndpointURL(apiUrl: string, suffix?: string): URL {
+  const url = new URL(apiUrl);
+  if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+    throw new Error(`Unsupported apiUrl protocol for tunnel: ${url.protocol}`);
+  }
+  const tunnelPath = `${url.pathname.replace(/\/+$/, '')}/tunnel`;
+  url.pathname = suffix === undefined ? tunnelPath : `${tunnelPath}/${suffix}`;
+  url.search = '';
+  url.hash = '';
+  return url;
+}
+
+export function deriveDestinationTunnelURL(apiUrl: string): string {
+  const url = deriveDestinationTunnelEndpointURL(apiUrl);
+  url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+  return url.toString();
+}
+
+export function deriveDestinationTunnelStatusURL(apiUrl: string): URL {
+  return deriveDestinationTunnelEndpointURL(apiUrl, 'status');
+}
+
+export function deriveDestinationTunnelStopURL(apiUrl: string, tunnelId: string): URL {
+  return deriveDestinationTunnelEndpointURL(apiUrl, encodeURIComponent(tunnelId));
+}

package/src/ios-client.ts

@@ -5,12 +5,20 @@ import fs from 'fs';
 import { WebSocket, Data } from 'ws';
 import { EventEmitter } from 'events';
 import { assertPort, isNonRetryableError, startReverseTcpTunnel, type ReverseTunnel } from './tunnel';
+import { startDestinationTcpTunnel, type DestinationTcpTunnel } from './destination-tunnel-dialer';
+import type { DestinationTunnelRoute } from './destination-tunnel';
 import { type SyncFolderResult, type FolderSyncOptions, syncFolder } from './folder-sync';
 import { createIgnoreFn } from './folder-sync-ignore';
 import { prepareAppBundlePath, watchAppArchive } from './app-archive';
 import { downloadFileToLocalPath } from './internal/download-file';
 import { sleep } from './internal/utils/sleep';
 import { nodeProxyTransport } from './internal/proxy-transport';
+import {
+  getDestinationTunnelStatus,
+  stopDestinationTunnel,
+  type DestinationTunnelStatus,
+} from './internal/destination-tunnel-management';
+import { deriveDestinationTunnelURL } from './internal/destination-tunnel-url';
 import {
   startHttpProxy as startLocalHttpProxy,
   startForwardHttpProxy as startLocalForwardHttpProxy,
@@ -55,6 +63,14 @@ export function deriveReverseTunnelUrl(apiUrl: string, remotePort: number): stri
 }
 
 export type { ReverseTunnel } from './tunnel';
+export type Tunnel = DestinationTcpTunnel;
+export type TunnelOptions = {
+  /** Exact localhost or literal-IP TCP destinations that the server may ask this client to dial. */
+  routes: DestinationTunnelRoute[];
+  /** Controls tunnel logging verbosity. Defaults to the instance client's log level. */
+  logLevel?: LogLevel;
+};
+export type TunnelStatus = DestinationTunnelStatus;
 
 /**
  * Events emitted by a simctl execution
@@ -855,6 +871,20 @@ export type InstanceClient = {
    */
   startReverseTunnel: (options: ReverseTunnelOptions) => Promise<ReverseTunnel>;
 
+  /**
+   * Transparently route declared simulator TCP destinations through this machine.
+   *
+   * The caller owns the returned tunnel and must close it. Disconnecting this
+   * instance client does not close the tunnel.
+   */
+  startTunnel: (options: TunnelOptions) => Promise<Tunnel>;
+
+  /** Get the active destination tunnel and most recent terminal failure. */
+  getTunnelStatus: () => Promise<TunnelStatus>;
+
+  /** Stop the active tunnel only when its ID matches `tunnelId`. */
+  stopTunnel: (tunnelId: string) => Promise<void>;
+
   /**
    * Start a local HTTP proxy to a port exposed by the iOS instance.
    *
@@ -2035,6 +2065,9 @@ export async function createInstanceClient(options: InstanceClientOptions): Prom
             discoverStoreKitConfig,
             softReset,
             startReverseTunnel,
+            startTunnel,
+            getTunnelStatus,
+            stopTunnel,
             startHttpProxy,
             startForwardHttpProxy,
             disconnect,
@@ -2823,6 +2856,21 @@ export async function createInstanceClient(options: InstanceClientOptions): Prom
       });
     };
 
+    const startTunnel = async (tunnelOptions: TunnelOptions): Promise<Tunnel> => {
+      return startDestinationTcpTunnel(deriveDestinationTunnelURL(options.apiUrl), options.token, {
+        routes: tunnelOptions.routes,
+        logLevel: tunnelOptions.logLevel ?? logLevel,
+      });
+    };
+
+    const getTunnelStatus = async (): Promise<TunnelStatus> => {
+      return getDestinationTunnelStatus(options.apiUrl, options.token);
+    };
+
+    const stopTunnel = async (tunnelId: string): Promise<void> => {
+      await stopDestinationTunnel(options.apiUrl, options.token, tunnelId);
+    };
+
     const startHttpProxy = async (proxyOptions: HttpProxyOptions): Promise<number> => {
       assertPort(proxyOptions.localPort, 'localPort', 1, 65535);
 

package/src/resources/android-instances.ts

@@ -228,7 +228,7 @@ export namespace AndroidInstanceCreateParams {
       clientIp?: string;
 
       /**
-       * The major version of Android, e.g. "13", "14" or "15".
+       * The major version of Android, e.g. "14" or "15".
        */
       osVersion?: string;
     }

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.47.2'; // x-release-please-version
+export const VERSION = '0.48.0'; // x-release-please-version

package/version.d.mts

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

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.47.2";
+export declare const VERSION = "0.48.0";
 //# 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.47.2'; // x-release-please-version
+exports.VERSION = '0.48.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

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