carrick 0.3.101 → 0.3.103

package/sidecar/dist/src/type-inferrer.js

@@ -20,7 +20,7 @@
 import * as path from 'node:path';
 import { Node, SyntaxKind, ts, } from 'ts-morph';
 import { validateInferRequestItem } from './validators.js';
-import { isExternalOrigin } from './origin.js';
+import { externalImportsOf, isExternalOrigin } from './origin.js';
 import { addedDiagnostics, applyInsertions, fileDiagnostics, literalInsertions, mapBack, mapForward, normalise, pathOf, } from './unwidened.js';
 import { expandTypeStructural, } from './type-structural-expander.js';
 /**
@@ -277,6 +277,7 @@ export class TypeInferrer {
         return {
             program: this.project.getProgram().compilerObject,
             repoRoot: this.repoRoot,
+            imports: externalImportsOf(this.project),
         };
     }
     /**
@@ -940,7 +941,9 @@ export class TypeInferrer {
                 this.log(`Span resolves to a callback-registration call at ${request.file_path}:${request.line_number}; no payload to infer`);
                 return null;
             }
-            if (args.length > 0) {
+            // A call whose result is a value the repo shapes is not a send: it is
+            // the payload (carrick#1732), and drilling would publish its input.
+            if (args.length > 0 && !this.callResultIsPayload(node)) {
                 payloadNode = args[0];
             }
         }
@@ -973,6 +976,31 @@ export class TypeInferrer {
         const anchor = this.unwrapArrayLevels(this.unwrapPromiseType(payloadType));
         return this.createInferredType(request, typeString, false, this.getNodeLocation(payloadNode), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined, this.primaryTypeSymbol(anchor.element), anchor.depth);
     }
+    /**
+     * True when a located call's own result is the route's payload, so the
+     * transitional drill into its first argument must not run (carrick#1732).
+     *
+     * `res.json(users)` reached that drill because nothing above it recognised
+     * the send: its result reads `void`, `any` or `unknown`, and the payload is
+     * the argument. `toPublicView(row)` is the opposite case: a mapper building
+     * the object the route sends. Its first argument is the row it was built
+     * FROM, which carries columns the route never sends.
+     *
+     * The call's result decides, not where its callee is declared. It is the
+     * payload when it reads as one by the rule a response helper's argument is
+     * read with (`nodeCarriesPayloadContract`: object-shaped, not machinery,
+     * not `void`/`any`/`unknown`) and the object is not a library's own: a
+     * codec's writer from `encode(message)` or a reply builder from a send is
+     * the library describing itself, and keeps the drill. A library call that
+     * returns the repo's own type (`toInstance(View, plain)`) is the payload.
+     */
+    callResultIsPayload(call) {
+        const { element } = this.unwrapArrayLevels(this.unwrapPromiseType(call.getType()));
+        if (this.symbolIsLibOrExternalOrigin(element.getSymbol() ?? element.getAliasSymbol())) {
+            return false;
+        }
+        return this.nodeCarriesPayloadContract(call, false);
+    }
     /**
      * The wire representation a request's printed type takes. A route response
      * is serialised as JSON by every sender this layer reads a payload out of,
@@ -1309,7 +1337,132 @@ export class TypeInferrer {
                 }
             }
         }
-        return this.createInferredType(request, typeString, isExplicit, this.getNodeLocation(terminalNode), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined, anchor ? this.primaryTypeSymbol(anchor.element) : undefined, anchor?.depth);
+        const inferred = this.createInferredType(request, typeString, isExplicit, this.getNodeLocation(terminalNode), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined, anchor ? this.primaryTypeSymbol(anchor.element) : undefined, anchor?.depth);
+        // carrick#1749: say when the text is the source's own statement of the
+        // body, and what that statement is rooted at, so the scanner can tell a
+        // model symbol that names the body from one that names a part of it.
+        const statedBody = explicitType ? this.statedBodyAtRead(terminalNode) : undefined;
+        if (statedBody) {
+            inferred.stated_body = statedBody;
+        }
+        return inferred;
+    }
+    /**
+     * What the source states the body read at `terminal` to be, when the type
+     * `extractExplicitTypeFromAncestor` printed for it is stated AT the read
+     * (carrick#1749): the read is the operand of that cast, or the initializer
+     * of that annotated declaration, through wrappers that leave a value as it
+     * is (parentheses, `await`, `!`, another cast). An annotation further out —
+     * the declared type of the function the read sits in — describes something
+     * else, and is not reported.
+     */
+    statedBodyAtRead(terminal) {
+        const typeNode = this.explicitTypeNodeFromAncestor(terminal);
+        const owner = typeNode?.getParent();
+        if (!typeNode || !owner || this.leavesAPositionOpen(typeNode))
+            return undefined;
+        let current = terminal;
+        for (;;) {
+            if (current === owner)
+                break;
+            const parent = current.getParent();
+            if (!parent)
+                return undefined;
+            if (parent === owner &&
+                Node.isVariableDeclaration(parent) &&
+                parent.getInitializer() === current) {
+                break;
+            }
+            if (!Node.isParenthesizedExpression(parent) &&
+                !Node.isAwaitExpression(parent) &&
+                !Node.isNonNullExpression(parent) &&
+                !Node.isAsExpression(parent) &&
+                !Node.isTypeAssertion(parent) &&
+                !Node.isSatisfiesExpression(parent)) {
+                return undefined;
+            }
+            current = parent;
+        }
+        return this.statedRoot(typeNode);
+    }
+    /**
+     * A stated type with `any` or `unknown` written anywhere in it (`unknown`,
+     * `Record<string, unknown>`, `{ items: any[] }`) leaves a position open: it
+     * is a placeholder the source narrows later (`const data: unknown = await
+     * res.json()`, then `data as Entry[]`), not its statement of the body.
+     */
+    leavesAPositionOpen(typeNode) {
+        const open = (node) => node.getKind() === SyntaxKind.AnyKeyword || node.getKind() === SyntaxKind.UnknownKeyword;
+        return open(typeNode) || typeNode.getDescendants().some(open);
+    }
+    /**
+     * The named root of a stated body type: `Promise<...>` and `PromiseLike`
+     * (the language's await protocol), array levels, parentheses, `readonly`
+     * and `| null`/`| undefined` are peeled, and what is left is either a type
+     * reference, whose name is the root, or anything else, which has none.
+     */
+    statedRoot(typeNode) {
+        let node = typeNode;
+        let depth = 0;
+        for (let step = 0; step < 16; step++) {
+            if (Node.isParenthesizedTypeNode(node)) {
+                node = node.getTypeNode();
+                continue;
+            }
+            if (Node.isArrayTypeNode(node)) {
+                node = node.getElementTypeNode();
+                depth++;
+                continue;
+            }
+            if (Node.isTypeOperatorTypeNode(node) &&
+                node.getOperator() === SyntaxKind.ReadonlyKeyword) {
+                node = node.getTypeNode();
+                continue;
+            }
+            if (Node.isUnionTypeNode(node)) {
+                const present = node
+                    .getTypeNodes()
+                    .filter((member) => !((Node.isLiteralTypeNode(member) &&
+                    member.getLiteral().getKind() === SyntaxKind.NullKeyword) ||
+                    member.getKind() === SyntaxKind.UndefinedKeyword ||
+                    member.getKind() === SyntaxKind.NullKeyword));
+                if (present.length === 1) {
+                    node = present[0];
+                    continue;
+                }
+                break;
+            }
+            if (Node.isTypeReference(node)) {
+                const name = node.getTypeName().getText();
+                const args = node.getTypeArguments();
+                if (args.length === 1 && (name === 'Promise' || name === 'PromiseLike')) {
+                    node = args[0];
+                    continue;
+                }
+                if (args.length === 1 && (name === 'Array' || name === 'ReadonlyArray')) {
+                    node = args[0];
+                    depth++;
+                    continue;
+                }
+            }
+            break;
+        }
+        const depthField = depth > 0 ? { array_depth: depth } : {};
+        if (!Node.isTypeReference(node)) {
+            return depthField;
+        }
+        const typeName = node.getTypeName();
+        const nameNode = Node.isQualifiedName(typeName) ? typeName.getRight() : typeName;
+        let symbol = nameNode.getSymbol();
+        if (symbol?.isAlias()) {
+            symbol = symbol.getAliasedSymbol() ?? symbol;
+        }
+        const source = symbol?.getDeclarations()[0]?.getSourceFile().getFilePath();
+        return {
+            root: nameNode.getText(),
+            ...(source ? { root_source: source } : {}),
+            ...depthField,
+        };
     }
     inferVariable(sourceFile, request, extractionConfig) {
         const node = this.resolveTargetNode(sourceFile, request);
@@ -1632,6 +1785,14 @@ export class TypeInferrer {
     // Call Result Resolution
     // ===========================================================================
     resolveCallResultTerminalNode(callExpr, func) {
+        // carrick#1749: the call starts a chain, and a callback in it is handed
+        // the body unread and casts it. That cast is the body read, and it comes
+        // before the return-statement answer below, which for a chain is the
+        // value the caller computed from the body, not the body.
+        const chainRead = this.bodyReadInCallbackChain(callExpr);
+        if (chainRead) {
+            return { terminal: chainRead, projectionOnly: false, projections: [] };
+        }
         const returnStmt = callExpr.getFirstAncestorByKind(SyntaxKind.ReturnStatement);
         if (returnStmt) {
             const returnExpr = returnStmt.getExpression();
@@ -2094,6 +2255,80 @@ export class TypeInferrer {
      * HTTP response is read exactly this way whatever produced the response, so
      * the shape is structural, not a framework's name.
      */
+    /**
+     * The body read inside a chain that starts at `callExpr` (carrick#1749):
+     * `request(url).check(ok).mapOk(response => { const data = response as
+     * SearchResponse; ... })`.
+     *
+     * The chain is the run of member calls whose receiver is the call, then
+     * that call's result, and so on. A callback passed to one of them whose
+     * first parameter the compiler types `unknown` is handed a value nothing
+     * has typed yet, which is what a parsed body is; where the source casts
+     * that parameter, the cast is what the caller says the body is. The value
+     * the chain ends in is what the caller computed from it, and publishing
+     * that as the body is the false mismatch this rule exists for.
+     *
+     * Exactly one such cast across the whole chain answers. None, or more than
+     * one (a callback on the failure side can be handed an `unknown` too), and
+     * the walk carries on as before. A parameter typed `any` is not read: an
+     * unresolved library types every callback that way, success and failure
+     * alike, so it says nothing about which one is the body.
+     */
+    bodyReadInCallbackChain(callExpr) {
+        const reads = [];
+        let receiver = callExpr;
+        for (let link = 0; link < 64; link++) {
+            const access = receiver.getParent();
+            if (!access ||
+                !Node.isPropertyAccessExpression(access) ||
+                access.getExpression() !== receiver) {
+                break;
+            }
+            const call = access.getParent();
+            if (!call || !Node.isCallExpression(call) || call.getExpression() !== access) {
+                break;
+            }
+            for (const arg of call.getArguments()) {
+                if (Node.isArrowFunction(arg) || Node.isFunctionExpression(arg)) {
+                    reads.push(...this.castsOfUnreadParameter(arg));
+                }
+            }
+            receiver = call;
+        }
+        return reads.length === 1 ? reads[0] : undefined;
+    }
+    /**
+     * The casts of a callback's first parameter, when the compiler types that
+     * parameter `unknown`: `response as T` and `<T>response`, the operand being
+     * the parameter itself. A cast that leaves a position open states nothing
+     * about the body and is skipped.
+     */
+    castsOfUnreadParameter(callback) {
+        const param = callback.getParameters()[0];
+        const name = param?.getNameNode();
+        if (!param || !name || !Node.isIdentifier(name) || !param.getType().isUnknown()) {
+            return [];
+        }
+        const symbol = name.getSymbol();
+        if (!symbol)
+            return [];
+        return callback.getDescendants().filter((node) => {
+            if (!Node.isAsExpression(node) && !Node.isTypeAssertion(node))
+                return false;
+            let operand = node.getExpression();
+            while (Node.isParenthesizedExpression(operand)) {
+                operand = operand.getExpression();
+            }
+            if (!Node.isIdentifier(operand) || operand.getSymbol() !== symbol)
+                return false;
+            const stated = node.getType();
+            const statedNode = node.getTypeNode();
+            return (!!statedNode &&
+                !stated.isAny() &&
+                !stated.isUnknown() &&
+                !this.leavesAPositionOpen(statedNode));
+        });
+    }
     bodyReadOnReceiver(identifier) {
         const access = identifier.getParent();
         if (!access ||
@@ -2610,7 +2845,7 @@ export class TypeInferrer {
         }
         const program = this.project.getProgram().compilerObject;
         for (const decl of symbol.getDeclarations()) {
-            if (isExternalOrigin(program, decl.getSourceFile().compilerNode, this.repoRoot)) {
+            if (isExternalOrigin(program, decl.getSourceFile().compilerNode, this.repoRoot, externalImportsOf(this.project))) {
                 return true;
             }
         }
@@ -2796,11 +3031,16 @@ export class TypeInferrer {
         return this.unwrapExpressionNode(args[0]);
     }
     extractExplicitTypeFromAncestor(node) {
+        const typeNode = this.explicitTypeNodeFromAncestor(node);
+        return typeNode ? this.expandAnnotationTypeNode(typeNode) : null;
+    }
+    /** The annotation `extractExplicitTypeFromAncestor` prints, as a node. */
+    explicitTypeNodeFromAncestor(node) {
         const varDecl = node.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
         if (varDecl) {
             const typeNode = varDecl.getTypeNode();
             if (typeNode) {
-                return this.expandAnnotationTypeNode(typeNode);
+                return typeNode;
             }
         }
         // Consider the node ITSELF as well as its ancestors: the `call_result`
@@ -2813,7 +3053,7 @@ export class TypeInferrer {
         if (asExpr) {
             const typeNode = asExpr.getTypeNode();
             if (typeNode) {
-                return this.expandAnnotationTypeNode(typeNode);
+                return typeNode;
             }
         }
         const typeAssertion = Node.isTypeAssertion(node)
@@ -2822,10 +3062,10 @@ export class TypeInferrer {
         if (typeAssertion) {
             const typeNode = typeAssertion.getTypeNode();
             if (typeNode) {
-                return this.expandAnnotationTypeNode(typeNode);
+                return typeNode;
             }
         }
-        return null;
+        return undefined;
     }
     /**
      * Render an explicit annotation (`as T`, `<T>`, or a typed binding) as

package/sidecar/dist/src/type-structural-expander.d.ts

@@ -29,6 +29,7 @@
  * structural form rather than a dangling name.
  */
 import { type Node, type Type, ts } from 'ts-morph';
+import { type ExternalImports } from './origin.js';
 /**
  * Bound on the structural-expansion recursion. Deep enough for every realistic
  * request/response shape; a backstop against pathological/recursive types the
@@ -83,11 +84,14 @@ export type WireFormat = 'declared' | 'json';
  * its own cache leaves no such segment in the path (carrick#1264). The program
  * carries the resolver's own verdict, so it is what `isExternalOrigin` is
  * asked — the same instrument the inference path uses, so the two layers
- * cannot disagree about which types to inline.
+ * cannot disagree about which types to inline. `imports` is that verdict kept
+ * past the program rebuilds that drop it (carrick#1731), for a project the
+ * loader built.
  */
 export interface ExpandOrigin {
     readonly program: ts.Program;
     readonly repoRoot: string;
+    readonly imports?: ExternalImports;
 }
 /** Everything `expandTypeStructural` takes besides the type and its origin. */
 export interface ExpandOptions {

package/sidecar/dist/src/type-structural-expander.js

@@ -366,7 +366,7 @@ function isLibraryType(type, origin) {
     const decls = symbol.getDeclarations();
     if (decls.length === 0)
         return false;
-    return decls.some((decl) => isExternalOrigin(origin.program, decl.getSourceFile().compilerNode, origin.repoRoot));
+    return decls.some((decl) => isExternalOrigin(origin.program, decl.getSourceFile().compilerNode, origin.repoRoot, origin.imports));
 }
 /**
  * Non-expanded text for a type. Passes `undefined` as the enclosing node so

package/sidecar/dist/src/types.d.ts

@@ -97,21 +97,6 @@ export interface TsconfigSnapshot {
         [key: string]: unknown;
     };
 }
-/**
- * Metadata for a single repository in the synthetic monorepo.
- */
-export interface RepoMetadata {
-    /** Unique name for this repo (used in @carrick/{repoName}/...) */
-    repoName: string;
-    /** Pinned dependency versions for this repo */
-    dependencies: PinnedDependencySnapshot;
-    /** Closed tsconfig snapshot for this repo */
-    tsconfig: TsconfigSnapshot;
-    /** Extraction config for unwrapping machinery types */
-    extractionConfig?: ExtractionConfig;
-    /** The emitted surface .d.ts content (after Task 2) */
-    surfaceContent?: string;
-}
 /**
  * Base fields present in all requests
  */
@@ -132,36 +117,11 @@ export interface InitRequest extends BaseRequest {
 }
 /**
  * Request to bundle explicit types from source files
- * @deprecated Use emit_surface instead for the new architecture
  */
 export interface BundleRequest extends BaseRequest {
     action: 'bundle';
     symbols: SymbolRequest[];
 }
-/**
- * Request to emit a surface .d.ts file with rewritten module specifiers
- */
-export interface EmitSurfaceRequest extends BaseRequest {
-    action: 'emit_surface';
-    /** The repo name for specifier rewriting (@carrick/{repoName}/...) */
-    repo_name: string;
-    /** Payload types to include in the surface */
-    payloads: PayloadDefinition[];
-    /** Output path for the surface .d.ts file */
-    output_path: string;
-}
-/**
- * Definition of a payload type to emit
- */
-export interface PayloadDefinition {
-    /** Alias/name for this payload in the surface */
-    alias: string;
-    /** The type string (already unwrapped from machinery) */
-    type_string: string;
-    /** Optional source information */
-    source_file?: string;
-    source_location?: SourceLocation;
-}
 /**
  * Request to run the v2 "tsc as serializer" capture for one service.
  * Produces a types-only stub package (compiler-emitted declaration tree +
@@ -223,40 +183,6 @@ export interface InferRequest extends BaseRequest {
     /** Agent-generated extraction config for machinery unwrapping */
     extraction_config?: ExtractionConfig;
 }
-/**
- * Request to build the synthetic monorepo workspace
- */
-export interface BuildWorkspaceRequest extends BaseRequest {
-    action: 'build_workspace';
-    repos: RepoMetadata[];
-    /** Root directory for the workspace (defaults to .carrick/workspace) */
-    workspace_root?: string;
-}
-/**
- * Request to run type compatibility checks
- */
-export interface CheckCompatibilityRequest extends BaseRequest {
-    action: 'check_compatibility';
-    /** Path to the workspace root */
-    workspace_root: string;
-    /** Pairs of types to check for compatibility */
-    checks: CompatibilityCheck[];
-}
-/**
- * A single compatibility check between two types
- */
-export interface CompatibilityCheck {
-    /** Source repo name */
-    source_repo: string;
-    /** Source payload alias */
-    source_alias: string;
-    /** Target repo name */
-    target_repo: string;
-    /** Target payload alias */
-    target_alias: string;
-    /** Direction: 'source_extends_target' or 'target_extends_source' or 'bidirectional' */
-    direction: 'source_extends_target' | 'target_extends_source' | 'bidirectional';
-}
 /**
  * Health check request
  */
@@ -524,7 +450,7 @@ export interface ListLibrarySurfaceRequest extends BaseRequest {
 /**
  * Union type for all possible sidecar requests
  */
-export type SidecarRequest = RetypeCheckRequest | VerifyClientSemanticsRequest | VerifyLibraryClaimsRequest | ListLibrarySurfaceRequest | InitRequest | BundleRequest | EmitSurfaceRequest | CaptureV2Request | CheckV2Request | InferRequest | BuildWorkspaceRequest | CheckCompatibilityRequest | ResolveDefinitionsRequest | HealthRequest | ShutdownRequest;
+export type SidecarRequest = RetypeCheckRequest | VerifyClientSemanticsRequest | VerifyLibraryClaimsRequest | ListLibrarySurfaceRequest | InitRequest | BundleRequest | CaptureV2Request | CheckV2Request | InferRequest | ResolveDefinitionsRequest | HealthRequest | ShutdownRequest;
 /**
  * Request for a specific symbol to be bundled
  */
@@ -588,7 +514,6 @@ export interface InitResponse extends BaseResponse {
 }
 /**
  * Response for bundle action
- * @deprecated Use EmitSurfaceResponse instead
  */
 export interface BundleResponse extends BaseResponse {
     /** The bundled .d.ts content */
@@ -600,27 +525,6 @@ export interface BundleResponse extends BaseResponse {
     /** General errors */
     errors?: string[];
 }
-/**
- * Response for emit_surface action
- */
-export interface EmitSurfaceResponse extends BaseResponse {
-    /** Path to the emitted surface file */
-    output_path?: string;
-    /** The emitted .d.ts content */
-    surface_content?: string;
-    /** Manifest of emitted payloads */
-    manifest?: SurfaceManifestEntry[];
-    /** Errors during emission */
-    errors?: string[];
-}
-/**
- * Entry in the surface manifest
- */
-export interface SurfaceManifestEntry {
-    alias: string;
-    type_string: string;
-    rewritten_imports: string[];
-}
 /**
  * Response for infer action
  */
@@ -630,42 +534,6 @@ export interface InferResponse extends BaseResponse {
     /** General errors */
     errors?: string[];
 }
-/**
- * Response for build_workspace action
- */
-export interface BuildWorkspaceResponse extends BaseResponse {
-    /** Path to the created workspace */
-    workspace_path?: string;
-    /** Paths to generated stub packages */
-    stub_packages?: string[];
-    /** Path to the checker package */
-    checker_path?: string;
-    /** Errors during workspace creation */
-    errors?: string[];
-}
-/**
- * Response for check_compatibility action
- */
-export interface CheckCompatibilityResponse extends BaseResponse {
-    /** Results of each compatibility check */
-    results?: CompatibilityResult[];
-    /** TypeScript compiler diagnostics */
-    diagnostics?: string[];
-    /** Errors during checking */
-    errors?: string[];
-}
-/**
- * Result of a single compatibility check
- */
-export interface CompatibilityResult {
-    source_repo: string;
-    source_alias: string;
-    target_repo: string;
-    target_alias: string;
-    compatible: boolean;
-    /** Diagnostic message if not compatible */
-    diagnostic?: string;
-}
 /**
  * Response for resolve_definitions action
  */
@@ -838,7 +706,7 @@ export interface ListLibrarySurfaceResponse extends BaseResponse {
 /**
  * Union type for all possible sidecar responses
  */
-export type SidecarResponse = RetypeCheckResponse | VerifyClientSemanticsResponse | VerifyLibraryClaimsResponse | ListLibrarySurfaceResponse | InitResponse | BundleResponse | EmitSurfaceResponse | CaptureV2Response | CheckV2Response | InferResponse | BuildWorkspaceResponse | CheckCompatibilityResponse | ResolveDefinitionsResponse | HealthResponse | ShutdownResponse | ErrorResponse;
+export type SidecarResponse = RetypeCheckResponse | VerifyClientSemanticsResponse | VerifyLibraryClaimsResponse | ListLibrarySurfaceResponse | InitResponse | BundleResponse | CaptureV2Response | CheckV2Response | InferResponse | ResolveDefinitionsResponse | HealthResponse | ShutdownResponse | ErrorResponse;
 /**
  * An entry in the type manifest
  */
@@ -938,6 +806,35 @@ export interface InferredType {
      * was dropped as unsound.
      */
     unwidened_type_string?: string;
+    /**
+     * carrick#1749, `call_result` only: present when the source itself states
+     * the type of the body it reads, AT the read: a cast of the read
+     * (`res.json() as Promise<T>`, a callback's `value as T`) or the annotated
+     * declaration it initializes (`const data: T = await res.json()`). The
+     * text in `type_string` is then that statement. Absent when no type is
+     * stated, or when the only annotation is further away than the read.
+     */
+    stated_body?: StatedBody;
+}
+/**
+ * What the source states a body read to be (carrick#1749). The scanner
+ * compares `root` with the type symbol the model named for the same call: a
+ * model symbol that is not the stated root names something other than the
+ * body (an element of it, or a value the caller later computed from it), and
+ * the source's own statement outranks it.
+ */
+export interface StatedBody {
+    /**
+     * The name the stated type is rooted at, once `Promise<...>`, array levels,
+     * parentheses and `| null`/`| undefined` are peeled: `Order` for
+     * `Promise<Order[] | null>`, `Page` for `Page<Order>`. Absent when the root
+     * is not a named type (an object literal type, a union of several types).
+     */
+    root?: string;
+    /** Declaration file (absolute path) of `root`, when it resolves to one. */
+    root_source?: string;
+    /** Array levels peeled on the way to `root`. Omitted when 0. */
+    array_depth?: number;
 }
 /**
  * Why a type carries `any`/`unknown` at a position, and where.
@@ -977,7 +874,6 @@ export interface SymbolFailure {
 }
 /**
  * Internal result from the bundler
- * @deprecated Use SurfaceEmitResult instead
  */
 export interface BundleResult {
     /** Whether bundling was successful */
@@ -991,21 +887,6 @@ export interface BundleResult {
     /** General error messages */
     errors?: string[];
 }
-/**
- * Internal result from surface emission
- */
-export interface SurfaceEmitResult {
-    /** Whether emission was successful */
-    success: boolean;
-    /** The emitted .d.ts content */
-    surface_content?: string;
-    /** Output path where content was written */
-    output_path?: string;
-    /** Manifest of emitted payloads */
-    manifest?: SurfaceManifestEntry[];
-    /** General error messages */
-    errors?: string[];
-}
 /**
  * Internal result from the type inferrer
  */
@@ -1017,32 +898,4 @@ export interface InferResult {
     /** General error messages */
     errors?: string[];
 }
-/**
- * Result from building the synthetic workspace
- */
-export interface WorkspaceBuildResult {
-    /** Whether build was successful */
-    success: boolean;
-    /** Path to the workspace root */
-    workspace_path?: string;
-    /** Paths to stub packages */
-    stub_packages?: string[];
-    /** Path to the checker package */
-    checker_path?: string;
-    /** Error messages */
-    errors?: string[];
-}
-/**
- * Result from running compatibility checks
- */
-export interface CompatibilityCheckResult {
-    /** Whether checks ran successfully (not whether types are compatible) */
-    success: boolean;
-    /** Individual check results */
-    results?: CompatibilityResult[];
-    /** TypeScript diagnostics */
-    diagnostics?: string[];
-    /** Error messages */
-    errors?: string[];
-}
 export {};