@apifuse/provider-sdk 2.2.0-beta.63 → 2.2.0-beta.64

package/dist/lint.js

@@ -1,20 +1,12 @@
-import { createRequire } from "node:module";
 import { SDK_CANONICAL_ERROR_CODE_RETRYABILITY, SDK_RUNTIME_OWNED_ERROR_CODES, SDK_STATUS_MAPPED_PROVIDER_ERROR_CODES, } from "./error-resolution.js";
-import { APIFUSE_HANDLE_META_KEY, handleFieldDescription, handleIssuerList, isHandleIssuedBy, isHandleFieldMeta, } from "./handle-meta.js";
+import { APIFUSE_HANDLE_META_KEY, handleFieldDescription, handleFieldNameFor, handleHasDirectionalFieldNames, handleIssuerList, isHandleFieldMeta, isHandleIssuedBy, } from "./handle-meta.js";
 import { PROVIDER_ERROR_CATALOG_NAMESPACE } from "./i18n/error-messages.js";
 import { getProviderLocaleSegments, isProviderLocaleKey, } from "./i18n/keys.js";
 import { lintPublicSchemaFieldNames } from "./public-schema-field-lint.js";
 import { isStealthOwnedHeaderName, SDK_OWNED_CHROME_HEADER_PREFIX, } from "./runtime/stealth-owned-headers.js";
+import { lintRuntimeBoundary, scriptKindForSourceFile } from "./runtime-boundary-lint.js";
 import { APIFUSE_DESCRIPTION_KEY_META_KEY, APIFUSE_SENSITIVE_META_KEY } from "./schema.js";
-const requireModule = createRequire(import.meta.url);
-// `typeof import(...)` keeps the type without emitting a static import: the
-// typescript package is a CLI-only dependency and src/lint.ts is production
-// runtime, which the typescript-import-boundary test enforces.
-let typeScriptModule;
-function getTypeScript() {
-    typeScriptModule ??= requireModule("typescript");
-    return typeScriptModule;
-}
+import { getTypeScript } from "./typescript-module.js";
 const CREDENTIAL_BEARING_AUTH_MODES = [
     "credentials",
     "oauth2",
@@ -860,9 +852,9 @@ function isReportedOwnedHeaderName(value) {
     }
     return name.startsWith(OWNED_CLIENT_HINT_HEADER_PREFIX);
 }
