morluto/rea

Fork 0

mirror of https://github.com/morluto/rea.git synced 2026-11-05 06:45:22 +00:00

[GH-ISSUE #3365] [Bug] Native-boundary inspection fails on a large metadata issue inventory #1231

New issue

Closed

opened 2026-10-16 21:03:05 +00:00 by bsakaguchi · 1 comment

bsakaguchi commented

2026-10-16 21:03:05 +00:00

Owner

Originally created by @coygeek on GitHub (Oct 14, 2026).
Original GitHub issue: https://github.com/morluto/rea/issues/3365

Before submitting

I searched the open and closed issues for a related report.
I removed credentials, tokens, private paths, and sensitive target data.

Area

Native analysis or decompilation

Observed behavior

inspect-managed-native-boundaries fails with a generic execution_failure for an 844,800-byte PE/CLI fixture containing 140,000 invalid custom-attribute constructor indexes and an otherwise readable P/Invoke declaration. It returns no inspection Evidence, coverage, or import rows. The provider is rea-dotnet-static, and the operation is inspect_managed_native_boundaries.

Member inspection of the same bytes succeeds with partial metadata. Native-boundary inspection also succeeds with the same fixture structure at 100,000 invalid attributes and retains the import. A separately executed direct call to the built native-boundary parser with the larger input throws RangeError: Maximum call stack size exceeded at the inventory-issue append.

Reproduction

Start from a clean checkout at the tested revision and install its locked dependencies and build the runtime:

git clone https://github.com/morluto/rea.git rea-repro
cd rea-repro
git checkout --detach 8dde6370d0809ad04cda3342d4e6f290f48aa063
npm ci
npm run build:cached

From the repository root, create the byte generator inline and run the larger input, same-input member inspection, and smaller native-boundary control:

mkdir -p repro/home
cat > repro/make-attributes.txt <<'JS'
import { buildManagedPeFixture } from './scripts/fixtures/managed/pe.mjs';
import { readManagedPeLayout } from './dist/dotnet/ManagedPeReader.js';
import { readManagedMetadataLayout } from './dist/dotnet/ManagedMetadataLayout.js';
import { writeFileSync } from 'node:fs';
const count = Number(process.argv[3] ?? 140000);
const image = buildManagedPeFixture({ pinvoke: {} });
const pe = readManagedPeLayout(image);
const cli = pe.cli;
const root = pe.rvaToOffset(cli.metadata.rva, cli.metadata.size, 'metadata');
const layout = readManagedMetadataLayout(image, root, cli.metadata.size);
const attributes = layout.table(12);
const before = attributes.offset - root;
const after = before + attributes.rowSize;
const extra = (count - 1) * attributes.rowSize;
const row = Buffer.from(image.subarray(attributes.offset, attributes.offset + attributes.rowSize));
row.writeUInt16LE(0, 2);
const copies = Buffer.alloc(count * row.length);
for (let i = 0; i < count; i++) row.copy(copies, i * row.length);
const metadata = Buffer.concat([image.subarray(root, root + before), copies, image.subarray(root + after, root + cli.metadata.size)]);
let header = Math.ceil((16 + metadata.readUInt32LE(12)) / 4) * 4 + 4;
const streamCount = metadata.readUInt16LE(header - 2);
for (let i = 0; i < streamCount; i++) {
  const offset = metadata.readUInt32LE(header);
  const end = metadata.indexOf(0, header + 8);
  const name = metadata.toString('ascii', header + 8, end);
  if (name === '#~') {
    metadata.writeUInt32LE(metadata.readUInt32LE(header + 4) + extra, header + 4);
    const valid = metadata.readBigUInt64LE(offset + 8);
    let rowCount = offset + 24;
    for (let table = 0; table < 12; table++) if ((valid & (1n << BigInt(table))) !== 0n) rowCount += 4;
    metadata.writeUInt32LE(count, rowCount);
  } else if (offset >= after) metadata.writeUInt32LE(offset + extra, header);
  header = Math.ceil((end + 1) / 4) * 4;
}
const relocated = image.length;
const result = Buffer.alloc(Math.ceil((relocated + metadata.length) / 512) * 512);
image.copy(result);
metadata.copy(result, relocated);
const optional = result.readUInt32LE(0x3c) + 24;
const section = optional + result.readUInt16LE(optional - 4);
const rawOffset = result.readUInt32LE(section + 20);
const virtualAddress = result.readUInt32LE(section + 12);
result.writeUInt32LE(virtualAddress + relocated - rawOffset, cli.headerOffset + 8);
result.writeUInt32LE(metadata.length, cli.headerOffset + 12);
result.writeUInt32LE(result.length - rawOffset, section + 8);
result.writeUInt32LE(result.length - rawOffset, section + 16);
result.writeUInt32LE(Math.ceil((virtualAddress + result.length - rawOffset) / 4096) * 4096, optional + 56);
writeFileSync(process.argv[2] + '/attributes.dll', result);
console.log(JSON.stringify({ count, bytes: result.length }));
JS
node --input-type=module - "$PWD/repro" 140000 < repro/make-attributes.txt
HOME="$PWD/repro/home" node scripts/rea.mjs inspect-managed-native-boundaries "$PWD/repro/attributes.dll" --format json
printf 'native exit=%s\n' "$?"
HOME="$PWD/repro/home" node scripts/rea.mjs inspect-managed-members "$PWD/repro/attributes.dll" --format json --filter-output normalized_result.metadata,normalized_result.coverage.state
printf 'members exit=%s\n' "$?"
node --input-type=module - "$PWD/repro" 100000 < repro/make-attributes.txt
HOME="$PWD/repro/home" node scripts/rea.mjs inspect-managed-native-boundaries "$PWD/repro/attributes.dll" --format json --filter-output normalized_result.metadata.status,normalized_result.coverage.state,normalized_result.pinvoke_imports,normalized_result.summary
printf 'control exit=%s\n' "$?"

Compare the native-boundary failure with the member inspection and smaller control. The generator uses the existing fixture as a base, repeats its custom-attribute row with a null constructor index, relocates the expanded metadata, and updates the file-backed section and CLI metadata extents. It changes no production or fixture-builder source files.

The attribute constructor indexes are deliberately malformed. This reproduction tests whether inspection preserves the partial result and readable independent declarations, not whether those indexes form a loadable assembly. No target code is loaded or executed. The CLI failure, direct built-parser exception, smaller native-boundary control, and same-input member inspection were all observed. The dependency installation and build commands above are clean-checkout preparation instructions.

Expected behavior

Native-boundary inspection should retain the readable module and P/Invoke declaration with partial metadata coverage and the constructor-index issues, as it does for the smaller control. If an actual representation limit prevents delivery, return the documented resource-limit coverage outcome rather than an internal execution failure with no inspection result.

docs/managed-code-analysis.md:138 and docs/managed-code-analysis.md:151 define input and representation admission and the resource-limit coverage outcome. The documented input ceiling is 128 MiB, and the separate conservative representation budget is 64 MiB. src/dotnet/ManagedArtifactFailures.test.ts:56 pins preservation of malformed inventory issues across the inspection callers. docs/tool-design.md:57 requires preserving partial provider facts.

Impact and scope

Impact level is P2, supported by the observed bounded local metadata inspection losing every native-boundary result and its diagnostic Evidence for this input, despite an intact readable import and a file far below the documented input ceiling. The failure is limited to sufficiently large issue inventories; it does not establish a failure on ordinary assemblies.

Workaround status is unverified. Member inspection retains partial metadata but does not return the native-boundary import inventory. Removing attributes would change the selected artifact and its identity. No workaround preserving the original native-boundary result was verified.

REA version

6.4.0 (main at 8dde6370d0)

Runtime and platform

Node.js v26.10.0 on macOS 27.0.1 arm64, using the built local CLI. The observed argument-count failure is runtime-dependent; these sizes establish the tested failure and successful control, not a universal threshold.

Target and artifact context

Source-owned PE/CLI fixture bytes with an otherwise readable P/Invoke declaration. The larger fixture contains 140,000 invalid custom-attribute constructor indexes in 844,800 bytes. The smaller control contains 100,000 invalid attributes in 604,672 bytes. The control retains the Main import of MessageBoxW from user32.dll, and its summary has one module reference, one P/Invoke import, and one native implementation.

Interface

CLI

Earliest failure stage

Native analysis or reconstruction

Relevant output or evidence

For 140,000 attributes, the generator reports 844,800 bytes and native-boundary inspection exits with status 1. The returned error is:

{"error":"Analysis failed","code":"execution_failure","category":"execution_failure","message":"Analysis could not complete. Run `rea doctor` and review the reported details; repeating the unchanged request is not expected to succeed.","retryable":false,"remediation":{"action":"Analysis could not complete. Run `rea doctor` and review the reported details; repeating the unchanged request is not expected to succeed."},"details":{"provider_id":"rea-dotnet-static","operation":"inspect_managed_native_boundaries"}}

Member inspection of the same bytes exits with status 0 and reports metadata.status: "partial", coverage.state: "partial", and row counts including CustomAttribute: 140000, ModuleRef: 1, and ImplMap: 1. The separately executed built parser throws:

RangeError: Maximum call stack size exceeded

For 100,000 attributes, the generator reports 604,672 bytes. Native-boundary inspection exits with status 0, returns partial metadata and coverage, and retains the Main import of MessageBoxW from user32.dll. Its summary has one module reference, one P/Invoke import, and one native implementation.

Typed outcome or recovery expected

Run the reproduction on both sizes. The larger input must no longer become a generic execution_failure from argument-count exhaustion. It should preserve partial inspection Evidence and the readable P/Invoke declaration if admitted, or return a justified representation-limit coverage result. The smaller control must continue preserving its import and partial issues, and no target execution should be introduced. Check the complete issue set or an explicitly reported capacity outcome rather than silently dropping diagnostics. Same-input member inspection supplies a discriminating control for readable metadata.

Analysis or suspected cause

Source-derived reasoning identifies src/dotnet/ManagedNativeBoundaryInspector.ts:147, where issues.push(...inventory.issues) passes inventory issues as individual call arguments. The separately observed built-parser RangeError occurs at the corresponding inventory-issue append. A sufficiently large issue inventory can exceed the runtime's call-argument capacity before independent native-boundary declarations reach the result. The source reasoning and observed exception support this cause; the tested input sizes do not establish a universal threshold.

Additional context

#1878 concerns temporary row-cursor charges exhausting metadata accounting and producing typed unavailable coverage; this failure occurs at native-boundary diagnostic append while same-input member inspection succeeds.
#1801 concerns excessive IL/blob representation charges returning resource-limit; this report concerns call-argument exhaustion returning execution_failure.
#1940 concerns quadratic TypeDef scans for local attribute constructors while preserving correct results; null constructor indexes here produce a large diagnostic inventory that fails at append.
#1538 concerns a similar call-argument limit in JavaScript reference traversal; the managed native-boundary inspector is a separate owner and requires a separate fix.
#553 concerns explicit-target routing between CLI and MCP; the present CLI reproduction reaches the managed static provider and fails later in parsing.
#2191 concerns malformed PE section-range failures escaping admission; this input has readable metadata and fails at the decoded inventory-issue append.
#2121 concerns invalid CLI type-selector validation; the present native-boundary request uses no type selector.
#2584 concerns fixture metadata overwriting a ReadyToRun signature; the present generator relocates expanded metadata and the observed exception occurs at diagnostic append.
#3154 proposes decoding custom-attribute arguments from valid constructor signatures; preserving malformed constructor diagnostics and independent imports is a separate existing contract.
#3201 concerns false module contradictions during managed/native verification; the present inspection fails before returning usable boundary Evidence.

Originally created by @coygeek on GitHub (Oct 14, 2026). Original GitHub issue: https://github.com/morluto/rea/issues/3365 ### Before submitting - [x] I searched the open and closed issues for a related report. - [x] I removed credentials, tokens, private paths, and sensitive target data. ### Area Native analysis or decompilation ### Observed behavior `inspect-managed-native-boundaries` fails with a generic `execution_failure` for an 844,800-byte PE/CLI fixture containing 140,000 invalid custom-attribute constructor indexes and an otherwise readable P/Invoke declaration. It returns no inspection Evidence, coverage, or import rows. The provider is `rea-dotnet-static`, and the operation is `inspect_managed_native_boundaries`. Member inspection of the same bytes succeeds with partial metadata. Native-boundary inspection also succeeds with the same fixture structure at 100,000 invalid attributes and retains the import. A separately executed direct call to the built native-boundary parser with the larger input throws `RangeError: Maximum call stack size exceeded` at the inventory-issue append. ### Reproduction 1. Start from a clean checkout at the tested revision and install its locked dependencies and build the runtime: ```sh git clone https://github.com/morluto/rea.git rea-repro cd rea-repro git checkout --detach 8dde6370d0809ad04cda3342d4e6f290f48aa063 npm ci npm run build:cached ``` 2. From the repository root, create the byte generator inline and run the larger input, same-input member inspection, and smaller native-boundary control: ```sh mkdir -p repro/home cat > repro/make-attributes.txt <<'JS' import { buildManagedPeFixture } from './scripts/fixtures/managed/pe.mjs'; import { readManagedPeLayout } from './dist/dotnet/ManagedPeReader.js'; import { readManagedMetadataLayout } from './dist/dotnet/ManagedMetadataLayout.js'; import { writeFileSync } from 'node:fs'; const count = Number(process.argv[3] ?? 140000); const image = buildManagedPeFixture({ pinvoke: {} }); const pe = readManagedPeLayout(image); const cli = pe.cli; const root = pe.rvaToOffset(cli.metadata.rva, cli.metadata.size, 'metadata'); const layout = readManagedMetadataLayout(image, root, cli.metadata.size); const attributes = layout.table(12); const before = attributes.offset - root; const after = before + attributes.rowSize; const extra = (count - 1) * attributes.rowSize; const row = Buffer.from(image.subarray(attributes.offset, attributes.offset + attributes.rowSize)); row.writeUInt16LE(0, 2); const copies = Buffer.alloc(count * row.length); for (let i = 0; i < count; i++) row.copy(copies, i * row.length); const metadata = Buffer.concat([image.subarray(root, root + before), copies, image.subarray(root + after, root + cli.metadata.size)]); let header = Math.ceil((16 + metadata.readUInt32LE(12)) / 4) * 4 + 4; const streamCount = metadata.readUInt16LE(header - 2); for (let i = 0; i < streamCount; i++) { const offset = metadata.readUInt32LE(header); const end = metadata.indexOf(0, header + 8); const name = metadata.toString('ascii', header + 8, end); if (name === '#~') { metadata.writeUInt32LE(metadata.readUInt32LE(header + 4) + extra, header + 4); const valid = metadata.readBigUInt64LE(offset + 8); let rowCount = offset + 24; for (let table = 0; table < 12; table++) if ((valid & (1n << BigInt(table))) !== 0n) rowCount += 4; metadata.writeUInt32LE(count, rowCount); } else if (offset >= after) metadata.writeUInt32LE(offset + extra, header); header = Math.ceil((end + 1) / 4) * 4; } const relocated = image.length; const result = Buffer.alloc(Math.ceil((relocated + metadata.length) / 512) * 512); image.copy(result); metadata.copy(result, relocated); const optional = result.readUInt32LE(0x3c) + 24; const section = optional + result.readUInt16LE(optional - 4); const rawOffset = result.readUInt32LE(section + 20); const virtualAddress = result.readUInt32LE(section + 12); result.writeUInt32LE(virtualAddress + relocated - rawOffset, cli.headerOffset + 8); result.writeUInt32LE(metadata.length, cli.headerOffset + 12); result.writeUInt32LE(result.length - rawOffset, section + 8); result.writeUInt32LE(result.length - rawOffset, section + 16); result.writeUInt32LE(Math.ceil((virtualAddress + result.length - rawOffset) / 4096) * 4096, optional + 56); writeFileSync(process.argv[2] + '/attributes.dll', result); console.log(JSON.stringify({ count, bytes: result.length })); JS node --input-type=module - "$PWD/repro" 140000 < repro/make-attributes.txt HOME="$PWD/repro/home" node scripts/rea.mjs inspect-managed-native-boundaries "$PWD/repro/attributes.dll" --format json printf 'native exit=%s\n' "$?" HOME="$PWD/repro/home" node scripts/rea.mjs inspect-managed-members "$PWD/repro/attributes.dll" --format json --filter-output normalized_result.metadata,normalized_result.coverage.state printf 'members exit=%s\n' "$?" node --input-type=module - "$PWD/repro" 100000 < repro/make-attributes.txt HOME="$PWD/repro/home" node scripts/rea.mjs inspect-managed-native-boundaries "$PWD/repro/attributes.dll" --format json --filter-output normalized_result.metadata.status,normalized_result.coverage.state,normalized_result.pinvoke_imports,normalized_result.summary printf 'control exit=%s\n' "$?" ``` 3. Compare the native-boundary failure with the member inspection and smaller control. The generator uses the existing fixture as a base, repeats its custom-attribute row with a null constructor index, relocates the expanded metadata, and updates the file-backed section and CLI metadata extents. It changes no production or fixture-builder source files. The attribute constructor indexes are deliberately malformed. This reproduction tests whether inspection preserves the partial result and readable independent declarations, not whether those indexes form a loadable assembly. No target code is loaded or executed. The CLI failure, direct built-parser exception, smaller native-boundary control, and same-input member inspection were all observed. The dependency installation and build commands above are clean-checkout preparation instructions. ### Expected behavior Native-boundary inspection should retain the readable module and P/Invoke declaration with partial metadata coverage and the constructor-index issues, as it does for the smaller control. If an actual representation limit prevents delivery, return the documented `resource-limit` coverage outcome rather than an internal execution failure with no inspection result. `docs/managed-code-analysis.md:138` and `docs/managed-code-analysis.md:151` define input and representation admission and the `resource-limit` coverage outcome. The documented input ceiling is 128 MiB, and the separate conservative representation budget is 64 MiB. `src/dotnet/ManagedArtifactFailures.test.ts:56` pins preservation of malformed inventory issues across the inspection callers. `docs/tool-design.md:57` requires preserving partial provider facts. ### Impact and scope Impact level is P2, supported by the observed bounded local metadata inspection losing every native-boundary result and its diagnostic Evidence for this input, despite an intact readable import and a file far below the documented input ceiling. The failure is limited to sufficiently large issue inventories; it does not establish a failure on ordinary assemblies. Workaround status is unverified. Member inspection retains partial metadata but does not return the native-boundary import inventory. Removing attributes would change the selected artifact and its identity. No workaround preserving the original native-boundary result was verified. ### REA version 6.4.0 (main at 8dde6370d0809ad04cda3342d4e6f290f48aa063) ### Runtime and platform Node.js v26.10.0 on macOS 27.0.1 arm64, using the built local CLI. The observed argument-count failure is runtime-dependent; these sizes establish the tested failure and successful control, not a universal threshold. ### Target and artifact context Source-owned PE/CLI fixture bytes with an otherwise readable P/Invoke declaration. The larger fixture contains 140,000 invalid custom-attribute constructor indexes in 844,800 bytes. The smaller control contains 100,000 invalid attributes in 604,672 bytes. The control retains the `Main` import of `MessageBoxW` from `user32.dll`, and its summary has one module reference, one P/Invoke import, and one native implementation. ### Interface CLI ### Earliest failure stage Native analysis or reconstruction ### Relevant output or evidence For 140,000 attributes, the generator reports 844,800 bytes and native-boundary inspection exits with status 1. The returned error is: ```text {"error":"Analysis failed","code":"execution_failure","category":"execution_failure","message":"Analysis could not complete. Run `rea doctor` and review the reported details; repeating the unchanged request is not expected to succeed.","retryable":false,"remediation":{"action":"Analysis could not complete. Run `rea doctor` and review the reported details; repeating the unchanged request is not expected to succeed."},"details":{"provider_id":"rea-dotnet-static","operation":"inspect_managed_native_boundaries"}} ``` Member inspection of the same bytes exits with status 0 and reports `metadata.status: "partial"`, `coverage.state: "partial"`, and row counts including `CustomAttribute: 140000`, `ModuleRef: 1`, and `ImplMap: 1`. The separately executed built parser throws: ```text RangeError: Maximum call stack size exceeded ``` For 100,000 attributes, the generator reports 604,672 bytes. Native-boundary inspection exits with status 0, returns partial metadata and coverage, and retains the `Main` import of `MessageBoxW` from `user32.dll`. Its summary has one module reference, one P/Invoke import, and one native implementation. ### Typed outcome or recovery expected Run the reproduction on both sizes. The larger input must no longer become a generic `execution_failure` from argument-count exhaustion. It should preserve partial inspection Evidence and the readable P/Invoke declaration if admitted, or return a justified representation-limit coverage result. The smaller control must continue preserving its import and partial issues, and no target execution should be introduced. Check the complete issue set or an explicitly reported capacity outcome rather than silently dropping diagnostics. Same-input member inspection supplies a discriminating control for readable metadata. ### Analysis or suspected cause Source-derived reasoning identifies `src/dotnet/ManagedNativeBoundaryInspector.ts:147`, where `issues.push(...inventory.issues)` passes inventory issues as individual call arguments. The separately observed built-parser RangeError occurs at the corresponding inventory-issue append. A sufficiently large issue inventory can exceed the runtime's call-argument capacity before independent native-boundary declarations reach the result. The source reasoning and observed exception support this cause; the tested input sizes do not establish a universal threshold. ### Additional context - [#1878](https://github.com/morluto/rea/issues/1878) concerns temporary row-cursor charges exhausting metadata accounting and producing typed unavailable coverage; this failure occurs at native-boundary diagnostic append while same-input member inspection succeeds. - [#1801](https://github.com/morluto/rea/issues/1801) concerns excessive IL/blob representation charges returning `resource-limit`; this report concerns call-argument exhaustion returning `execution_failure`. - [#1940](https://github.com/morluto/rea/issues/1940) concerns quadratic TypeDef scans for local attribute constructors while preserving correct results; null constructor indexes here produce a large diagnostic inventory that fails at append. - [#1538](https://github.com/morluto/rea/issues/1538) concerns a similar call-argument limit in JavaScript reference traversal; the managed native-boundary inspector is a separate owner and requires a separate fix. - [#553](https://github.com/morluto/rea/issues/553) concerns explicit-target routing between CLI and MCP; the present CLI reproduction reaches the managed static provider and fails later in parsing. - [#2191](https://github.com/morluto/rea/issues/2191) concerns malformed PE section-range failures escaping admission; this input has readable metadata and fails at the decoded inventory-issue append. - [#2121](https://github.com/morluto/rea/issues/2121) concerns invalid CLI type-selector validation; the present native-boundary request uses no type selector. - [#2584](https://github.com/morluto/rea/issues/2584) concerns fixture metadata overwriting a ReadyToRun signature; the present generator relocates expanded metadata and the observed exception occurs at diagnostic append. - [#3154](https://github.com/morluto/rea/issues/3154) proposes decoding custom-attribute arguments from valid constructor signatures; preserving malformed constructor diagnostics and independent imports is a separate existing contract. - [#3201](https://github.com/morluto/rea/issues/3201) concerns false module contradictions during managed/native verification; the present inspection fails before returning usable boundary Evidence.

bsakaguchi referenced this issue

2026-10-17 21:09:53 +00:00

[PR #1274] [MERGED] fix(process): preserve unknown filesystem absence in partial captures #2757

bsakaguchi closed this issue

2026-10-31 00:30:11 +00:00

bsakaguchi commented

2026-10-31 00:30:12 +00:00

Author

Owner

@coygeek commented on GitHub (Oct 24, 2026):

Checked the reported fix on main at d87e73f2db.

Native-boundary inspection now appends inventory issues with appendManagedParseIssues, whose nested loop avoids one argument per issue. The regression injects 150,000 inventory issues around a real managed fixture with readable P/Invoke, then requires the import, partial coverage, all issue records and first/last values. This targets the exact argument-capacity failure rather than suppressing diagnostics.

Implementation: ManagedNativeBoundaryInspector.ts, ManagedReaderFailure.ts.

The relevant regression checks in ManagedArtifactFailures.test.ts passed in the focused test run on this revision. This closure is based on the current source and those checks; provider fixtures do not establish a real-engine run. Closing as completed on main.

@coygeek commented on GitHub (Oct 24, 2026): Checked the reported fix on `main` at d87e73f2db50be72d33a4b3c7199af35518b441c. Native-boundary inspection now appends inventory issues with appendManagedParseIssues, whose nested loop avoids one argument per issue. The regression injects 150,000 inventory issues around a real managed fixture with readable P/Invoke, then requires the import, partial coverage, all issue records and first/last values. This targets the exact argument-capacity failure rather than suppressing diagnostics. Implementation: [ManagedNativeBoundaryInspector.ts](https://github.com/morluto/rea/blob/d87e73f2db50be72d33a4b3c7199af35518b441c/src/dotnet/ManagedNativeBoundaryInspector.ts#L161), [ManagedReaderFailure.ts](https://github.com/morluto/rea/blob/d87e73f2db50be72d33a4b3c7199af35518b441c/src/dotnet/ManagedReaderFailure.ts#L89). The relevant regression checks in [ManagedArtifactFailures.test.ts](https://github.com/morluto/rea/blob/d87e73f2db50be72d33a4b3c7199af35518b441c/src/dotnet/ManagedArtifactFailures.test.ts) passed in the focused test run on this revision. This closure is based on the current source and those checks; provider fixtures do not establish a real-engine run. Closing as completed on main.

No milestone

No project

No assignees

1 participant

Notifications

Due date

The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference

morluto/rea#1231

No description provided.

Rows
Columns