@typra/emitter 0.2.5 → 0.2.7

package/README.md

@@ -11,9 +11,14 @@ ship runtime service implementations or product-specific contracts.
 ## Install
 
 ```powershell
-npm install --save-dev @typra/emitter @typespec/compiler
+npm install --save-dev @typra/emitter @typespec/compiler@1.10.0 @typespec/json-schema@1.10.0
 ```
 
+Typra currently validates against TypeSpec compiler and JSON schema emitter
+`1.10.0`. Unvalidated TypeSpec versions report a clear diagnostic during emit;
+set `allow-unsupported-typespec-version: true` only when you intentionally accept
+possible generated output churn.
+
 ## Configure TypeSpec
 
 Add the emitter to `tspconfig.yaml`:
@@ -50,12 +55,21 @@ npx tsp compile ./path/to/main.tsp --config ./tspconfig.yaml
 
 ## CLI
 
-The package includes the `typra-generate` command:
+The package includes `typra-generate`, `typra-verify`, and a generic
+`typra-consumer-smoke` harness:
 
 ```powershell
 npx typra-generate --help
+npx typra-verify --baseline ./baseline --current ./generated
+npx typra-consumer-smoke --config ./typra-smoke.json
 ```
 
+`typra-verify` compares committed `.typra-generated` metadata against current
+generated metadata and prints deterministic review summaries for exports,
+protocols, files, package/module identity, toolchain, protected paths, schema
+evolution, stale cleanup dry-runs, hydration seams, and breaking-change
+classification. It never deletes files.
+
 ## Supported output
 
 Typra includes emitters for:
@@ -78,6 +92,18 @@ Generated source files include Typra markers, and the emitter records a
 generated-file manifest for each output root. Stale-file deletion is not enabled
 yet, so Typra will not remove hand-authored runtime files.
 
+Consumers can declare hand-authored boundaries in verifier config:
+
+```json
+{
+  "protectedPaths": ["src/adapters/**"],
+  "hydrationZones": ["src/extensions/**"]
+}
+```
+
+The emitter records hydration seam metadata for generated protocol adapters, but
+runtime behavior remains hand-authored by the consuming project.
+
 ## Links
 
 - Repository: <https://github.com/sethjuarez/typra>

package/dist/src/cleanup/generated-file.d.ts

@@ -1,5 +1,16 @@
 import { EmitContext } from "@typespec/compiler";
 import { TypraEmitterOptions } from "../lib.js";
