diff --git a/packages/vscode/AGENTS.md b/packages/vscode/AGENTS.md index 23f7c6e..44e2c88 100644 --- a/packages/vscode/AGENTS.md +++ b/packages/vscode/AGENTS.md @@ -7,7 +7,7 @@ One extension replacing the standalone `rstack.rslint` and `rstack.rstest` exten - `stacks/lint` and `stacks/test` are deliberate near-verbatim copies of the upstream extensions, kept close to upstream so changes can be synced by diffing. Do NOT deduplicate or refactor across the two stacks — the duplication is the point; consolidation is a later, explicit phase. - The copies diverge from upstream in exactly thirteen ways (the "adaptations" below). When syncing upstream, preserve them. A fourteenth divergence is either a bug or must be added to this list. - **Tracked upstream state.** `stacks/lint` tracks web-infra-dev/rslint `packages/vscode-extension` at **e5d76242** (0.9.3); `stacks/test` tracks web-infra-dev/rstest `packages/vscode` at **e1607861** (post-0.12.2 main). Additional ports: Rslint **84f9c9b5** trace wording and **72cd2b1f** fixAll waits; Rstest **988f8e1d** per-bundle license notices, with explicit native-binding inclusion and no network license-text replenishment. We replace upstream's plugin-host failure toast with status (adaptations 4/7). Diff `CoreResolver.ts`, `RuntimeManager.ts`, `WorkspaceDocumentRouter.ts`, and `Rslint.ts` on future syncs. The rstest#1888 IPC port uses default JSON instead of advanced serialization: values must survive a JSON round-trip, and both `createBirpc` calls spread `rpcErrorCodec` (`stacks/test/shared/rpc.ts`) to preserve thrown errors. Failed-project retry and worker cleanup remain ahead of upstream. -- **Ahead of upstream — offer these back when syncing** (bug fixes, not adaptations): (1) `RuntimeManager.reconcile` resolves the document's core **before** sweeping pending uses (`planDocumentCore`), so a reconcile landing on the key a pending start is already producing adopts that start instead of tearing it down mid-`initialize` — the teardown made vscode-languageclient force-notify ("couldn't create connection to server") whenever the register-time pass, a detection change and `didOpen` landed inside one worker startup window (`tests/stacks/lint/runtimeManager.test.ts`). (2) `Rslint.close()` gives a still-Starting language client a bounded chance to settle before tearing down its transport, so a legitimate mid-start close (document closed during start, core key changed) stops cleanly instead of triggering the same force-notified toasts. (3) The registry-harness E2E gives its never-settling startup operation 500ms to begin and accepts only the in-flight timeout message, so a stalled runner cannot satisfy the assertion through the already-expired path (`e2e/lint/suite/registry-harness.test.ts`). (4) `Project.retryFailedConfig()` keeps a failed Rstest project and retries its config evaluation in place with one single-flight promise, so repeated dependency-change passes neither overlap workers nor repeat an unchanged not-installed warning. (5) `RuntimeManager` retires a stopped client even when its resolved key is unchanged. The existing closing barrier and pending-use adoption share one replacement across documents; running and starting clients remain untouched (`tests/stacks/lint/runtimeManager.test.ts`). (6) The lint E2E runner (`e2e/lint/runSuite.ts`) gives Mocha a 120s default timeout instead of 2000ms, so hooks doing real workspace I/O (the router suite's `suiteSetup`) do not time out on Windows CI runners. +- **Ahead of upstream — offer these back when syncing** (bug fixes, not adaptations): (1) `RuntimeManager.reconcile` resolves the document's core **before** sweeping pending uses (`planDocumentCore`), so a reconcile landing on the key a pending start is already producing adopts that start instead of tearing it down mid-`initialize` — the teardown made vscode-languageclient force-notify ("couldn't create connection to server") whenever the register-time pass, a detection change and `didOpen` landed inside one worker startup window (`tests/stacks/lint/runtimeManager.test.ts`). (2) `Rslint.close()` gives a still-Starting language client a bounded chance to settle before tearing down its transport, so a legitimate mid-start close (document closed during start, core key changed) stops cleanly instead of triggering the same force-notified toasts. (3) The registry-harness E2E gives its never-settling startup operation 500ms to begin and accepts only the in-flight timeout message, so a stalled runner cannot satisfy the assertion through the already-expired path (`e2e/lint/suite/registry-harness.test.ts`). (4) `Project.retryFailedConfig()` keeps a failed Rstest project and retries its config evaluation in place with one single-flight promise, so repeated dependency-change passes neither overlap workers nor repeat an unchanged not-installed warning. (5) `RuntimeManager` retires a stopped client even when its resolved key is unchanged. The existing closing barrier and pending-use adoption share one replacement across documents; running and starting clients remain untouched (`tests/stacks/lint/runtimeManager.test.ts`). (6) The lint E2E runner (`e2e/lint/runSuite.ts`) gives Mocha a 120s default timeout instead of 2000ms, so hooks doing real workspace I/O (the router suite's `suiteSetup`) do not time out on Windows CI runners. (7) The test worker's `ProgressReporter` (`stacks/test/worker/reporter.ts`) defers suite-result deliveries into a per-testPath queue and flushes them (in emission order) just before the file result posts, because @rstest/core 0.12.6's sink paces case-result deliveries against the extension host's round-trip but fires suite delivery immediately — an `afterAll` failure can fire while a case emitted before it is still queued inside core, and on a loaded host it then reached `run.failed` ahead of that case (macOS E2E `progress.test.ts` flipped `failedMessages[2]`). Core fans the file result out after its case chain drained, so the flush point is the one moment every preceding case result is known-delivered; `onTestRunEnd` flushes leftovers and a new attempt's `onTestFileStart`/`onTestFileReady` drops the previous attempt's queue. Upstream 1.0 fixed this at the sink level (`runnerEventSink` joins all file-scoped deliveries before `onTestFileResult`, #1875); offer that back (or this) upstream for the 0.12 line when syncing. The ported `workerReporter` unit test drops its suite-result ack assertion accordingly. ## The thirteen adaptations diff --git a/packages/vscode/package.json b/packages/vscode/package.json index c5a00fc..976e39b 100644 --- a/packages/vscode/package.json +++ b/packages/vscode/package.json @@ -436,7 +436,7 @@ "@rslint/core": "^0.10.0", "@rstackjs/load-config": "^1.0.2", "@rstest/core": "^0.12.6", - "@swc-next/parser": "^0.4.1", + "@swc-next/parser": "^0.5.0", "@types/istanbul-lib-report": "^3.0.3", "@types/mocha": "^10.0.10", "@types/node": "^26.6.6", diff --git a/packages/vscode/src/stacks/test/parserTest.ts b/packages/vscode/src/stacks/test/parserTest.ts index f23f9e1..c006ade 100644 --- a/packages/vscode/src/stacks/test/parserTest.ts +++ b/packages/vscode/src/stacks/test/parserTest.ts @@ -25,10 +25,13 @@ export const parseTestFile = ( ): (() => void) | void; }, ) => { + // errorRecovery keeps 0.4.x behavior: return diagnostics in `result` + // instead of throwing (the 0.5.0 default throws a plain diagnostic object). const result = parseSync(code, { lang: 'tsx', preserveParens: false, sourceType: 'module', + errorRecovery: true, }); const error = result.diagnostics.find( (diagnostic) => diagnostic.severity === 'error', diff --git a/packages/vscode/src/stacks/test/worker/reporter.ts b/packages/vscode/src/stacks/test/worker/reporter.ts index b3ed719..3a9cdbb 100644 --- a/packages/vscode/src/stacks/test/worker/reporter.ts +++ b/packages/vscode/src/stacks/test/worker/reporter.ts @@ -19,20 +19,105 @@ import { masterApi } from '.'; export class ProgressReporter implements Reporter { readonly flushOutputStreams = false; - onTestRunStart = () => masterApi.onTestRunStart(); - onTestRunEnd = () => masterApi.onTestRunEnd(); - onTestFileStart = (test: TestFileInfo) => masterApi.onTestFileStart(test); - onTestFileReady = (test: TestFileInfo) => masterApi.onTestFileReady(test); - onTestFileResult = (test: TestFileResult) => masterApi.onTestFileResult(test); + // Suite results post through the same extension-host round-trip as case + // results, but @rstest/core 0.12.6 only paces case-result deliveries (its + // `createRunnerEventSink` chains each case's fanout behind the previous + // delivery) and fires a suite delivery as soon as the runner hook returns. + // A suite hook failure (an `afterAll` throw) therefore fires while a case + // emitted before it may still be queued inside core, not yet handed to us; + // on a slow extension host that suite failure can then post ahead of the + // pending case failures of the same file, and the editor publishes + // `run.failed` in arrival order — the exact macOS CI flip in + // `e2e/rstest/suite/progress.test.ts`. + // + // Core cannot tell us what is still queued, and its `onTestFileResult` + // waits for the case chain before fanning out, so every case result has + // been delivered by file-result time. So suites are deferred per testPath + // and flushed (in emission order) just before the file result posts: the + // master always sees [cases..., suites..., file] — runner emission order — + // at any extension-host speed. `onTestRunEnd` flushes leftovers so a torn- + // down attempt never loses queued results; a new attempt's + // `onTestFileStart`/`onTestFileReady` (core re-runs a file only after a + // worker SIGKILL retry) drops a previous attempt's queue. This mirrors + // upstream 1.0's `runnerEventSink` (`joinHooks` before + // `onTestFileResult`, #1875); our pinned 0.12.6 joins case deliveries + // only. Offer this back upstream for the 0.12 line. + private pendingSuiteResults = new Map(); + + private async flushSuiteResults(testPath: string): Promise { + const queue = this.pendingSuiteResults.get(testPath); + if (!queue) return Promise.resolve(); + // Drop the queue first: a suite result arriving during the flush belongs + // to a new emission sequence and starts a fresh queue instead of being + // re-flushed by this loop. + this.pendingSuiteResults.delete(testPath); + await sequentially(queue, (result) => masterApi.onTestCaseResult(result)); + } + + onTestRunStart = () => { + // Earlier runs flushed by now or were torn down mid-flight; a fresh run + // must not inherit their queues (the master's TestRunReporter resets its + // per-run caches the same way). + this.pendingSuiteResults.clear(); + return masterApi.onTestRunStart(); + }; + onTestRunEnd = async () => { + // Fallback for a file result that never came: flush in queue-arrival + // order (a crashed attempt may hold suites) before the run closes, so + // nothing queued is silently dropped. Snapshot the keys so a queue + // re-added during a flush (a late suite arrival) starts its own pass. + for (const testPath of [...this.pendingSuiteResults.keys()]) { + await this.flushSuiteResults(testPath); + } + return masterApi.onTestRunEnd(); + }; + onTestFileStart = (test: TestFileInfo) => { + // New attempt boundary: the previous attempt's queued suite results + // belong to a discarded run and must not leak into this one. + this.pendingSuiteResults.delete(test.testPath); + return masterApi.onTestFileStart(test); + }; + onTestFileReady = (test: TestFileInfo) => { + this.pendingSuiteResults.delete(test.testPath); + return masterApi.onTestFileReady(test); + }; + onTestFileResult = async (test: TestFileResult) => { + // Core drained its case chain by now (for this testPath), so every case + // result precedes the flushed suites and the file result. + await this.flushSuiteResults(test.testPath); + return masterApi.onTestFileResult(test); + }; onTestSuiteStart = (test: TestSuiteInfo) => masterApi.onTestSuiteStart(test); - // TestRunReporter delegates suite results to this async method without - // returning its promise, so call it directly to preserve acknowledgement. - onTestSuiteResult = (result: TestResult) => - masterApi.onTestCaseResult(result); + onTestSuiteResult = (result: TestResult) => { + // Queue instead of posting; delivery happens with the file result. + // Returns immediately, so the returned promise no longer acknowledges + // the extension host's handling of this result (upstream's ported unit + // test is adapted accordingly in + // `tests/stacks/test/workerReporter.test.ts`). + let queue = this.pendingSuiteResults.get(result.testPath); + if (!queue) { + queue = []; + this.pendingSuiteResults.set(result.testPath, queue); + } + queue.push(result); + }; onTestCaseStart = (test: TestCaseInfo) => masterApi.onTestCaseStart(test); + // Case results stay awaitable master requests: core's delivery chain (and + // the file-result join) settles per delivery, so the extension-host ack is + // what paces the next case's posting path. onTestCaseResult = (result: TestResult) => masterApi.onTestCaseResult(result); } +const sequentially = (items: T[], step: (item: T) => Promise) => { + let chain: Promise = Promise.resolve(); + for (const item of items) { + // A step's rejection (a torn-down transport) must not break the queue: + // the step's own caller already handles reporting; keep flushing. + chain = chain.then(() => step(item).catch(() => {})); + } + return chain; +}; + export class ProgressLogger { outputStream = new Writable({ decodeStrings: false, diff --git a/packages/vscode/tests/stacks/test/workerReporter.test.ts b/packages/vscode/tests/stacks/test/workerReporter.test.ts index 4b2c99e..ecaa224 100644 --- a/packages/vscode/tests/stacks/test/workerReporter.test.ts +++ b/packages/vscode/tests/stacks/test/workerReporter.test.ts @@ -1,43 +1,208 @@ -import { expect, it, rs } from '@rstest/core'; +import { beforeEach, expect, it, rs } from '@rstest/core'; import { ProgressReporter } from '../../../src/stacks/test/worker/reporter'; -let resultAcknowledgement = Promise.withResolvers(); +type MasterCall = { method: string; name: string }; +const masterCalls: MasterCall[] = []; +let pendingAcks: { resolve(): void }[] = []; +beforeEach(() => { + pendingAcks = []; + masterCalls.length = 0; +}); + +// Result callbacks (`onTestCaseResult`, `onTestFileResult`, which the worker +// flushes queued suite results through, and `onTestRunEnd`) stay master +// requests: each call registers an ack the test settles on demand. +// Everything else is fire-and-forget, so its mock resolves immediately. rs.mock('../../../src/stacks/test/worker', () => { - const acknowledged = () => resultAcknowledgement.promise; - const event = Object.assign(acknowledged, { asEvent: async () => {} }); const immediate = Object.assign(async () => {}, { asEvent: async () => {} }); + const eventFor = (method: string) => + Object.assign( + (...args: unknown[]) => { + const payload = (args[0] ?? {}) as { name?: string }; + masterCalls.push({ method, name: payload.name ?? '' }); + const ack = Promise.withResolvers(); + pendingAcks.push(ack); + return ack.promise; + }, + { asEvent: async () => {} }, + ); return { masterApi: { onTestRunStart: immediate, - onTestRunEnd: immediate, + onTestRunEnd: eventFor('onTestRunEnd'), onTestFileStart: immediate, onTestFileReady: immediate, - onTestFileResult: event, + onTestFileResult: eventFor('onTestFileResult'), onTestSuiteStart: immediate, onTestSuiteResult: immediate, onTestCaseStart: immediate, - onTestCaseResult: event, + onTestCaseResult: eventFor('onTestCaseResult'), }, }; }); +// Resolves the most recently registered acknowledgement. `pendingAcks` keeps +// only unresolved acks; a call's ack is added synchronously with the call, +// so later helper hangs surface as a test timeout, not a length confusion. +const settleLastAck = (): void => { + const ack = pendingAcks.pop(); + if (!ack) throw new Error('no pending acknowledgement'); + ack.resolve(); +}; + +// Lets the reporter's queue/flush machinery issue its pending master calls; +// a chain hop must land before the next call is visible or settle-able. +const flushTicks = async (): Promise => { + await Promise.resolve(); + await Promise.resolve(); + await Promise.resolve(); +}; + +const call = (method: string, name: string): MasterCall => ({ method, name }); +const FILE = '/fixtures/workspace-1/test/progress.test.ts'; + +// Ported from upstream `rstest/packages/vscode/tests/unit/workerReporter.test.ts`. +// +// Adaptation: upstream also asserted `onTestSuiteResult` waits for the +// extension host's acknowledgement. Our reporter defers suite deliveries to +// the file result to keep suite hook errors ordered after the pending case +// results of the same file (`worker/reporter.ts`), so a suite result no +// longer contacts the master on arrival; its acknowledgement is the file +// result's flush instead. The case/file assertions below stay upstream's. it('waits for result callbacks to finish in the extension host', async () => { const reporter = new ProgressReporter(); for (const report of [ () => reporter.onTestCaseResult({} as any), - () => reporter.onTestSuiteResult({} as any), () => reporter.onTestFileResult({} as any), ]) { - resultAcknowledgement = Promise.withResolvers(); + const before = masterCalls.length; let settled = false; const reporting = report().then(() => { settled = true; }); - await Promise.resolve(); + await flushTicks(); expect(settled).toBe(false); - resultAcknowledgement.resolve(); + expect(masterCalls.length).toBe(before + 1); + settleLastAck(); await reporting; expect(settled).toBe(true); } }); + +// Models the pinned @rstest/core's worker-side pacing (`createRunnerEventSink` +// in 0.12.6): core hands our reporter one case result only after the previous +// delivery's extension-host acknowledgement, while a suite result fires as +// soon as the runner hook returns — which can happen while a case emitted +// before it is still queued inside core, not yet handed to us. The suite +// failure must not overtake the pending case results at the master: suite +// deliveries defer to the file result, which core fans out after its case +// chain drained. (Fails against the previous fix's `caseResultChain`, which +// only saw deliveries already handed to us.) +it('delivers queued suite results after every pending case of the file', async () => { + const reporter = new ProgressReporter(); + const caseOne = { testPath: FILE, name: 'should mismatch number' } as any; + const caseTwo = { + testPath: FILE, + name: 'should mismatch inline snapshot', + } as any; + const suiteResult = { testPath: FILE, name: 's1' } as any; + + // Case one reaches us; the extension host is slow to answer. + const caseOneDelivered = reporter.onTestCaseResult(caseOne); + // The suite result fires while case one is still pending — core cannot + // have handed us case two yet (it arrives only after case one's ack). + reporter.onTestSuiteResult(suiteResult); + + // Against an arrival-order delivery this is where the suite result would + // already have been posted. + expect(masterCalls).toEqual([ + call('onTestCaseResult', 'should mismatch number'), + ]); + expect(pendingAcks).toHaveLength(1); + + settleLastAck(); + await caseOneDelivered; + const caseTwoDelivered = reporter.onTestCaseResult(caseTwo); + expect(masterCalls).toEqual([ + call('onTestCaseResult', 'should mismatch number'), + call('onTestCaseResult', 'should mismatch inline snapshot'), + ]); + + settleLastAck(); + await caseTwoDelivered; + // The file result fans out after core's case chain drained; it flushes the + // queued suite result first, then posts the file result itself. + const fileResultDelivered = reporter.onTestFileResult({ + testPath: FILE, + name: '', + results: [], + } as any); + await flushTicks(); + expect(masterCalls).toEqual([ + call('onTestCaseResult', 'should mismatch number'), + call('onTestCaseResult', 'should mismatch inline snapshot'), + call('onTestCaseResult', 's1'), + ]); + + settleLastAck(); + await flushTicks(); + expect(masterCalls).toEqual([ + call('onTestCaseResult', 'should mismatch number'), + call('onTestCaseResult', 'should mismatch inline snapshot'), + call('onTestCaseResult', 's1'), + call('onTestFileResult', ''), + ]); + + settleLastAck(); + await fileResultDelivered; + expect(pendingAcks).toHaveLength(0); +}); + +// A file result that never comes (worker torn down mid-run) must still +// surface its queued suite failures before the run closes. +it('flushes a leftover queue at run end', async () => { + const reporter = new ProgressReporter(); + + reporter.onTestSuiteResult({ testPath: FILE, name: 's1' } as any); + expect(masterCalls).toEqual([]); + + const runEnd = reporter.onTestRunEnd(); + await flushTicks(); + expect(masterCalls).toEqual([call('onTestCaseResult', 's1')]); + + settleLastAck(); + await flushTicks(); + expect(masterCalls).toEqual([ + call('onTestCaseResult', 's1'), + call('onTestRunEnd', ''), + ]); + + settleLastAck(); + await runEnd; + expect(pendingAcks).toHaveLength(0); +}); + +// A new attempt (core only re-runs a file after a worker SIGKILL retry) +// drops the previous attempt's queued suite results instead of leaking them +// into the re-run. +it('drops a queue taken over by a new attempt', async () => { + const reporter = new ProgressReporter(); + + reporter.onTestSuiteResult({ testPath: FILE, name: 's1' } as any); + reporter.onTestFileStart({ testPath: FILE } as any); + + const fileResultDelivered = reporter.onTestFileResult({ + testPath: FILE, + name: '', + results: [], + } as any); + await flushTicks(); + // No flush call happened: the queue was dropped with the old attempt. + expect(masterCalls).toEqual([call('onTestFileResult', '')]); + expect(pendingAcks).toHaveLength(1); + + settleLastAck(); + await fileResultDelivered; + expect(pendingAcks).toHaveLength(0); +}); diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 34fe2bd..e3e2074 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -33,8 +33,8 @@ importers: specifier: ^0.12.6 version: 0.12.6 '@swc-next/parser': - specifier: ^0.4.1 - version: 0.4.1 + specifier: ^0.5.0 + version: 0.5.0 '@types/istanbul-lib-report': specifier: ^3.0.3 version: 3.0.3 @@ -1084,79 +1084,155 @@ packages: '@swc-next/decoder@0.4.1': resolution: {integrity: sha512-HkTOvxm923cjLMUc2LsAMoYU9LjJo2r/O3bXMhP1Y4t3Df7ytFgjmYjNnyQBq7biGtmSLI1xnvYcQd+1XypaEg==} + '@swc-next/decoder@0.5.0': + resolution: {integrity: sha512-2i4eW+H+w/L7eVu/aajIC2IcVoGvHU5CE5k3FLJJ8Wfhcpk/SqAbpxGH8KWGbZYIirGQqiPG/QRgX0cdyhW91A==} + '@swc-next/parser-binding-darwin-arm64@0.4.1': resolution: {integrity: sha512-cz8M7qF2oWPNMw+ZLWbeL+e6oQW9rwAWEVJXSNR5ddPa475/IhM2S7DrapDl360uFqae0uSvssyYUqa2ZNZ3kQ==} cpu: [arm64] os: [darwin] + '@swc-next/parser-binding-darwin-arm64@0.5.0': + resolution: {integrity: sha512-IleOzDNuvFZPPSKxAPDl1pCQslYVId9hUpLHhYqvtNb7CLmZABWA+Ty5EBmClVkzsLsPP8UfpaEjrao4t+/IJw==} + cpu: [arm64] + os: [darwin] + '@swc-next/parser-binding-darwin-x64@0.4.1': resolution: {integrity: sha512-1GW2iO8ejSwHKd5/S1KWwJRMu8kA4ReGsZtmRdHDtxq8RzXK8kglO/+xIkzMJFfyUvPRabEMWyD89u+8ALAjFQ==} cpu: [x64] os: [darwin] + '@swc-next/parser-binding-darwin-x64@0.5.0': + resolution: {integrity: sha512-MHz/8djr6b///rBGr11e99zl1a1k5MZhMqd1DiPwXZtvo8KE0PiGXRVchtZ5EFCOzJ7RB1flsFi7j0PWKy09Fw==} + cpu: [x64] + os: [darwin] + '@swc-next/parser-binding-linux-arm64-gnu@0.4.1': resolution: {integrity: sha512-O5SZI82exauaawobbesGZgwchs0mBVxhigWKQyrESl7r2I+BiUpDc/XLW8YGICPUicaDQ4vt3gwIfTBaAqGDew==} cpu: [arm64] os: [linux] libc: [glibc] + '@swc-next/parser-binding-linux-arm64-gnu@0.5.0': + resolution: {integrity: sha512-NHhgrFa/lH79myIST7M5+nl8RgYFhmnuA/7YpF2stgyxluH2B3qILDuKFmTmhYTyGugbwRKOS5M3MrAiGL37Ew==} + cpu: [arm64] + os: [linux] + libc: [glibc] + '@swc-next/parser-binding-linux-arm64-musl@0.4.1': resolution: {integrity: sha512-7YrKRZxJIvHJgLXSncgsC2HNrlsHuC+NfYvno9SRq5IS6gFAbcfBqtnNf7ZJsi382OJNMFhjlZV6TZBxDhXv9Q==} cpu: [arm64] os: [linux] libc: [musl] + '@swc-next/parser-binding-linux-arm64-musl@0.5.0': + resolution: {integrity: sha512-0Z28WRYGiEwcI+2fsK1DJI4n5O8yCUpOaYRWedZgPeihdHFnzLjs7+1gUQ1vugjJ4a6DxZ/gtTYx6OtMTs2Jcw==} + cpu: [arm64] + os: [linux] + libc: [musl] + '@swc-next/parser-binding-linux-ppc64-gnu@0.4.1': resolution: {integrity: sha512-6fk0zI8NegOeQDStvuKqHEdSwaTa5guq0eU8xbrub2sqTA84T8C5GnCkeybslHzZxedOcWz0NJ5wZ6/I8Ge5mQ==} cpu: [ppc64] os: [linux] libc: [glibc] + '@swc-next/parser-binding-linux-ppc64-gnu@0.5.0': + resolution: {integrity: sha512-UYFeGgLWyDivErS1bgEOI6pMmL3JHR3boqoSqdXstlf9+Vmv2ADJMbhYUxfYjoQxZqYaRIH6wYVRo2ZrkWZk6A==} + cpu: [ppc64] + os: [linux] + libc: [glibc] + '@swc-next/parser-binding-linux-riscv64-gnu@0.4.1': resolution: {integrity: sha512-i07DnwhN0R2NFH+m698cGR1RT7ayLMXYjCMAeFEOZ5KQmPl+ltxzmXwd9nSO80rFdycKAtnS8SDRVDlGqQFeWg==} cpu: [riscv64] os: [linux] libc: [glibc] + '@swc-next/parser-binding-linux-riscv64-gnu@0.5.0': + resolution: {integrity: sha512-2SdbQN4138tzrrrLByYChD7ruNS6rGBvkTCgDrNVlV3D0QzwiMSxv9ZKf2Qx7+HqFNLZ4sJKlG2aJO8GpQC+qw==} + cpu: [riscv64] + os: [linux] + libc: [glibc] + '@swc-next/parser-binding-linux-riscv64-musl@0.4.1': resolution: {integrity: sha512-OvFQb+17quQoPLmOD0Mv/qdGnd6+fZL43Krnm6Q2TxHol7g7tLskL4sTtt8BGYybBJeMEcY3DkH2fZwGaRvrMg==} cpu: [riscv64] os: [linux] libc: [musl] + '@swc-next/parser-binding-linux-riscv64-musl@0.5.0': + resolution: {integrity: sha512-X1vwcUSvUKqaISB00EsV6UnXZAu5a/WLH9eTFuxmJV047WEmTYkj5EWAZ+c9d0dZ7dj+O1f9gmgqabJJeDjgsw==} + cpu: [riscv64] + os: [linux] + libc: [musl] + '@swc-next/parser-binding-linux-s390x-gnu@0.4.1': resolution: {integrity: sha512-KwjEquKRyKRJZT83oZMpjnVi1OUzPV9pUcWFUci7OQDGE6Q4DCljGcZ14R4o3Xgth4T7QvqG7GGAScBuevFIwQ==} cpu: [s390x] os: [linux] libc: [glibc] + '@swc-next/parser-binding-linux-s390x-gnu@0.5.0': + resolution: {integrity: sha512-5969EEc37QhUtB812vUmx/f8sbeS+zcQP9JGuVbaMxCroXP5R1sar13ZA4naCz4aKcCXRZwPxRQmbBH468pnIQ==} + cpu: [s390x] + os: [linux] + libc: [glibc] + '@swc-next/parser-binding-linux-x64-gnu@0.4.1': resolution: {integrity: sha512-3xsRB/8B4F31CJ3K9VFPlUdlClR0ogPeMRQ8I+JuLyMin9xbhl3zu6CZ34mPoYuynGBt5tGnK0Y2E/e3BH7X7Q==} cpu: [x64] os: [linux] libc: [glibc] + '@swc-next/parser-binding-linux-x64-gnu@0.5.0': + resolution: {integrity: sha512-NbwImI1y3/Nc3eNXS+lFn/57JGJAeg2LVAISJzyTWeEFp+uiyJAPS/0UwT5NvwTt8HYWqPzQRFjhj8T3H711JQ==} + cpu: [x64] + os: [linux] + libc: [glibc] + '@swc-next/parser-binding-linux-x64-musl@0.4.1': resolution: {integrity: sha512-QKgpJeuMprp4dodkY4al3QfGKnFuGechwJPi0XwWpcTZBOefK0i0bZof5suSIO1pLQ1+jOc0rKWv51gbC23K/g==} cpu: [x64] os: [linux] libc: [musl] + '@swc-next/parser-binding-linux-x64-musl@0.5.0': + resolution: {integrity: sha512-9SL4QVUAEALmjIU6g3+30VRuJ7XabWunaNAHKcOwk9aEvJka9zOgX51wrZ6UG3A+xB5ikmdJ47U5GzXq1pLj8w==} + cpu: [x64] + os: [linux] + libc: [musl] + '@swc-next/parser-binding-win32-arm64-msvc@0.4.1': resolution: {integrity: sha512-y/DrHfN4k7+/z2DxBnewbqIgFUapXSxQ9gphXiLen8QiQnZLpUUAFCvXRy1XT1HZEgEKwQBo0FTsLH4qMVghbQ==} cpu: [arm64] os: [win32] + '@swc-next/parser-binding-win32-arm64-msvc@0.5.0': + resolution: {integrity: sha512-zPDrCu2Dkpn3g0Exz1YNpTMzRQYUU9cXaUBBQZjJY69omg6O93JcrAdfIGlhrRsl3oW/3J119uAonAWwBvpvlQ==} + cpu: [arm64] + os: [win32] + '@swc-next/parser-binding-win32-ia32-msvc@0.4.1': resolution: {integrity: sha512-lnsgCeACs+mLUKAy6Xd9b9d/ltjqItIHFWze3okGOHY+7+8N+SpOwwGS7Hq7r4LfK1gmCmEpyObiAD67X1zAdg==} cpu: [ia32] os: [win32] + '@swc-next/parser-binding-win32-ia32-msvc@0.5.0': + resolution: {integrity: sha512-SoRKwDuAyvLYtlnAT9SKrQ0prDd/OEJaM+TdA7Vu37Bpul/wT+f91Z1F0fGOWoR5nLDxRb/syu0+VcTGxKpiyA==} + cpu: [ia32] + os: [win32] + '@swc-next/parser-binding-win32-x64-msvc@0.4.1': resolution: {integrity: sha512-dOlRVHipLRVHAamFgpKOPttvkSNljI2zhnyPUnZX9nFi+dDsvWO/bx40m0Z/4kIFW3LqLMMcDXP+oq4LciR4Zw==} cpu: [x64] os: [win32] + '@swc-next/parser-binding-win32-x64-msvc@0.5.0': + resolution: {integrity: sha512-qGrd26OqQO5OqRynITHpsObpeqhEWdMMJoTKxEt8upoiRZGybGHE7WqwKFvK9s2Sha7h9J8SHJUgPmetaVkr+A==} + cpu: [x64] + os: [win32] + '@swc-next/parser@0.4.1': resolution: {integrity: sha512-wTWUe4Tsve70NmsdiLdpae+HP83t9TN3NI03TKcTU0+u5C2U9t+Od/6p9OW3UFDC6jqDirDObK2bfwiXNLtb7Q==} peerDependencies: @@ -1165,9 +1241,20 @@ packages: '@swc-next/parser-binding-wasm': optional: true + '@swc-next/parser@0.5.0': + resolution: {integrity: sha512-Axy7kOofIpX7+ij7WI3dEBNEgKxUCmU2O/8hZwjB9o5w4wT40kMyk0FpLKzisAlqYg4QZBS6e5mhYP+vtvRc2g==} + peerDependencies: + '@swc-next/parser-binding-wasm': 0.5.0 + peerDependenciesMeta: + '@swc-next/parser-binding-wasm': + optional: true + '@swc-next/types@0.4.1': resolution: {integrity: sha512-cK5oQcZVfLXaTqmty67dAyns7O0rgroray4WR2JhoyoDy9kHCD+cDpfTfStp5sO8WWvFHVqeB46mWwzhXwQljQ==} + '@swc-next/types@0.5.0': + resolution: {integrity: sha512-Z08/346bweHJI1b/Fn7ZaVt2KXFFik7nCNKg6NZ4/zCW2BRBqM2yunOQi210F7Ox8qR1DVttXb2trb6r+JnrmQ==} + '@swc/helpers@0.5.23': resolution: {integrity: sha512-5lSsMOTXURePglDfvuAQUqkGek9Hg2kksOYay2m0+XR++b2NWYL/4sWyuvVBIs8oKnJaxkdi9whaL/sqN13afw==} @@ -3276,45 +3363,88 @@ snapshots: dependencies: '@swc-next/types': 0.4.1 + '@swc-next/decoder@0.5.0': + dependencies: + '@swc-next/types': 0.5.0 + '@swc-next/parser-binding-darwin-arm64@0.4.1': optional: true + '@swc-next/parser-binding-darwin-arm64@0.5.0': + optional: true + '@swc-next/parser-binding-darwin-x64@0.4.1': optional: true + '@swc-next/parser-binding-darwin-x64@0.5.0': + optional: true + '@swc-next/parser-binding-linux-arm64-gnu@0.4.1': optional: true + '@swc-next/parser-binding-linux-arm64-gnu@0.5.0': + optional: true + '@swc-next/parser-binding-linux-arm64-musl@0.4.1': optional: true + '@swc-next/parser-binding-linux-arm64-musl@0.5.0': + optional: true + '@swc-next/parser-binding-linux-ppc64-gnu@0.4.1': optional: true + '@swc-next/parser-binding-linux-ppc64-gnu@0.5.0': + optional: true + '@swc-next/parser-binding-linux-riscv64-gnu@0.4.1': optional: true + '@swc-next/parser-binding-linux-riscv64-gnu@0.5.0': + optional: true + '@swc-next/parser-binding-linux-riscv64-musl@0.4.1': optional: true + '@swc-next/parser-binding-linux-riscv64-musl@0.5.0': + optional: true + '@swc-next/parser-binding-linux-s390x-gnu@0.4.1': optional: true + '@swc-next/parser-binding-linux-s390x-gnu@0.5.0': + optional: true + '@swc-next/parser-binding-linux-x64-gnu@0.4.1': optional: true + '@swc-next/parser-binding-linux-x64-gnu@0.5.0': + optional: true + '@swc-next/parser-binding-linux-x64-musl@0.4.1': optional: true + '@swc-next/parser-binding-linux-x64-musl@0.5.0': + optional: true + '@swc-next/parser-binding-win32-arm64-msvc@0.4.1': optional: true + '@swc-next/parser-binding-win32-arm64-msvc@0.5.0': + optional: true + '@swc-next/parser-binding-win32-ia32-msvc@0.4.1': optional: true + '@swc-next/parser-binding-win32-ia32-msvc@0.5.0': + optional: true + '@swc-next/parser-binding-win32-x64-msvc@0.4.1': optional: true + '@swc-next/parser-binding-win32-x64-msvc@0.5.0': + optional: true + '@swc-next/parser@0.4.1': dependencies: '@swc-next/decoder': 0.4.1 @@ -3334,8 +3464,29 @@ snapshots: '@swc-next/parser-binding-win32-ia32-msvc': 0.4.1 '@swc-next/parser-binding-win32-x64-msvc': 0.4.1 + '@swc-next/parser@0.5.0': + dependencies: + '@swc-next/decoder': 0.5.0 + '@swc-next/types': 0.5.0 + optionalDependencies: + '@swc-next/parser-binding-darwin-arm64': 0.5.0 + '@swc-next/parser-binding-darwin-x64': 0.5.0 + '@swc-next/parser-binding-linux-arm64-gnu': 0.5.0 + '@swc-next/parser-binding-linux-arm64-musl': 0.5.0 + '@swc-next/parser-binding-linux-ppc64-gnu': 0.5.0 + '@swc-next/parser-binding-linux-riscv64-gnu': 0.5.0 + '@swc-next/parser-binding-linux-riscv64-musl': 0.5.0 + '@swc-next/parser-binding-linux-s390x-gnu': 0.5.0 + '@swc-next/parser-binding-linux-x64-gnu': 0.5.0 + '@swc-next/parser-binding-linux-x64-musl': 0.5.0 + '@swc-next/parser-binding-win32-arm64-msvc': 0.5.0 + '@swc-next/parser-binding-win32-ia32-msvc': 0.5.0 + '@swc-next/parser-binding-win32-x64-msvc': 0.5.0 + '@swc-next/types@0.4.1': {} + '@swc-next/types@0.5.0': {} + '@swc/helpers@0.5.23': dependencies: tslib: 2.8.1