-function collectBrowserVersionLiteralFindings(source) {
+function collectBrowserVersionLiteralFindings(fileName, source) {
     const ts = getTypeScript();
-    const sourceFile = ts.createSourceFile("provider-source.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, scriptKindForSourceFile(ts, fileName));
     let findings = [];
     const seen = new Set();
     // Owned-header entries only count once the file is known to reach
@@ -980,19 +972,27 @@ function lintBrowserVersionLiterals(provider) {
         !RECORDED_FIXTURE_SOURCE_FILE_PATTERN.test(filePath));
     if (sourceFiles.length > 0) {
         for (const [filePath, source] of sourceFiles) {
-            sources.push({ field: `sourceFiles.${filePath}`, source });
+            sources.push({ field: `sourceFiles.${filePath}`, fileName: filePath, source });
         }
     }
     else {
         if (provider.authFlowSource)
-            sources.push({ field: "auth.flow", source: provider.authFlowSource });
+            sources.push({
+                field: "auth.flow",
+                fileName: "auth-flow.ts",
+                source: provider.authFlowSource,
+            });
         for (const [operationKey, operation] of Object.entries(provider.operations ?? {})) {
             const source = getOperationSource(operation);
             if (source)
-                sources.push({ field: `operations.${operationKey}.handler`, source });
+                sources.push({
+                    field: `operations.${operationKey}.handler`,
+                    fileName: `${operationKey}.ts`,
+                    source,
+                });
         }
     }
-    return sources.flatMap(({ field, source }) => collectBrowserVersionLiteralFindings(source).map((finding) => ({
+    return sources.flatMap(({ field, fileName, source }) => collectBrowserVersionLiteralFindings(fileName, source).map((finding) => ({
         rule: "browser-version-literal",
         level: "error",
         field,
@@ -1565,6 +1565,7 @@ function readHandleKindDeclarations(value) {
         return (typeof record.name === "string" &&
             (record.type === "cursor" || record.type === "draft") &&
             typeof record.fieldName === "string" &&
+            (record.outputFieldName === undefined || typeof record.outputFieldName === "string") &&
             (record.issuedBy === undefined || isHandleIssuedBy(record.issuedBy)));
     });
 }
@@ -1600,7 +1601,13 @@ function lintHandleDeclarations(provider) {
         for (const { side, fields } of positions) {
             for (const occurrence of fields) {
                 const field = `operations.${operationKey}.${occurrence.path}`;
-                const { kind, fieldName } = occurrence.meta;
+                const { kind } = occurrence.meta;
+                // A kind may name one handle differently in each direction (the canon's
+                // `cursor` in, `next_cursor` out). The rule is still exact: each side
+                // must use the key declared for THAT side, so the handle's identity
+                // stays readable from the property key and the round trip has exactly
+                // one edge — read `output`, send back under `input`.
+                const expected = handleFieldNameFor(occurrence.meta, side);
                 if (!kindByName.has(kind)) {
                     diagnostics.push({
                         rule: "handle-kind-undeclared",
@@ -1609,12 +1616,16 @@ function lintHandleDeclarations(provider) {
                         message: `${providerLabel} operation "${operationKey}" ${side} field "${occurrence.path}" is a handle of kind "${kind}", which is not declared in provider.handle. Add the kind to handle: [...] or remove the field.`,
                     });
                 }
-                if (occurrence.key !== fieldName) {
+                if (occurrence.key !== expected) {
+                    const directional = handleHasDirectionalFieldNames(occurrence.meta);
+                    const advice = directional
+                        ? `Use the kind's ${side} fieldName on every ${side} schema; its ${side === "input" ? "output" : "input"} fieldName is "${handleFieldNameFor(occurrence.meta, side === "input" ? "output" : "input")}".`
+                        : "Use the same key in every schema so the LLM sees one name.";
                     diagnostics.push({
                         rule: "handle-field-name",
                         level: "error",
                         field,
-                        message: `${providerLabel} operation "${operationKey}" ${side} declares handle kind "${kind}" under property "${occurrence.key}" but the kind's fieldName is "${fieldName}". Use the same key in every schema so the LLM sees one name.`,
+                        message: `${providerLabel} operation "${operationKey}" ${side} declares handle kind "${kind}" under property "${occurrence.key}" but the kind's ${directional ? `${side} ` : ""}fieldName is "${expected}". ${advice}`,
                     });
                 }
                 if (side === "input") {
@@ -1641,7 +1652,7 @@ function lintHandleDeclarations(provider) {
                 rule: "handle-field-parity",
                 level: "error",
                 field,
-                message: `${providerLabel} handle kind "${kind.name}" is never issued: no operation output contains its field "${kind.fieldName}". Add ${kind.name}.field() to the issuing operation's output.`,
+                message: `${providerLabel} handle kind "${kind.name}" is never issued: no operation output contains its field "${handleFieldNameFor(kind, "output")}". Add ${kind.name}.field() to the issuing operation's output.`,
             });
         }
         if (!accepted) {
@@ -1649,7 +1660,7 @@ function lintHandleDeclarations(provider) {
                 rule: "handle-field-parity",
                 level: "error",
                 field,
-                message: `${providerLabel} handle kind "${kind.name}" is never accepted: no operation input contains its field "${kind.fieldName}". Add ${kind.name}.field() to the consuming operation's input.`,
+                message: `${providerLabel} handle kind "${kind.name}" is never accepted: no operation input contains its field "${handleFieldNameFor(kind, "input")}". Add ${kind.name}.field() to the consuming operation's input.`,
             });
         }
         if (kind.issuedBy === undefined)
@@ -1676,7 +1687,7 @@ function lintHandleDeclarations(provider) {
                 rule: "handle-issued-by",
                 level: "error",
                 field,
-                message: `${providerLabel} handle kind "${kind.name}" declares issuedBy "${known[0]}", but that operation's output has no "${kind.fieldName}" handle field.`,
+                message: `${providerLabel} handle kind "${kind.name}" declares issuedBy "${known[0]}", but that operation's output has no "${handleFieldNameFor(kind, "output")}" handle field.`,
             });
         }
         else {
@@ -1686,7 +1697,7 @@ function lintHandleDeclarations(provider) {
                 field,
                 message: `${providerLabel} handle kind "${kind.name}" declares issuedBy ${known
                     .map((operationKey) => `"${operationKey}"`)
-                    .join(", ")}, but none of those operations' outputs has a "${kind.fieldName}" handle field. At least one listed issuer must output it.`,
+                    .join(", ")}, but none of those operations' outputs has a "${handleFieldNameFor(kind, "output")}" handle field. At least one listed issuer must output it.`,
             });
         }
     }
@@ -1711,7 +1722,7 @@ const LEGACY_CHOICE_IDENTIFIERS = new Set([
  * the provider) while code inside `${}` interpolations still does. Falls back
  * to a raw-source regex when TypeScript is not installed.
  */
-function findLegacyChoiceUsage(source) {
+function findLegacyChoiceUsage(fileName, source) {
     let ts;
     try {
         ts = getTypeScript();
@@ -1719,7 +1730,7 @@ function findLegacyChoiceUsage(source) {
     catch {
         return LEGACY_CHOICE_USAGE_PATTERN.exec(source)?.[0];
     }
-    const file = ts.createSourceFile("provider.ts", source, ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX);
+    const file = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, false, scriptKindForSourceFile(ts, fileName));
     let found;
     const visit = (node) => {
         if (found)
@@ -1743,19 +1754,23 @@ function findLegacyChoiceUsage(source) {
 function lintLegacyChoiceUsage(provider) {
     const sources = [];
     if (provider.authFlowSource) {
-        sources.push({ field: "auth.flow", source: provider.authFlowSource });
+        sources.push({ field: "auth.flow", fileName: "auth-flow.ts", source: provider.authFlowSource });
     }
     for (const [filePath, source] of Object.entries(provider.providerSourceFiles ?? {})) {
-        sources.push({ field: `sourceFiles.${filePath}`, source });
+        sources.push({ field: `sourceFiles.${filePath}`, fileName: filePath, source });
     }
     for (const [operationKey, operation] of Object.entries(provider.operations ?? {})) {
         const source = getOperationSource(operation);
         if (source) {
-            sources.push({ field: `operations.${operationKey}.handler`, source });
+            sources.push({
+                field: `operations.${operationKey}.handler`,
+                fileName: `${operationKey}.ts`,
+                source,
+            });
         }
     }
-    return sources.flatMap(({ field, source }) => {
-        const match = findLegacyChoiceUsage(source);
+    return sources.flatMap(({ field, fileName, source }) => {
+        const match = findLegacyChoiceUsage(fileName, source);
         if (!match)
             return [];
         return [
@@ -1872,6 +1887,10 @@ export function lintProviderWithInformation(provider, options = {}) {
         ...lintLegacyChoiceUsage(provider),
         ...lintHandleDeclarations(provider),
     ];
+    // Runtime boundary rules (process.env, node:fs/net/child_process, raw
+    // fetch) also yield information entries for `@apifuse-allow` acknowledgements.
+    const runtimeBoundary = lintRuntimeBoundary(getTypeScript(), provider, getOperationSource);
+    diagnostics.push(...runtimeBoundary.diagnostics);
     if (provider.operations) {
         const authMode = provider.auth?.mode;
         for (const [operationKey, operation] of Object.entries(provider.operations)) {
@@ -1911,7 +1930,7 @@ export function lintProviderWithInformation(provider, options = {}) {
         }
     }
     if (!provider.operations) {
-        return applyPinnedWireFieldPaths(provider, diagnostics);
+        return withInformation(applyPinnedWireFieldPaths(provider, diagnostics), runtimeBoundary.information);
     }
     diagnostics.push(...Object.entries(provider.operations).flatMap(([operationKey, operation]) => [
         ...lintOperation({
@@ -1930,5 +1949,10 @@ export function lintProviderWithInformation(provider, options = {}) {
             : `operations.${operationKey}`,
         message: `[${operationKey}] ${diagnostic.message}`,
     }))));
-    return applyPinnedWireFieldPaths(provider, diagnostics);
+    return withInformation(applyPinnedWireFieldPaths(provider, diagnostics), runtimeBoundary.information);
+}
+function withInformation(result, information) {
+    if (information.length === 0)
+        return result;
+    return { diagnostics: result.diagnostics, information: [...information, ...result.information] };
 }

package/dist/provider.d.ts

@@ -11,7 +11,7 @@ export { createProviderEnvironment, createInProcessProviderEngine, ENGINE_OWNED_
 export type { ProviderCapabilityKey, ProviderEngine, ProviderEngineAttachmentInput, ProviderEngineBindingCandidates, ProviderEngineCapabilitySurface, ProviderEngineMode, ProviderEngineRequest, ProviderEngineResidentSurface, ProviderEngineSession, ProviderEngineTransport, } from "./engine.js";
 export { getProviderLocalePath, type ProviderErrorMessageParams, providerLocaleKey, qualifyProviderLocaleKey, } from "./i18n/index.js";
 export * from "./handle.js";
-export { APIFUSE_HANDLE_META_KEY, HANDLE_KIND_NAME_PATTERN, handleFieldDescription, isHandleFieldMeta, } from "./handle-meta.js";
+export { APIFUSE_HANDLE_META_KEY, HANDLE_KIND_NAME_PATTERN, handleFieldDescription, handleFieldNameFor, handleHasDirectionalFieldNames, isHandleFieldMeta, } from "./handle-meta.js";
 export { type CreateHandleContextOptions, type CreateTestHandleContextOptions, createHandleContext, createTestHandleContext, type HandleNormalizationClass, type NormalizedHandle, normalizeHandle, } from "./runtime/handle.js";
 export { createMemoryProviderRuntimeState, createUnsupportedProviderRuntimeState, } from "./runtime/state.js";
 export { APIFUSE_CONTENT_PROVENANCE_META_KEY, APIFUSE_CONTENT_TRUST_META_KEY, APIFUSE_DESCRIPTION_KEY_META_KEY, APIFUSE_REDACTION_MARKER, APIFUSE_SENSITIVE_KIND_META_KEY, APIFUSE_SENSITIVE_META_KEY, collectSensitivePaths, describeKey, field, fields, isSensitiveSchema, publicField, redactPayload, type SensitiveFieldKind, type SensitiveFieldOptions, type SensitivePath, sensitive, untrustedContent, z, } from "./schema.js";

package/dist/provider.js

@@ -6,7 +6,7 @@ export { AuthError, HttpRedirectError, isProviderError, isSessionExpiredError, i
 export { createProviderEnvironment, createInProcessProviderEngine, ENGINE_OWNED_PROXY_CREDENTIAL_ENV_NAMES, ENGINE_OWNED_RESOLVER_CREDENTIAL_ENV_NAMES, ENGINE_OWNED_RUNTIME_ENV_NAMES, ENGINE_OWNED_TELEMETRY_ENV_NAMES, isEngineOwnedEnvName, isEngineOwnedProxyCredentialName, isEngineOwnedResolverCredentialName, isEngineOwnedRuntimeEnvName, isEngineOwnedTelemetryEnvName, PROVIDER_CAPABILITY_KEYS, PROVIDER_ENGINE_MODE_ENV, PROVIDER_ENGINE_PROTOCOL_VERSION, readEngineProxyCredentials, } from "./engine.js";
 export { getProviderLocalePath, providerLocaleKey, qualifyProviderLocaleKey, } from "./i18n/index.js";
 export * from "./handle.js";
-export { APIFUSE_HANDLE_META_KEY, HANDLE_KIND_NAME_PATTERN, handleFieldDescription, isHandleFieldMeta, } from "./handle-meta.js";
+export { APIFUSE_HANDLE_META_KEY, HANDLE_KIND_NAME_PATTERN, handleFieldDescription, handleFieldNameFor, handleHasDirectionalFieldNames, isHandleFieldMeta, } from "./handle-meta.js";
 export { createHandleContext, createTestHandleContext, normalizeHandle, } from "./runtime/handle.js";
 export { createMemoryProviderRuntimeState, createUnsupportedProviderRuntimeState, } from "./runtime/state.js";
 export { APIFUSE_CONTENT_PROVENANCE_META_KEY, APIFUSE_CONTENT_TRUST_META_KEY, APIFUSE_DESCRIPTION_KEY_META_KEY, APIFUSE_REDACTION_MARKER, APIFUSE_SENSITIVE_KIND_META_KEY, APIFUSE_SENSITIVE_META_KEY, collectSensitivePaths, describeKey, field, fields, isSensitiveSchema, publicField, redactPayload, sensitive, untrustedContent, z, } from "./schema.js";

package/dist/runtime/handle.js

@@ -11,7 +11,7 @@
 import { randomInt, randomUUID } from "node:crypto";
 import { isProviderError } from "../errors.js";
 import { HandleError, handleRecoverySentence, isDraftKind, } from "../handle.js";
-import { formatHandleIssuers } from "../handle-meta.js";
+import { formatHandleIssuers, handleHasDirectionalFieldNames } from "../handle-meta.js";
 import { BOUND_HANDLE_WORD_COUNT, findHandleWordWithinDistance, HIGH_PUBLIC_HANDLE_WORD_COUNT, ISSUABLE_HANDLE_WORDS, PUBLIC_HANDLE_WORD_COUNT, } from "./handle-wordlist.js";
 import { createMemoryProviderRuntimeState } from "./state.js";
 const RECORD_VERSION = 1;
@@ -153,6 +153,14 @@ export function formatNormalizationClasses(classes) {
 // Errors (spec §5)
 // ---------------------------------------------------------------------------
 function publicCollapsedMessage(kind) {
+    // "a new one" is unambiguous only while the kind has one name. When it is
+    // issued under `next_cursor` and accepted under `cursor`, the caller has to
+    // be told which field to read, so use the full recovery sentence — it names
+    // both keys and is identical for invalid / expired / not-found, which is
+    // what keeps the public collapse indistinguishable.
+    if (handleHasDirectionalFieldNames(kind)) {
+        return `\`${kind.fieldName}\` is not valid or has expired. ${handleRecoverySentence(kind)}`;
+    }
     const issuers = formatHandleIssuers(kind.issuedBy);
     const again = issuers ? `Call ${issuers} again to get a new one.` : "Request a new one.";
     return `\`${kind.fieldName}\` is not valid or has expired. ${again}`;

package/dist/runtime/ocr.js

@@ -42,6 +42,10 @@ function createErrorOcrClient(options) {
         });
     };
     return tagCapability({
+        // Own data property: `bindOcrTelemetry` re-spreads the context, so a
+        // getter or prototype member would silently vanish before reaching
+        // provider code.
+        available: false,
         async recognize() {
             return unavailable();
         },
@@ -274,6 +278,7 @@ function toOcrTransportError(error) {
 }
 function createOcrClient(model, recognize) {
     return {
+        available: true,
         recognize,
         async extractCaptchaText(image, options = {}) {
             const result = await recognize({ image, hint: "captcha" });

package/dist/runtime-boundary-lint.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Runtime boundary lint: provider runtime source must reach the outside world
+ * through the SDK context (`ctx.http`, `ctx.stealth`, `ctx.env`,
+ * `ctx.credential`, `ctx.browser`), not through ambient Node/Bun globals.
+ *
+ * Three rules, all reported at `warn` level in this first release so the
+ * fleet can migrate before the level is raised:
+ *
+ * - `process-env-direct-read`: `process.env.X`, `process.env["X"]`, a bare
+ *   `process.env` object use, and the `Bun.env` equivalents. Runtime bootstrap
+ *   keys (`APIFUSE__RUNTIME__*`) are exempt everywhere because `serve()`
+ *   callers read the port and pod identity before a context exists.
+ * - `node-runtime-module-import`: value imports of `fs`, `fs/promises`, `net`,
+ *   `tls`, `dgram`, `http`, `https`, `http2`, `child_process` (with or without
+ *   the `node:` prefix) via import/export declarations, `require()`, or dynamic
+ *   `import()`, plus the Bun equivalents `Bun.spawn`, `Bun.spawnSync`, `Bun.$`,
+ *   `Bun.file`, `Bun.write`. Type-only imports are not runtime reach and are
+ *   ignored.
+ * - `direct-fetch-call`: a call to the global `fetch` (bare identifier, or
+ *   `globalThis`/`window`/`self`/`global` member). A bare `fetch` call whose
+ *   enclosing scope declares a `fetch` binding (parameter, variable, import,
+ *   function, catch clause) is calling that binding, not the global, and is
+ *   left alone; the check is lexical, so a wrapper that takes `fetch` as a
+ *   parameter does not hide a global `fetch()` elsewhere in the same file.
+ *   `ctx.stealth.fetch()` is a member call and never matches.
+ *
+ * Files are parsed with the script kind their extension implies (`.ts` as
+ * TypeScript, `.tsx` as TSX, …). Parsing everything as TSX would make a
+ * generic arrow (`<T>(value: T) => value`) or an angle-bracket assertion in an
+ * ordinary `.ts` file read as JSX, and everything after it would silently drop
+ * out of the AST.
+ *
+ * Scope is the provider *runtime* source: JavaScript/TypeScript files under
+ * `providerSourceFiles` minus tests, recorded fixtures, the root bootstrap
+ * entrypoints (`dev.ts`, `start.ts`, `deploy.ts`) and the operator tooling
+ * directories (`scripts/`, `tools/`, `bin/`). Tooling legitimately reads the
+ * ambient environment and the filesystem when a human runs it; the rule is
+ * about code the pod executes on behalf of a request.
+ *
+ * A deliberate exception is acknowledged with the same escape hatch the submit
+ * check uses: `// @apifuse-allow <rule>: <reason>` on the finding line or the
+ * line directly above it. Acknowledged findings are reported as information so
+ * `apifuse check` still lists them.
+ */
+import type { LintDiagnostic, ProviderLintInformation, ProviderLintResult } from "./lint.js";
+import { type TypeScriptCompilerModuleLike, type TypeScriptModule } from "./typescript-module.js";
+export declare const PROCESS_ENV_DIRECT_READ_RULE = "process-env-direct-read";
+export declare const NODE_RUNTIME_MODULE_IMPORT_RULE = "node-runtime-module-import";
+export declare const DIRECT_FETCH_CALL_RULE = "direct-fetch-call";
+export declare const RUNTIME_BOUNDARY_RULES: readonly ["process-env-direct-read", "node-runtime-module-import", "direct-fetch-call"];
+export type RuntimeBoundaryRule = (typeof RUNTIME_BOUNDARY_RULES)[number];
+/**
+ * Environment names a provider may read from `process.env` directly. These
+ * are consumed before `serve()` builds a context (port, pod identity), so
+ * `ctx.env` cannot carry them. The whole `APIFUSE__RUNTIME__` family is the
+ * bootstrap contract; nothing else is exempt.
+ */
+export declare const BOOTSTRAP_ENV_NAME_PREFIX = "APIFUSE__RUNTIME__";
+export declare function isBootstrapEnvName(name: string): boolean;
+type RuntimeBoundaryFinding = {
+    rule: RuntimeBoundaryRule;
+    /** 1-based line. */
+    line: number;
+    /** What was reached: the env name, module specifier, or call text. */
+    subject: string;
+};
+type RuntimeBoundaryFileReport = {
+    findings: RuntimeBoundaryFinding[];
+    acknowledged: Array<RuntimeBoundaryFinding & {
+        reason: string;
+    }>;
+};
+/** True for the files the runtime boundary rules look at. */
+export declare function isRuntimeBoundarySourceFile(relativePath: string): boolean;
+/**
+ * Script kind for a provider source file, from its extension. `.tsx`/`.jsx`
+ * enable JSX; everything else (`.ts`, `.mts`, `.cts`, `.js`, `.mjs`, `.cjs`,
+ * and the synthetic names used for in-memory sources) does not, so a generic
+ * arrow or `<T>value` assertion in a `.ts` file parses as TypeScript instead
+ * of swallowing the rest of the file as unterminated JSX.
+ */
+export declare function scriptKindForSourceFile(ts: TypeScriptModule, fileName: string): import("typescript").ScriptKind;
+export declare function analyzeRuntimeBoundary(ts: TypeScriptModule, fileName: string, source: string): RuntimeBoundaryFileReport;
+export type RuntimeBoundaryLintInput = {
+    authFlowSource?: string;
+    providerSourceFiles?: Record<string, string>;
+    operations?: Record<string, {
+        handler?: unknown;
+        source?: string;
+    }>;
+};
+/**
+ * Lint the provider runtime boundary. Returns warn-level diagnostics (one per
+ * file and rule, listing every line) and information entries for findings
+ * acknowledged with `@apifuse-allow`.
+ */
+export declare function lintRuntimeBoundary(ts: TypeScriptModule, provider: RuntimeBoundaryLintInput, readOperationSource: (operation: {
+    handler?: unknown;
+    source?: string;
+}) => string): {
+    diagnostics: LintDiagnostic[];
+    information: ProviderLintInformation[];
+};
+export type LintRuntimeBoundarySourcesOptions = {
+    /**
+     * A loaded TypeScript compiler API module to parse with (`typescript` 6.x
+     * or `@typescript/typescript6`). When omitted the SDK resolves one from its
+     * own install location, trying `typescript` first and falling back to
+     * `@typescript/typescript6` when `typescript` is the 7.x native shell
+     * without `createSourceFile`. A caller whose dependency tree pins its own
+     * compiler module (the APIFuse monorepo contract check) passes it here so
+     * the parse does not depend on what hoists next to the SDK.
+     */
+    typescript?: TypeScriptCompilerModuleLike;
+};
+/**
+ * Lint provider runtime source files for the runtime boundary rules without a
+ * provider definition: `files` maps provider-root-relative paths to source
+ * text (the same shape `apifuse check` collects as `providerSourceFiles`).
+ * Out-of-scope paths (tests, recorded fixtures, `.d.ts`, the root
+ * `dev.ts`/`start.ts`/`deploy.ts`, `scripts/`, `tools/`, `bin/`) are skipped
+ * with `isRuntimeBoundarySourceFile`. Diagnostics carry
+ * `field: "sourceFiles.<path>"`; `@apifuse-allow` acknowledgements come back
+ * as `information`.
+ *
+ * Parses with `options.typescript` when given, otherwise with the compiler
+ * module resolved from the installed SDK (see `getTypeScript`). This is the
+ * entry point the platform contract check uses to apply the rules with the
+ * monorepo's SDK pin instead of each provider's own pin.
+ */
+export declare function lintRuntimeBoundarySources(files: Record<string, string>, options?: LintRuntimeBoundarySourcesOptions): ProviderLintResult;
+export {};