improve type inference

[turadg]

Refs: #3171

Description

Improves TypeScript inference across @endo/exo, @endo/patterns, @endo/pass-style, @endo/eventual-send, and @endo/ocapn, discovered while integrating Endo with agoric-sdk under TypeScript 6. The changes are almost entirely type-level — no runtime behavior changes — and each commit is a self-contained fix so they can be reviewed (and reverted) independently.

Notable fixes:

• pass-style: CopyArray<T> is now readonly T[], so readonly tuples (e.g. readonly ["ibc"]) satisfy Passable. Backward-compatible since T[] still extends readonly T[].
• patterns: M.remotable() defaults to any (matching M.promise()) so unparameterized remotables are assignable to concrete remotable typedefs downstream. TFRemotable, TFOr, TFOptionalTuple, TFSplitRecord, TFRestArgs, TypeFromArgGuard, and MatcherOf propagation through InterfaceGuard all tightened. Adds CastedPattern<T> for unchecked type assertions and objectExtendEach helper.
• exo: defineExoClass, defineExoClassKit, and makeExo no longer intersect facet constraints with & Methods, which was collapsing specific facet keys into the index signature and erasing facet method inference (Pick<X, never> = {}). Guarded<M, G> is now structurally compatible across G.
• eventual-send: short-circuits any in RemoteFunctions, PickCallable, and ECallableOrMethods. Publicly exports EMethods/EGetters and friends.
• ocapn: parameterizes CapTP slots; general TS-6 conformance pass.

The most critical files to review are the type definitions under packages/patterns/src/types.d.ts, packages/exo/src/types.d.ts, packages/pass-style/src/types.js, and packages/eventual-send/src/types.d.ts.

Security Considerations

None. Type-only changes; no new authority, no change to mutually-suspicious component boundaries.

Scaling Considerations

None. No runtime changes.

Documentation Considerations

No user-facing API changes. Downstream consumers that were working around the inference bugs with casts may be able to remove those casts, but existing casts remain valid.

Testing Considerations

Covered by existing unit tests plus the root tsc type-check, which this PR makes pass cleanly under TypeScript 6. The real-world validation is successful integration with agoric-sdk, where these inference gaps were originally surfaced.

Compatibility Considerations

Backward-compatible at the value level. At the type level, a few overly-narrow types were widened (e.g. CopyArray<T> to readonly T[], M.remotable() default to any); downstream code that depended on the previous narrower shape may need minor adjustments, but the common case is that previously-broken inference now works without changes.

Upgrade Considerations

None — no persistent state, no migrations, no breaking runtime changes.

[turadg]

This change is part of the following stack:

• adopt TS "strict" #3171
  • improve type inference #3172 ◀

_{Change managed by git-spice.}

[changeset-bot]

🦋 Changeset detected

Latest commit: 37aa50b

The changes in this PR will be included in the next version bump.

This PR includes changesets to release 19 packages

Name	Type
@endo/common	Minor
@endo/eventual-send	Minor
@endo/patterns	Minor
@endo/exo	Minor
@endo/pass-style	Minor
@endo/ocapn	Minor
@endo/marshal	Patch
@endo/captp	Patch
@endo/cli	Patch
@endo/daemon	Patch
@endo/far	Patch
@endo/init	Patch
@endo/lp32	Patch
@endo/netstring	Patch
@endo/stream-node	Patch
@endo/stream	Patch
@endo/bundle-source	Patch
@endo/ses-ava	Patch
@endo/stream-types-test	Patch

Not sure what this means? Click here to learn what changesets are.

Click here if you're a maintainer who wants to add another changeset to this PR

[Copilot]

Pull request overview

Note

Copilot was unable to run its full agentic suite in this review.

Improves TypeScript type inference and TS6 compatibility across multiple Endo packages, primarily via type-level refinements and expanded type tests.

Changes:

• Refines @endo/patterns type inference (e.g., M.remotable() default, void vs undefined, PromiseLike, optional tuples, rest args, and new CastedPattern<T>).
• Updates @endo/exo guarded type plumbing to preserve facet inference and improve Guarded<..., G> structural compatibility.
• Parameterizes OCapN CapTP slot types and adds a new @endo/common helper objectExtendEach.

