@trainstar/synchro-react-native 0.3.2 → 0.4.0-rc.2

package/src/inspection.ts

@@ -2,14 +2,24 @@ import {
   configureInspection,
   nativeForInspection,
   parseClientStateInspection,
+  parseRetainedMutationInspection,
+  parseRetainedRejectionInspection,
   parseTransportObservationSnapshot,
   SynchroClient,
 } from './SynchroClient';
 import { InvalidResponseError, mapNativeError } from './errors';
+import { assertValidSQLiteBindParams } from './sqliteValues';
 import type {
   ClientStateInspection,
+  RetainedMutationInspection,
+  RetainedRejectionInspection,
+  Row,
+  SQLStatement,
   TransportObservationSnapshot,
   TransportOperationClass,
+  MigrationCheckpoint,
+  MigrationJournalInspection,
+  PhysicalSchemaColumnInspection,
 } from './types';
 
 const TRANSPORT_OPERATION_CLASSES: readonly TransportOperationClass[] = [
@@ -45,6 +55,25 @@ export interface DurableStateInspection {
   }>;
 }
 
+/**
+ * One read-only snapshot of client state and retained details. A detail list is
+ * null when its record count exceeds the native capture bound. `applicationRows`
+ * holds the rows that the requested read statements returned inside the snapshot.
+ */
+export interface ClientStateSnapshotInspection {
+  clientState: ClientStateInspection;
+  captureOverflowed: boolean;
+  retainedMutations: RetainedMutationInspection[] | null;
+  rejectedMutations: RetainedRejectionInspection[] | null;
+  applicationRows: Row[];
+  migrationJournal: MigrationJournalInspection | null;
+  migrationJournalTruncated: boolean;
+  physicalSchema: PhysicalSchemaColumnInspection[];
+  physicalSchemaTruncated: boolean;
+  acceptedMutationOutcomes: Record<string, string>;
+  acceptedMutationOutcomesTruncated: boolean;
+}
+
 export interface SynchroInspectionOptions {
   transportObservationCapacity?: number;
   requireNewDatabase?: boolean;
@@ -62,9 +91,29 @@ export class SynchroInspection {
     );
   }
 