+export interface GeneratedManifestEntry {
+    outputRoot: string;
+    path: string;
+    marker: boolean;
+}
+export interface GeneratedManifest {
+    emitter: "typra-emitter";
+    version: 1;
+    generatedAt: string;
+    files: GeneratedManifestEntry[];
+}
 export declare function emitGeneratedFile(context: EmitContext<TypraEmitterOptions>, filePath: string, content: string, options?: {
     marker?: boolean;
     outputRoot?: string;

package/dist/src/compatibility.d.ts

@@ -0,0 +1,32 @@
+import { EmitContext, NoTarget } from "@typespec/compiler";
+import { TypraEmitterOptions } from "./lib.js";
+export declare const SUPPORTED_TYPESPEC_COMPILER_VERSION = "1.10.0";
+export declare const SUPPORTED_TYPESPEC_JSON_SCHEMA_VERSION = "1.10.0";
+export interface ToolchainPackageMetadata {
+    name: string;
+    version: string;
+    supportedRange: string;
+    supported: boolean;
+}
+export interface ToolchainMetadata {
+    packages: ToolchainPackageMetadata[];
+}
+interface CompatibilityDiagnosticContext {
+    options: Pick<TypraEmitterOptions, "allow-unsupported-typespec-version">;
+    program: {
+        reportDiagnostic(diagnostic: {
+            code: string;
+            message: string;
+            severity: "error" | "warning";
+            target: typeof NoTarget;
+        }): void;
+    };
+}
+export declare function getToolchainMetadata(): ToolchainMetadata;
+export declare function buildToolchainMetadata(packages: Array<Omit<ToolchainPackageMetadata, "supported"> & Partial<Pick<ToolchainPackageMetadata, "supported">>>): ToolchainMetadata;
+export declare function reportTypeSpecCompatibility(context: EmitContext<TypraEmitterOptions>): ToolchainMetadata;
+export declare function shouldBlockUnsupportedTypeSpecToolchain(options: Pick<TypraEmitterOptions, "allow-unsupported-typespec-version">, toolchain: ToolchainMetadata): boolean;
+export declare function reportToolchainCompatibility(context: CompatibilityDiagnosticContext, toolchain: ToolchainMetadata): void;
+export declare function getUnsupportedTypeSpecPackages(toolchain: ToolchainMetadata): ToolchainPackageMetadata[];
+export declare function formatUnsupportedTypeSpecVersionMessage(unsupported: ToolchainPackageMetadata[], allowedUnsupportedVersion: boolean): string;
+export {};

package/dist/src/compatibility.js

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { NoTarget } from "@typespec/compiler";
+export const SUPPORTED_TYPESPEC_COMPILER_VERSION = "1.10.0";
+export const SUPPORTED_TYPESPEC_JSON_SCHEMA_VERSION = "1.10.0";
+const require = createRequire(import.meta.url);
+export function getToolchainMetadata() {
+    const emitterVersion = resolveNearestPackageVersion("@typra/emitter", dirname(fileURLToPath(import.meta.url)));
+    return buildToolchainMetadata([
+        {
+            name: "@typespec/compiler",
+            version: resolveInstalledPackageVersion("@typespec/compiler"),
+            supportedRange: SUPPORTED_TYPESPEC_COMPILER_VERSION,
+        },
+        {
+            name: "@typespec/json-schema",
+            version: resolveInstalledPackageVersion("@typespec/json-schema"),
+            supportedRange: SUPPORTED_TYPESPEC_JSON_SCHEMA_VERSION,
+        },
+        {
+            name: "@typra/emitter",
+            version: emitterVersion,
+            supportedRange: emitterVersion,
+        },
+    ]);
+}
+export function buildToolchainMetadata(packages) {
+    return {
+        packages: packages
+            .map((entry) => ({
+            ...entry,
+            supported: entry.supported ?? isSupportedVersion(entry.version, entry.supportedRange),
+        }))
+            .sort((left, right) => left.name.localeCompare(right.name)),
+    };
+}
+export function reportTypeSpecCompatibility(context) {
+    const toolchain = getToolchainMetadata();
+    reportToolchainCompatibility(context, toolchain);
+    return toolchain;
+}
+export function shouldBlockUnsupportedTypeSpecToolchain(options, toolchain) {
+    return options["allow-unsupported-typespec-version"] !== true && getUnsupportedTypeSpecPackages(toolchain).length > 0;
+}
+export function reportToolchainCompatibility(context, toolchain) {
+    const unsupported = getUnsupportedTypeSpecPackages(toolchain);
+    if (unsupported.length === 0) {
+        return;
+    }
+    context.program.reportDiagnostic({
+        code: "typra-emitter-unsupported-typespec-version",
+        message: formatUnsupportedTypeSpecVersionMessage(unsupported, context.options["allow-unsupported-typespec-version"] === true),
+        severity: context.options["allow-unsupported-typespec-version"] === true ? "warning" : "error",
+        target: NoTarget,
+    });
+}
+export function getUnsupportedTypeSpecPackages(toolchain) {
+    return toolchain.packages.filter((entry) => (entry.name === "@typespec/compiler" || entry.name === "@typespec/json-schema") && !entry.supported);
+}
+export function formatUnsupportedTypeSpecVersionMessage(unsupported, allowedUnsupportedVersion) {
+    const actual = unsupported.map((entry) => `${entry.name}@${entry.version}`).join(", ");
+    const expected = unsupported.map((entry) => `${entry.name}@${entry.supportedRange}`).join(", ");
+    const action = allowedUnsupportedVersion
+        ? "Generation will continue because allow-unsupported-typespec-version is enabled."
+        : "Pin the TypeSpec toolchain to the supported versions, or set allow-unsupported-typespec-version: true to continue with a warning.";
+    return `@typra/emitter has only been validated with ${expected}; found ${actual}. ${action}`;
+}
+function isSupportedVersion(version, supportedRange) {
+    return version === supportedRange;
+}
+function resolveInstalledPackageVersion(packageName) {
+    try {
+        const packageEntry = require.resolve(packageName);
+        return resolveNearestPackageVersion(packageName, dirname(packageEntry));
+    }
+    catch {
+        return "unresolved";
+    }
+}
+function resolveNearestPackageVersion(expectedPackageName, startDir) {
+    let current = startDir;
+    while (current !== dirname(current)) {
+        const candidate = join(current, "package.json");
+        if (existsSync(candidate)) {
+            const metadata = JSON.parse(readFileSync(candidate, "utf8"));
+            if (metadata.name === expectedPackageName && typeof metadata.version === "string") {
+                return metadata.version;
+            }
+        }
+        current = dirname(current);
+    }
+    return "unresolved";
+}
+//# sourceMappingURL=compatibility.js.map

package/dist/src/consumer-smoke.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/consumer-smoke.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { verifyTypraMetadata } from "./verify/index.js";
+const HELP = `
+typra-consumer-smoke - Run a generic Typra consumer smoke harness
+
+Usage:
+  npx typra-consumer-smoke --config typra-smoke.json
+
+Config shape:
+  {
+    "install": ["npm ci"],
+    "generate": ["npx tsp compile ./typespec/main.tsp --config ./tspconfig.yaml"],
+    "verify": { "baseline": "./baseline", "current": "./generated" },
+    "smoke": ["npm test"]
+  }
+`;
+async function main() {
+    const { values } = parseArgs({
+        options: {
+            config: { type: "string" },
+            help: { type: "boolean", short: "h" },
+        },
+    });
+    if (values.help) {
+        console.log(HELP);
+        process.exit(0);
+    }
+    if (!values.config) {
+        console.error("Error: --config is required.\n");
+        console.log(HELP);
+        process.exit(1);
+    }
+    const config = readConfig(values.config);
+    runCommands("install", config.install ?? []);
+    runCommands("generate", config.generate ?? []);
+    if (config.verify) {
+        const result = verifyTypraMetadata({
+            baselineRoot: config.verify.baseline,
+            currentRoot: config.verify.current,
+            configPath: config.verify.config,
+        });
+        if (!result.ok) {
+            console.error(JSON.stringify(result, null, 2));
+            process.exit(1);
+        }
+    }
+    runCommands("smoke", config.smoke ?? []);
+}
+function readConfig(configPath) {
+    if (!existsSync(configPath)) {
+        throw new Error(`Missing consumer smoke config: ${configPath}`);
+    }
+    const config = JSON.parse(readFileSync(configPath, "utf8"));
+    for (const key of ["install", "generate", "smoke"]) {
+        if (config[key] !== undefined && (!Array.isArray(config[key]) || config[key]?.some((entry) => typeof entry !== "string"))) {
+            throw new Error(`Invalid consumer smoke config: ${key} must be an array of commands.`);
+        }
+    }
+    if (config.verify && (typeof config.verify.baseline !== "string" || typeof config.verify.current !== "string")) {
+        throw new Error("Invalid consumer smoke config: verify.baseline and verify.current are required strings.");
+    }
+    return config;
+}
+function runCommands(label, commands) {
+    for (const command of commands) {
+        console.log(`[typra-consumer-smoke:${label}] ${command}`);
+        execFileSync(command, {
+            cwd: process.cwd(),
+            shell: true,
+            stdio: "inherit",
+        });
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});
+//# sourceMappingURL=consumer-smoke.js.map

package/dist/src/contract-surface.d.ts

@@ -1,6 +1,7 @@
 import { EmitContext } from "@typespec/compiler";
 import { EmitTarget, TypraEmitterOptions } from "./lib.js";
 import { TypeNode } from "./ir/ast.js";
+import { ToolchainMetadata } from "./compatibility.js";
 export interface ExportSurfaceMethod {
     name: string;
     returns: string;
@@ -11,6 +12,8 @@ export interface ExportSurfaceMethod {
 export interface ExportSurfaceProtocol {
     name: string;
     group: string;
+    symbol: string;
+    source: string;
     methods: ExportSurfaceMethod[];
 }
 export interface ExportSurfaceEntry {
@@ -39,6 +42,7 @@ export interface TargetExportSurface {
 export interface ExportSurfaceSnapshot {
     emitter: "typra-emitter";
     version: 1;
+    toolchain: ToolchainMetadata;
     root: {
         object: string;
         namespace: string;
@@ -46,5 +50,5 @@ export interface ExportSurfaceSnapshot {
     };
     targets: TargetExportSurface[];
 }
-export declare function buildExportSurfaceSnapshot(rootObject: string, rootNamespace: string, rootAlias: string, targets: EmitTarget[], nodes: TypeNode[]): ExportSurfaceSnapshot;
+export declare function buildExportSurfaceSnapshot(rootObject: string, rootNamespace: string, rootAlias: string, targets: EmitTarget[], nodes: TypeNode[], toolchain?: ToolchainMetadata): ExportSurfaceSnapshot;
 export declare function emitExportSurfaceSnapshot(context: EmitContext<TypraEmitterOptions>, snapshot: ExportSurfaceSnapshot): Promise<void>;

package/dist/src/contract-surface.js

@@ -1,9 +1,11 @@
 import { emitFile, resolvePath } from "@typespec/compiler";
 import { toKebabCase, toSnakeCase } from "./ir/utilities.js";
-export function buildExportSurfaceSnapshot(rootObject, rootNamespace, rootAlias, targets, nodes) {
+import { getToolchainMetadata } from "./compatibility.js";
+export function buildExportSurfaceSnapshot(rootObject, rootNamespace, rootAlias, targets, nodes, toolchain = getToolchainMetadata()) {
     return {
         emitter: "typra-emitter",
         version: 1,
+        toolchain,
         root: {
             object: rootObject,
             namespace: rootNamespace,
@@ -32,6 +34,8 @@ function buildTargetSurface(rootNamespace, target, nodes) {
         .map((node) => ({
         name: node.typeName.name,
         group: node.group || "",
+        symbol: node.typeName.name,
+        source: sourceFor(targetName, node, node.group || ""),
         methods: node.methods
             .map((method) => ({
             name: method.name,

package/dist/src/emitter.js

@@ -8,6 +8,8 @@ import { generateGo } from "./languages/go/driver.js";
 import { generateRust } from "./languages/rust/driver.js";
 import { emitGeneratedFile, emitGeneratedManifest } from "./cleanup/generated-file.js";
 import { buildExportSurfaceSnapshot, emitExportSurfaceSnapshot } from "./contract-surface.js";
+import { reportTypeSpecCompatibility, shouldBlockUnsupportedTypeSpecToolchain } from "./compatibility.js";
+import { buildHydrationBoundarySnapshot, emitHydrationBoundarySnapshot } from "./hydration-seams.js";
 /**
  * Filter nodes based on omit-models option.
  * Matches against model name (e.g., "AgentManifest") or fully qualified name (e.g., "Prompty.AgentManifest")
@@ -69,6 +71,10 @@ const generators = {
     rust: generateRust,
 };
 export async function $onEmit(context) {
+    const toolchain = reportTypeSpecCompatibility(context);
+    if (shouldBlockUnsupportedTypeSpecToolchain(context.options, toolchain)) {
+        return;
+    }
     const options = {
         emitterOutputDir: context.emitterOutputDir,
         ...context.options,
@@ -159,7 +165,9 @@ export async function $onEmit(context) {
         }
     }
     await emitGeneratedFile(context, resolvePath(context.emitterOutputDir, "json-ast", "model.json"), JSON.stringify(model.getSanitizedObject(), null, 2), { marker: false });
-    await emitExportSurfaceSnapshot(context, buildExportSurfaceSnapshot(rootObject, rootNamespace, rootAlias, targets, exportSurfaceNodes));
+    const exportSurfaceSnapshot = buildExportSurfaceSnapshot(rootObject, rootNamespace, rootAlias, targets, exportSurfaceNodes, toolchain);
+    await emitExportSurfaceSnapshot(context, exportSurfaceSnapshot);
+    await emitHydrationBoundarySnapshot(context, buildHydrationBoundarySnapshot(exportSurfaceSnapshot, options));
     await emitGeneratedManifest(context);
 }
 //# sourceMappingURL=emitter.js.map

package/dist/src/hydration-seams.d.ts

@@ -0,0 +1,20 @@
+import { EmitContext } from "@typespec/compiler";
+import { ExportSurfaceSnapshot } from "./contract-surface.js";
+import { TypraEmitterOptions } from "./lib.js";
+export interface HydrationSeam {
+    contract: string;
+    target: string;
+    group: string;
+    symbol: string;
+    generatedSource: string;
+    seamKind: "protocol-adapter";
+}
+export interface HydrationBoundarySnapshot {
+    emitter: "typra-emitter";
+    version: 1;
+    protectedPaths: string[];
+    hydrationZones: string[];
+    seams: HydrationSeam[];
+}
+export declare function buildHydrationBoundarySnapshot(exportSurface: ExportSurfaceSnapshot, options: Pick<TypraEmitterOptions, "protected-paths" | "hydration-zones">): HydrationBoundarySnapshot;
+export declare function emitHydrationBoundarySnapshot(context: EmitContext<TypraEmitterOptions>, snapshot: HydrationBoundarySnapshot): Promise<void>;

package/dist/src/hydration-seams.js

@@ -0,0 +1,32 @@
+import { emitFile, resolvePath } from "@typespec/compiler";
+export function buildHydrationBoundarySnapshot(exportSurface, options) {
+    return {
+        emitter: "typra-emitter",
+        version: 1,
+        protectedPaths: uniqueSorted(options["protected-paths"] ?? []),
+        hydrationZones: uniqueSorted(options["hydration-zones"] ?? []),
+        seams: exportSurface.targets
+            .flatMap((target) => target.protocols.map((protocol) => ({
+            contract: protocol.name,
+            target: target.target,
+            group: protocol.group,
+            symbol: protocol.symbol,
+            generatedSource: protocol.source,
+            seamKind: "protocol-adapter",
+        })))
+            .sort((left, right) => seamKey(left).localeCompare(seamKey(right))),
+    };
+}
+export async function emitHydrationBoundarySnapshot(context, snapshot) {
+    await emitFile(context.program, {
+        path: resolvePath(context.emitterOutputDir, ".typra-generated", "hydration-seams.json"),
+        content: `${JSON.stringify(snapshot, null, 2)}\n`,
+    });
+}
+function uniqueSorted(values) {
+    return Array.from(new Set(values)).sort((left, right) => left.localeCompare(right));
+}
+function seamKey(seam) {
+    return `${seam.target}:${seam.group}:${seam.contract}:${seam.symbol}`;
+}
+//# sourceMappingURL=hydration-seams.js.map

package/dist/src/index.d.ts

@@ -2,3 +2,5 @@ export { $onEmit, GeneratorOptions, filterNodes } from "./emitter.js";
 export { $lib } from "./lib.js";
 export { $sample, $abstract, $coerce, $factory, $method, $knownAs, $defaultFor, $protocol } from "./decorators.js";
 export { generate, GenerateOptions, GenerateResult, TargetLanguage, TargetOptions } from "./generate.js";
+export { compareTypraMetadata, formatVerifySummary, loadTypraMetadata, loadVerifyConfig, verifyTypraMetadata, TypraMetadataSet, TypraVerifyConfig, TypraVerifyFailure, TypraVerifyResult, TypraVerifySummary, } from "./verify/index.js";
+export { buildHydrationBoundarySnapshot, emitHydrationBoundarySnapshot, HydrationBoundarySnapshot, HydrationSeam, } from "./hydration-seams.js";

package/dist/src/index.js

@@ -2,4 +2,6 @@ export { $onEmit, filterNodes } from "./emitter.js";
 export { $lib } from "./lib.js";
 export { $sample, $abstract, $coerce, $factory, $method, $knownAs, $defaultFor, $protocol } from "./decorators.js";
 export { generate } from "./generate.js";
+export { compareTypraMetadata, formatVerifySummary, loadTypraMetadata, loadVerifyConfig, verifyTypraMetadata, } from "./verify/index.js";
+export { buildHydrationBoundarySnapshot, emitHydrationBoundarySnapshot, } from "./hydration-seams.js";
 //# sourceMappingURL=index.js.map

package/dist/src/lib.d.ts

@@ -18,6 +18,9 @@ export interface TypraEmitterOptions {
     "omit-models"?: string[];
     "schema-output-dir"?: string;
     "additional-roots"?: string[];
+    "allow-unsupported-typespec-version"?: boolean;
+    "protected-paths"?: string[];
+    "hydration-zones"?: string[];
 }
 export declare const $lib: import("@typespec/compiler").TypeSpecLibrary<{
     [code: string]: import("@typespec/compiler").DiagnosticMessages;

package/dist/src/lib.js

@@ -82,6 +82,24 @@ const TypraEmitterOptionsSchema = {
             items: { type: "string" },
             nullable: true,
             description: "Additional root types to resolve and generate alongside the main root object. These types need not be referenced from the main root. Specified as fully-qualified names (e.g., 'Typra.Message')."
+        },
+        "allow-unsupported-typespec-version": {
+            type: "boolean",
+            nullable: true,
+            default: false,
+            description: "Allow generation with an unvalidated TypeSpec compiler/json-schema version. Unsupported versions report a warning instead of an error."
+        },
+        "protected-paths": {
+            type: "array",
+            items: { type: "string" },
+            nullable: true,
+            description: "Hand-authored paths Typra must not own. Recorded for verifier boundary checks; generation still does not delete files."
+        },
+        "hydration-zones": {
+            type: "array",
+            items: { type: "string" },
+            nullable: true,
+            description: "Hand-authored extension zones adjacent to generated output. Recorded as verifier boundary metadata; Typra does not generate runtime behavior."
         }
     },
     required: ["root-object"],

package/dist/src/verify/index.d.ts

@@ -0,0 +1,140 @@
+import { ExportSurfaceSnapshot } from "../contract-surface.js";
+import { GeneratedManifest } from "../cleanup/generated-file.js";
+import { HydrationBoundarySnapshot } from "../hydration-seams.js";
+export interface TypraMetadataSet {
+    exportSurface: ExportSurfaceSnapshot;
+    manifest: GeneratedManifest;
+    model?: SchemaNode;
+    hydration?: HydrationBoundarySnapshot;
+}
+export interface TypraVerifyConfig {
+    protectedPaths?: string[];
+    hydrationZones?: string[];
+}
+export interface TypraVerifyFailure {
+    code: string;
+    message: string;
+    blocking: boolean;
+}
+export interface TypraVerifySummary {
+    exports: {
+        added: number;
+        removed: number;
+        changed: number;
+    };
+    protocols: {
+        added: number;
+        removed: number;
+        changed: number;
+    };
+    files: {
+        added: number;
+        deleted: number;
+        ownershipChanged: number;
+    };
+    packageNamesChanged: number;
+    modulesChanged: number;
+    toolchain: {
+        changed: number;
+        unsupported: number;
+    };
+    protectedPathTouches: number;
+    hydrationZoneTouches: number;
+    staleCleanupCandidates: number;
+    schema: {
+        addedTypes: number;
+        removedTypes: number;
+        addedOptionalProperties: number;
+        addedRequiredProperties: number;
+        removedProperties: number;
+        requirednessChanged: number;
+        propertyTypesChanged: number;
+        wireNamesChanged: number;
+        discriminatorsChanged: number;
+        enumValuesChanged: number;
+    };
+}
+export interface TypraVerifyResult {
+    ok: boolean;
+    breakingChange: "patch" | "minor" | "major";
+    summary: TypraVerifySummary;
+    failures: TypraVerifyFailure[];
+    schemaEvolution: SchemaEvolutionChange[];
+    conformanceMap: ConformanceMapEntry[];
+    staleCleanupDryRun: StaleCleanupCandidate[];
+    hydrationBoundaries: HydrationBoundaryReport;
+}
+export interface SchemaNode {
+    typeName?: {
+        namespace?: string;
+        name?: string;
+    };
+    base?: {
+        namespace?: string;
+        name?: string;
+    };
+    isAbstract?: boolean;
+    isProtocol?: boolean;
+    discriminator?: string;
+    childTypes?: SchemaNode[];
+    properties?: SchemaProperty[];
+}
+export interface SchemaProperty {
+    name?: string;
+    typeName?: {
+        namespace?: string;
+        name?: string;
+    };
+    isOptional?: boolean;
+    knownAs?: Array<{
+        provider?: string;
+        name?: string;
+    }>;
+    allowedValues?: string[];
+    enumName?: string | null;
+    isOpenEnum?: boolean;
+    isScalar?: boolean;
+    isCollection?: boolean;
+    isAny?: boolean;
+    isDict?: boolean;
+    type?: SchemaNode;
+}
+export interface SchemaEvolutionChange {
+    kind: "type-added" | "type-removed" | "property-added-optional" | "property-added-required" | "property-removed" | "property-requiredness-changed" | "property-type-changed" | "property-wire-name-changed" | "type-discriminator-changed" | "property-enum-values-changed";
+    path: string;
+    severity: "patch" | "minor" | "major";
+    message: string;
+}
+export interface ConformanceMapEntry {
+    contract: string;
+    protocol: boolean;
+    targets: Array<{
+        target: string;
+        symbol: string;
+        source: string;
+        packageName?: string;
+        namespace?: string;
+        outputRoot: string;
+        modules: string[];
+        exported: boolean;
+    }>;
+}
+export interface StaleCleanupCandidate {
+    path: string;
+    reasons: string[];
+    safe: boolean;
+}
+export interface HydrationBoundaryReport {
+    protectedPaths: string[];
+    hydrationZones: string[];
+    seams: HydrationBoundarySnapshot["seams"];
+}
+export declare function verifyTypraMetadata(options: {
+    baselineRoot: string;
+    currentRoot: string;
+    configPath?: string;
+}): TypraVerifyResult;
+export declare function loadTypraMetadata(root: string): TypraMetadataSet;
+export declare function loadVerifyConfig(configPath: string): TypraVerifyConfig;
+export declare function compareTypraMetadata(baseline: TypraMetadataSet, current: TypraMetadataSet, config?: TypraVerifyConfig): TypraVerifyResult;
+export declare function formatVerifySummary(result: TypraVerifyResult): string;