Reviewed changes

Copilot reviewed 27 out of 32 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
packages/ses/types.d.ts	Adds global typing for ModuleSource (optionally installed by shim).
packages/ses/test/module-source.test.js	Narrows ModuleSource to non-undefined after shim load for tests.
packages/patterns/test/types.test-d.ts	Expands/updates type-level regression tests (void/PromiseLike/remotable/rest/optional tuples/CastedPattern).
packages/patterns/src/types.ts	Adds CastedPattern<T> and changes M.remotable() default generic to any; tightens interface guard generic constraints.
packages/patterns/src/type-from-pattern.ts	Implements CastedPattern handling and multiple inference fixes (void/PromiseLike/TFOr/TFSplitRecord/TFOptionalTuple/TFRestArgs/etc.).
packages/pass-style/src/types.d.ts	Changes CopyArray<T> to readonly T[] to accept readonly tuples.
packages/ocapn/test/codecs/passable.test.js	Adds casts to satisfy stricter typing for tagged passable codec tests.
packages/ocapn/test/client.test.js	Adds casts for debug/message typing in tests.
packages/ocapn/test/captp/pairwise.test.js	Adds casts for primitive-path slot lookup tests.
packages/ocapn/src/client/sturdyrefs.js	Casts bootstrap to any for E(...) call site under stricter typing.
packages/ocapn/src/client/ref-kit.js	Adds JSDoc assertions for remote promise/object value lookups.
packages/ocapn/src/client/ocapn.js	Widens getRemoteBootstrap return type to any.
packages/ocapn/src/captp/types.js	Parameterizes CapTP Slot type by SlotType.
packages/ocapn/src/captp/pairwise.js	Propagates parameterized Slot<T> through makeSlot/parseSlot.
packages/exo/types-index.d.ts	Adjusts generics to avoid facet inference collapse and improve ThisType inference in kits.
packages/exo/test/types-plain-unguarded.test-d.ts	Adds regression tests for facet inference when guard kit is undefined.
packages/exo/test/types-plain-guarded.test-d.ts	Updates expectations to void returns and documents kit typing trade-offs.
packages/exo/test/types-advanced.test-d.ts	Updates advanced type expectations (e.g., void returns).
packages/exo/test/heap-classes.test.js	Removes @ts-expect-error markers that are no longer expected under new typing.
packages/exo/src/types.d.ts	Makes Guarded<M, G> structurally compatible across G via phantom method; adjusts GuardedMethods extraction.
packages/eventual-send/test/eventual-send.test.js	Casts rwp(handler2) result to any under stricter checking.
packages/eventual-send/src/no-shim.js	Removes an imported type from JSDoc @import list.
packages/eventual-send/src/exports.d.ts	Exports additional public E() helper types.
packages/eventual-send/src/E.js	Short-circuits any in several conditional helper types to avoid unusable projections.
packages/daemon/src/context.js	Tightens JSDoc typing (@returns, Context['cancel']) and asserts returned object type.
packages/compartment-mapper/src/link.js	Removes an unused JSDoc-imported type name.
packages/common/object-map.js	Adds new objectExtendEach helper with hardened result and typed JSDoc.
.eslintignore	Removes explicit un-ignore entries for many .d.ts files.
.changeset/ocapn-captp-slot-types.md	Changeset for OCapN slot typing improvements.
.changeset/improve-pattern-exo-inference.md	Changeset for patterns/exo/pass-style inference improvements.
.changeset/eventual-send-type-exports.md	Changeset for eventual-send type exports and any short-circuiting.
.changeset/common-object-extend-each.md	Changeset for new objectExtendEach helper.

Comments suppressed due to low confidence (1)

packages/patterns/src/type-from-pattern.ts:1

• The doc comment says M.remotable<SomeTypedef>() should preserve and return the concrete Payload type, but the implementation currently returns any for all non-InterfaceGuard payloads. This makes parameterized M.remotable<T>() lose specificity and contradicts the comment (and parts of the PR description/changeset). Consider returning Payload in the non-InterfaceGuard branch, and using a separate condition to keep the unparameterized default (any) behavior.

/// <reference types="ses"/>

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[turadg]