-  async clientState(): Promise<ClientStateInspection> {
+  async captureSnapshot(rowStatements: SQLStatement[] = []): Promise<ClientStateSnapshotInspection> {
     try {
-      return parseClientStateInspection(parseJSON(await nativeForInspection(this.client).inspectClientState()));
+      const statements = rowStatements.map((statement) => ({
+        sql: statement.sql,
+        params: assertValidSQLiteBindParams(statement.params ?? []),
+      }));
+      const result = await nativeForInspection(this.client).inspectClientStateSnapshot(statements);
+      const snapshot = requireRecord(parseJSON(result.inspection), 'client state snapshot');
+      const extensions = parseCaptureExtensions(snapshot);
+      const clientState = requireRecord(snapshot.client_state, 'client state');
+      if (typeof clientState.capture_overflowed !== 'boolean') {
+        throw new InvalidResponseError('Native bridge returned invalid capture bound');
+      }
+      return {
+        ...extensions,
+        clientState: parseClientStateInspection(clientState),
+        captureOverflowed: clientState.capture_overflowed,
+        retainedMutations:
+          nullableArray(snapshot.retained_mutations, 'retained mutations')?.map(parseRetainedMutationInspection) ?? null,
+        rejectedMutations:
+          nullableArray(snapshot.rejected_mutations, 'rejected mutations')?.map(parseRetainedRejectionInspection) ?? null,
+        applicationRows: [...result.applicationRows] as Row[],
+      };
     } catch (error) {
       throw mapNativeError(error);
     }
@@ -105,8 +154,8 @@ export class SynchroInspection {
     }
   }
 
-  async armTransportPause(operationClass: TransportOperationClass): Promise<void> {
-    requireTransportOperationClass(operationClass);
+  async armTransportPause(operationClass: TransportOperationClass | MigrationCheckpoint): Promise<void> {
+    requirePauseTarget(operationClass);
     try {
       await nativeForInspection(this.client).armTransportPause(operationClass);
     } catch (error) {
@@ -114,8 +163,8 @@ export class SynchroInspection {
     }
   }
 
-  async awaitTransportPause(operationClass: TransportOperationClass, timeoutMs: number): Promise<void> {
-    requireTransportOperationClass(operationClass);
+  async awaitTransportPause(operationClass: TransportOperationClass | MigrationCheckpoint, timeoutMs: number): Promise<void> {
+    requirePauseTarget(operationClass);
     if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 60_000) {
       throw new InvalidResponseError('Transport pause request is invalid');
     }
@@ -187,6 +236,16 @@ function parseDurableState(value: unknown): DurableStateInspection {
   return proof as unknown as DurableStateInspection;
 }
 
+function nullableArray(value: unknown, name: string): unknown[] | null {
+  if (value === null) {
+    return null;
+  }
+  if (!Array.isArray(value)) {
+    throw new InvalidResponseError(`Native bridge returned invalid ${name}`);
+  }
+  return value;
+}
+
 function requireRecord(value: unknown, name: string): Record<string, unknown> {
   if (typeof value !== 'object' || value === null || Array.isArray(value)) {
     throw new InvalidResponseError(`Native bridge returned invalid ${name}`);
@@ -206,10 +265,77 @@ function isNullableString(value: unknown): value is string | null {
   return value === null || typeof value === 'string';
 }
 
-function requireTransportOperationClass(value: TransportOperationClass): void {
-  if (!TRANSPORT_OPERATION_CLASSES.includes(value)) {
-    throw new InvalidResponseError('Transport operation class is invalid');
+function requirePauseTarget(value: TransportOperationClass | MigrationCheckpoint): void {
+  if (value !== 'migration_prepared' && value !== 'migration_committed' &&
+      !TRANSPORT_OPERATION_CLASSES.includes(value as TransportOperationClass)) {
+    throw new InvalidResponseError('Pause target is invalid');
+  }
+}
+
+function parseCaptureExtensions(snapshot: Record<string, unknown>): Pick<ClientStateSnapshotInspection,
+  'migrationJournal' | 'migrationJournalTruncated' | 'physicalSchema' | 'physicalSchemaTruncated' |
+  'acceptedMutationOutcomes' | 'acceptedMutationOutcomesTruncated'> {
+  if (typeof snapshot.migration_journal_truncated !== 'boolean' ||
+      typeof snapshot.physical_schema_truncated !== 'boolean' || !Array.isArray(snapshot.physical_schema) ||
+      snapshot.physical_schema.length > 512) {
+    throw new InvalidResponseError('Native bridge returned invalid migration capture');
+  }
+  const journal = snapshot.migration_journal;
+  if (journal !== null) {
+    const value = requireRecord(journal, 'migration journal');
+    for (const key of ['source', 'target']) {
+      const schema = requireRecord(value[key], 'migration schema');
+      if (!isNonnegativeSafeInteger(schema.version) || typeof schema.hash !== 'string') {
+        throw new InvalidResponseError('Native bridge returned invalid migration schema');
+      }
+    }
+    const stored = requireRecord(value.stored, 'stored migration bindings');
+    if (typeof value.action !== 'string' || typeof value.phase !== 'string' ||
+        Object.values(stored).some((item) => typeof item !== 'string') ||
+        ['journal_version', 'target_manifest_json', 'affected_scopes_json', 'scope_cursor_updates_json',
+          'migration_plan_version', 'migration_plan_json', 'migration_plan_hash'].some((key) => typeof stored[key] !== 'string')) {
+      throw new InvalidResponseError('Native bridge returned invalid migration journal');
+    }
+  }
+  const physicalSchema = snapshot.physical_schema.map((item) => {
+    const column = requireRecord(item, 'physical schema column');
+    if (typeof column.table_name !== 'string' || typeof column.name !== 'string' || typeof column.type !== 'string' ||
+        typeof column.not_null !== 'boolean' || !isNonnegativeSafeInteger(column.primary_key_position)) {
+      throw new InvalidResponseError('Native bridge returned invalid physical schema column');
+    }
+    return column as unknown as PhysicalSchemaColumnInspection;
+  });
+  if (snapshot.migration_journal_truncated && journal !== null) {
+    throw new InvalidResponseError('Native bridge returned truncated migration details');
+  }
+  const accepted = requireRecord(snapshot.accepted_mutation_outcomes, 'accepted mutation outcomes');
+  const entries = Object.entries(accepted);
+  if (typeof snapshot.accepted_mutation_outcomes_truncated !== 'boolean' || entries.length > 512 ||
+      (snapshot.accepted_mutation_outcomes_truncated && entries.length !== 0)) {
+    throw new InvalidResponseError('Native bridge returned invalid accepted outcome capture');
+  }
+  let acceptedBytes = 0;
+  for (const [id, outcome] of entries) {
+    if (typeof outcome !== 'string') throw new InvalidResponseError('Native bridge returned invalid accepted outcome');
+    for (const text of [id, outcome]) {
+      for (const character of text) {
+        const first = character.charCodeAt(0);
+        if (character.length === 1 && first >= 0xd800 && first <= 0xdfff) {
+          throw new InvalidResponseError('Native bridge returned invalid accepted outcome encoding');
+        }
+        acceptedBytes += character.length === 2 ? 4 : first <= 0x7f ? 1 : first <= 0x7ff ? 2 : 3;
+        if (acceptedBytes > 65_536) throw new InvalidResponseError('Native bridge returned oversized accepted outcomes');
+      }
+    }
   }
+  return {
+    migrationJournal: journal as MigrationJournalInspection | null,
+    migrationJournalTruncated: snapshot.migration_journal_truncated,
+    physicalSchema,
+    physicalSchemaTruncated: snapshot.physical_schema_truncated,
+    acceptedMutationOutcomes: accepted as Record<string, string>,
+    acceptedMutationOutcomesTruncated: snapshot.accepted_mutation_outcomes_truncated,
+  };
 }
 
 export { sha256Hex } from './digest';
@@ -223,4 +349,7 @@ export type {
   TransportObservation,
   TransportObservationSnapshot,
   TransportOperationClass,
+  MigrationCheckpoint,
+  MigrationJournalInspection,
+  PhysicalSchemaColumnInspection,
 } from './types';

package/src/types.ts

@@ -186,7 +186,8 @@ export type MutationRejectionCode =
   | 'schema_incompatible'
   | 'policy_rejected'
   | 'validation_failed'
-  | 'table_not_synced';
+  | 'table_not_synced'
+  | 'atomic_batch_rejected';
 
 export interface SchemaRef {
   version: number;
@@ -199,6 +200,7 @@ export interface AuthoredMutationField {
   value: JSONValue;
 }
 
+/** A retained mutation with its complete ledger binding and authored values. */
 export interface PendingMutationInspection {
   mutationID: string;
   localOrder: number;
@@ -220,6 +222,29 @@ export interface PendingMutationInspection {
   authoredFields: AuthoredMutationField[];
 }
 
+/**
+ * A retained mutation that a queue from before the mutation ledger imported.
+ * It has only the fields that the old queue stored.
+ */
+export interface LegacyMutationInspection {
+  representation: 'legacy';
+  mutationID: string;
+  localOrder: number;
+  tableName: string;
+  recordID: string;
+  operation: MutationOperation;
+  baseVersion: string | null;
+  clientVersion: string;
+  status: LocalMutationStatus;
+  sourceKind: string;
+}
+
+/** One retained mutation in its stored representation. */
+export type RetainedMutationInspection =
+  | (PendingMutationInspection & { representation: 'current' })
+  | LegacyMutationInspection;
+
+/** A retained rejection with its exact mutation and rejection JSON. */
 export interface RejectedMutationInspection {
   mutationID: string;
   tableName: string;
@@ -235,6 +260,29 @@ export interface RejectedMutationInspection {
   updatedAt: string;
 }
 
+/**
+ * A retained rejection that a database from before the mutation ledger stored.
+ * It has only the fields that the old rejection table stored.
+ */
+export interface LegacyRejectionInspection {
+  representation: 'legacy';
+  mutationID: string;
+  tableName: string;
+  recordID: string;
+  status: MutationStatus;
+  code: MutationRejectionCode;
+  message: string | null;
+  serverRowJSON: string | null;
+  serverVersion: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/** One retained rejection in its stored representation. */
+export type RetainedRejectionInspection =
+  | (RejectedMutationInspection & { representation: 'current' })
+  | LegacyRejectionInspection;
+
 export interface ScopeStateInspection {
   scopeID: string;
   cursor: string | null;
@@ -281,6 +329,24 @@ export interface ClientStateInspection {
   provenanceMaintenanceWorkCursor: string;
 }
 
+export type MigrationCheckpoint = 'migration_prepared' | 'migration_committed';
+
+export interface MigrationJournalInspection {
+  source: SchemaRef;
+  target: SchemaRef;
+  action: string;
+  phase: string;
+  stored: Record<string, string>;
+}
+
+export interface PhysicalSchemaColumnInspection {
+  table_name: string;
+  name: string;
+  type: string;
+  not_null: boolean;
+  primary_key_position: number;
+}
+
 export type TransportOperationClass =
   | 'connect'
   | 'pull'
@@ -294,12 +360,15 @@ export interface TransportObservation {
   sequence: number;
   operationClass: TransportOperationClass;
   statusCode: number;
+  errorCode?: string;
+  retryable?: boolean;
   durationNanoseconds: number;
   cursorFingerprints?: string[];
   cursorFingerprintsComplete?: boolean;
   requestFacts?: Record<string, JSONValue>;
   rebuildResponseFacts?: Record<string, JSONValue>;
   pullResponseFacts?: Record<string, JSONValue>;
+  connectResponseFacts?: Record<string, JSONValue>;
 }
 
 export interface TransportObservationSnapshot {

package/tooling-patches/apply.cjs

@@ -0,0 +1,163 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const {spawnSync} = require('child_process');
+
+const appRoot = fs.realpathSync(process.cwd());
+
+const repairs = {
+  cli: [{
+    caller: '@react-native-community/cli-platform-android',
+    callerVersion: '20.2.0',
+    packageName: '@react-native-community/cli-config-android',
+    version: '20.2.0',
+    patch: 'cli-config-android-20.2.0.patch',
+    sources: [{
+      path: 'build/config/findComponentDescriptors.js',
+      preimage: '2cfe70a25818c4cd61fc8c122602f5363b8d57ffc1cf8c153f26fe68f1b8f047',
+      postimage: '75ace921b876fb1164e2b80dda9045bfebf2972b9465da992bba5758452add94'
+    }]
+  }, {
+    caller: '@react-native-community/cli',
+    callerVersion: '20.2.0',
+    packageName: '@react-native-community/cli-clean',
+    version: '20.2.0',
+    patch: 'cli-clean-20.2.0.patch',
+    sources: [{
+      path: 'build/clean.js',
+      preimage: 'f46f188859df1d616676d5cb246ed0b96b8f5e71868c5df914d31830acdde4be',
+      postimage: '9aea3a5112e0432ec78f5716d91ceac56d35e2b24eb5c45f4f28d254b9eaf9c2'
+    }]
+  }],
+  'stream-json': [{
+    caller: 'bunyamin',
+    callerVersion: '1.6.3',
+    packageName: 'stream-json',
+    version: '1.9.1',
+    patch: 'stream-json-1.9.1.patch',
+    sources: [{
+      path: 'Assembler.js',
+      preimage: 'a341b21d86a9c005e5433eadb6c33d4708d611c8bc624ee383463c0fb6d2e32b',
+      postimage: '51bf2168f777c8c7285dd521c32f0de636f363efc9baa80dbfb140fa55372203'
+    }]
+  }],
+  bob: [{
+    caller: 'react-native-builder-bob',
+    callerVersion: '0.40.18',
+    packageName: 'react-native-builder-bob',
+    version: '0.40.18',
+    patch: 'react-native-builder-bob-0.40.18.patch',
+    sources: [{
+      path: 'lib/targets/module.js',
+      preimage: '1ef8ee20f2767347348e86de7f421358b7705623ae04a9b952fabc61f365ede6',
+      postimage: '16686f186b97a7a83fa6fc761db191a623d0f5697acb45b8df907e343c7629fa'
+    }, {
+      path: 'lib/targets/typescript.js',
+      preimage: '451fe8050e20bc1c4724564b2c33fb819f815848f5ad2eb529be5915bf62f2bb',
+      postimage: 'd22c16e9d4ebe97b15a3b734b70e1060a5526b907cad2b1ec3bb1004d4ed0675'
+    }]
+  }]
+};
+
+function fail(message) {
+  throw new Error(`Synchro tooling patch: ${message}`);
+}
+
+function resolvedPackageRoot(request, paths) {
+  const packageJson = require.resolve(`${request}/package.json`, {paths});
+  return fs.realpathSync(path.dirname(packageJson));
+}
+
+function assertInsideInstall(target) {
+  const relative = path.relative(appRoot, target);
+  if (relative === '' || relative.startsWith('..') || path.isAbsolute(relative)) {
+    fail('resolved target is outside the caller installation');
+  }
+  if (!relative.split(path.sep).includes('node_modules')) {
+    fail('resolved target is not in node_modules');
+  }
+}
+
+function packageIdentity(packageRoot, expectedName, expectedVersion) {
+  const manifest = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+  if (manifest.name !== expectedName) {
+    fail('unexpected package identity');
+  }
+  if (manifest.version !== expectedVersion) {
+    fail('unexpected package version');
+  }
+}
+
+function hashFile(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function callerRoot(repair) {
+  if (repair.caller === 'bunyamin') {
+    const entry = require.resolve('bunyamin', {paths: [appRoot]});
+    let directory = path.dirname(fs.realpathSync(entry));
+    while (directory !== path.dirname(directory)) {
+      const manifest = path.join(directory, 'package.json');
+      if (fs.existsSync(manifest) && JSON.parse(fs.readFileSync(manifest, 'utf8')).name === 'bunyamin') {
+        return directory;
+      }
+      directory = path.dirname(directory);
+    }
+    fail('could not locate the resolved bunyamin package root');
+  }
+  return resolvedPackageRoot(repair.caller, [appRoot]);
+}
+
+function targetRoot(repair, caller) {
+  if (repair.caller === 'bunyamin') {
+    const source = require.resolve('stream-json/Assembler.js', {paths: [caller]});
+    return fs.realpathSync(path.dirname(source));
+  }
+  return resolvedPackageRoot(repair.packageName, [caller]);
+}
+
+function applyRepair(repair) {
+  const caller = callerRoot(repair);
+  assertInsideInstall(caller);
+  packageIdentity(caller, repair.caller, repair.callerVersion);
+  const target = targetRoot(repair, caller);
+  assertInsideInstall(target);
+  packageIdentity(target, repair.packageName, repair.version);
+  const sources = repair.sources.map(source => {
+    const file = path.join(target, source.path);
+    if (!fs.existsSync(file) || fs.realpathSync(file) !== file) {
+      fail('unexpected or missing source target');
+    }
+    return {file, source};
+  });
+  if (sources.every(({file, source}) => hashFile(file) === source.postimage)) {
+    process.stdout.write(`${repair.packageName} ${repair.version} already has the verified patch\n`);
+    return;
+  }
+  if (!sources.every(({file, source}) => hashFile(file) === source.preimage)) {
+    fail('unexpected source hash');
+  }
+  const patchFile = path.join(__dirname, repair.patch);
+  const result = spawnSync('patch', ['--batch', '--forward', '--fuzz=0', '-p1', '-d', target], {
+    input: fs.readFileSync(patchFile),
+    encoding: 'utf8',
+    stdio: ['pipe', 'inherit', 'inherit']
+  });
+  if (result.error || result.status !== 0) {
+    fail('patch command failed');
+  }
+  if (!sources.every(({file, source}) => hashFile(file) === source.postimage)) {
+    fail('postimage verification failed');
+  }
+  process.stdout.write(`applied verified ${repair.packageName} ${repair.version} patch\n`);
+}
+
+const name = process.argv[2] || 'cli';
+if (!Object.prototype.hasOwnProperty.call(repairs, name)) {
+  fail('unsupported repair');
+}
+for (const repair of repairs[name]) {
+  applyRepair(repair);
+}

package/tooling-patches/cli-clean-20.2.0.patch

@@ -0,0 +1,21 @@
+diff --git a/build/clean.js b/build/clean.js
+index 0cad23b..942fb42 100644
+--- a/build/clean.js
++++ b/build/clean.js
+@@ -157,13 +157,13 @@ async function clean(_argv, ctx, cleanOptions) {
+       description: 'Metro, haste-map caches',
+       tasks: [{
+         label: 'Clean Metro cache',
+-        action: () => cleanDir(`${_os().default.tmpdir()}/metro-*`)
++        action: () => cleanDir(`${_fastGlob().default.convertPathToPattern(_os().default.tmpdir())}/metro-*`)
+       }, {
+         label: 'Clean Haste cache',
+-        action: () => cleanDir(`${_os().default.tmpdir()}/haste-map-*`)
++        action: () => cleanDir(`${_fastGlob().default.convertPathToPattern(_os().default.tmpdir())}/haste-map-*`)
+       }, {
+         label: 'Clean React Native cache',
+-        action: () => cleanDir(`${_os().default.tmpdir()}/react-*`)
++        action: () => cleanDir(`${_fastGlob().default.convertPathToPattern(_os().default.tmpdir())}/react-*`)
+       }]
+     },
+     bun: {

package/tooling-patches/cli-config-android-20.2.0.patch

@@ -0,0 +1,13 @@
+diff --git a/build/config/findComponentDescriptors.js b/build/config/findComponentDescriptors.js
+index 36fdb7c..4e857d0 100644
+--- a/build/config/findComponentDescriptors.js
++++ b/build/config/findComponentDescriptors.js
+@@ -42,7 +42,7 @@ function findComponentDescriptors(packageRoot) {
+   } catch (error) {
+     // no jsSrcsDir, continue with default glob pattern
+   }
+-  const globPattern = jsSrcsDir ? `${jsSrcsDir}/**/*{.js,.jsx,.ts,.tsx}` : '**/*{.js,.jsx,.ts,.tsx}';
++  const globPattern = jsSrcsDir ? `${_fastGlob().default.convertPathToPattern(jsSrcsDir)}/**/*{.js,.jsx,.ts,.tsx}` : '**/*{.js,.jsx,.ts,.tsx}';
+   const files = _fastGlob().default.sync(globPattern, {
+     cwd: (0, _cliTools().unixifyPaths)(packageRoot),
+     onlyFiles: true,

package/tooling-patches/react-native-builder-bob-0.40.18.patch

@@ -0,0 +1,74 @@
+diff --git a/lib/targets/module.js b/lib/targets/module.js
+--- a/lib/targets/module.js
++++ b/lib/targets/module.js
+@@ -6,7 +6,7 @@
+ exports.default = build;
+ var _path = _interopRequireDefault(require("path"));
+ var _kleur = _interopRequireDefault(require("kleur"));
+-var _del = _interopRequireDefault(require("del"));
++var _fsExtra = _interopRequireDefault(require("fs-extra"));
+ var _compile = _interopRequireDefault(require("../utils/compile"));
+ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+ async function build({
+@@ -19,7 +19,11 @@
+   report
+ }) {
+   report.info(`Cleaning up previous build at ${_kleur.default.blue(_path.default.relative(root, output))}`);
+-  await (0, _del.default)([output]);
++  const outputRelative = _path.default.relative(process.cwd(), output);
++  if (outputRelative === '' || outputRelative === '..' || outputRelative.startsWith(`..${_path.default.sep}`) || _path.default.isAbsolute(outputRelative)) {
++    throw new Error('Refusing to remove build output outside the current working directory.');
++  }
++  await _fsExtra.default.remove(output);
+   await (0, _compile.default)({
+     ...options,
+     variants,
+diff --git a/lib/targets/typescript.js b/lib/targets/typescript.js
+--- a/lib/targets/typescript.js
++++ b/lib/targets/typescript.js
+@@ -4,7 +4,6 @@
+   value: true
+ });
+ exports.default = build;
+-var _del = _interopRequireDefault(require("del"));
+ var _fsExtra = _interopRequireDefault(require("fs-extra"));
+ var _json = _interopRequireDefault(require("json5"));
+ var _kleur = _interopRequireDefault(require("kleur"));
+@@ -23,7 +22,11 @@
+   esm
+ }) {
+   report.info(`Cleaning up previous build at ${_kleur.default.blue(_path.default.relative(root, output))}`);
+-  await (0, _del.default)([output]);
++  const outputRelative = _path.default.relative(process.cwd(), output);
++  if (outputRelative === '' || outputRelative === '..' || outputRelative.startsWith(`..${_path.default.sep}`) || _path.default.isAbsolute(outputRelative)) {
++    throw new Error('Refusing to remove build output outside the current working directory.');
++  }
++  await _fsExtra.default.remove(output);
+   report.info(`Generating type definitions with ${_kleur.default.blue('tsc')}`);
+   const project = options?.project ? options.project : 'tsconfig.json';
+   const tsconfig = _path.default.join(root, project);
+@@ -101,8 +104,12 @@
+       throw new Error('Neither commonjs nor module output is enabled.');
+     }
+     const tsbuildinfo = _path.default.join(outDir, project.replace(/\.json$/, '.tsbuildinfo'));
++    const buildInfoRelative = _path.default.relative(process.cwd(), tsbuildinfo);
++    const tsbuildinfoIsOwned = buildInfoRelative !== '' && buildInfoRelative !== '..' && !buildInfoRelative.startsWith(`..${_path.default.sep}`) && !_path.default.isAbsolute(buildInfoRelative);
+     try {
+-      await (0, _del.default)([tsbuildinfo]);
++      if (tsbuildinfoIsOwned) {
++        await _fsExtra.default.remove(tsbuildinfo);
++      }
+     } catch (e) {
+       // Ignore
+     }
+@@ -110,7 +117,9 @@
+       cwd: root
+     });
+     try {
+-      await (0, _del.default)([tsbuildinfo]);
++      if (tsbuildinfoIsOwned) {
++        await _fsExtra.default.remove(tsbuildinfo);
++      }
+     } catch (e) {
+       // Ignore
+     }

package/tooling-patches/stream-json-1.9.1.patch

@@ -0,0 +1,40 @@
+diff --git a/Assembler.js b/Assembler.js
+index 2a8bda9..3a0aace 100644
+--- a/Assembler.js
++++ b/Assembler.js
+@@ -120,7 +120,16 @@ class Assembler extends EventEmitter {
+       if (this.current instanceof Array) {
+         this.current.push(value);
+       } else {
+-        this.current[this.key] = value;
++        if (this.key === '__proto__') {
++          Object.defineProperty(this.current, this.key, {
++            value,
++            writable: true,
++            enumerable: true,
++            configurable: true
++          });
++        } else {
++          this.current[this.key] = value;
++        }
+         this.key = null;
+       }
+     }
+@@ -138,7 +147,16 @@ class Assembler extends EventEmitter {
+       } else {
+         value = this.reviver(this.key, value);
+         if (value !== undefined) {
+-          this.current[this.key] = value;
++          if (this.key === '__proto__') {
++            Object.defineProperty(this.current, this.key, {
++              value,
++              writable: true,
++              enumerable: true,
++              configurable: true
++            });
++          } else {
++            this.current[this.key] = value;
++          }
+         }
+         this.key = null;
+       }