Good catch — the comment was stale. The & {} intersection is not needed and not present: TypeScript's homomorphic-mapped-type-over-tuple special case preserves tuple-ness on its own, so { [K in keyof T]?: ... } already produces a clean [X?, Y?] shape without length/prototype pollution. The test at types.test-d.ts:402 pins this down with expectType<[string, bigint?, boolean?]> (exact-type match), which the current impl passes.

Updated the doc comment to drop the misleading paragraph and explain the preservation via the homomorphic-mapped-type special case instead.

[turadg]

Good catch — the comment was stale. The & {} intersection is not needed and not present: TypeScript's homomorphic-mapped-type-over-tuple special case preserves tuple-ness on its own, so { [K in keyof T]?: ... } already produces a clean [X?, Y?] shape without length/prototype pollution. The test at types.test-d.ts:402 pins this down with expectType<[string, bigint?, boolean?]> (exact-type match), which the current impl passes.

Updated the doc comment to drop the misleading paragraph and explain the preservation via the homomorphic-mapped-type special case instead.

[boneskull]

This is pretty big, but I went over it about as well as can be expected. I don't see any blockers; just some questions and suggestions.

[boneskull]

Don't like it 😄

[turadg]

would you prefer a ts-expect-error? it is just a test

[boneskull]

Should this be:

Suggested change

	__interfaceGuard__?(g?: G): void;
	__interfaceGuard__?(g?: G | undefined): void;

..?

[turadg]

not sure. what drives the question?

[boneskull]

This is interesting and makes me think about how to avoid the type assertion. I don't think it's avoidable. That said, it should be possible to create a type and function which would extract the SlotType from any Slot (though the function itself would contain a type assertion).

type ExtractSlotType<Slot extends string> = Slot extends 
  `${infer S extends SlotType}${'+' | '-'}${string}` ? S : never;

function extractSlotType<T extends Slot<SlotType>>(slot: T): ExtractPrefix<T> {
  return s[0] as ExtractPrefix<T>;
}

Of course, this is of dubious value, but I just got nerd-sniped, so I'm sharing.

[boneskull]

Why are these needed?

[turadg]

good catch. from an earlier rev. removing

[boneskull]

TIL!

[boneskull]

Why isn't it @endo/module-source's responsibility to add this global?

[turadg]

Good question. Its shim does add the global. I think it was because this module defines other globals but I've moved it to module-source.

[boneskull]

💯

[turadg]

landed this in the TS6 bump

[boneskull]

What changed so that this claim is now true?

[turadg]

Commit 1155ec691 ("fix(patterns): TFOptionalTuple emits truly optional elements") changed TFOptionalTuple from a recursive conditional type to a homomorphic mapped type.

Before:

type TFOptionalTuple<T extends readonly any[]> = T extends readonly [infer H, ...infer R]
  ? [TypeFromPattern<H> | undefined, ...TFOptionalTuple<R>]
  : [];

Produced [X | undefined, Y | undefined] — each position a union with undefined, not optional. Callers had to pass all N elements with explicit undefined placeholders.

After:

type TFOptionalTuple<T extends readonly any[]> = {
  [K in keyof T]?: TypeFromPattern<T[K]>;
};

Produces [X?, Y?] — truly optional positions callers can omit.

The prior code comment claimed TS couldn't produce [X?, Y?] from a recursive conditional. That's technically true (conditional types can't emit optional positions) but the wrong framing — the fix swaps tools from conditional recursion to a homomorphic mapped type, where the ? modifier attaches to each position rather than the value type. When T is a tuple, { [K in keyof T]?: ... } iterates the tuple indices and preserves tuple-ness; the tuple-ness of the input is load-bearing.

The test assertion at this line was updated in the same commit from [X | undefined, Y | undefined] to [X, Y?, Z?].

[boneskull]

This seems dubious. Why even declare innerShape if we throw away the type? Why use typeof casted when we could use CastedPattern<'agoric1xyz'> instead?

[turadg]

Good catch. I've tightened up the test to verify CastedPattern's phantom is optional.

const casted: CastedPattern<'agoric1xyz'> = innerShape;

[boneskull]

Given the val: string, the assertion is pretty useless.