npm - bunsane - Versions diffs - 0.3.0 → 0.3.2 - Mend

bunsane 0.3.0 → 0.3.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (54) hide show

package/.claude/scheduled_tasks.lock +1 -0
package/CHANGELOG.md +104 -0
package/CLAUDE.md +20 -0
package/config/cache.config.ts +35 -1
package/core/App.ts +24 -1060
package/core/ArcheType.ts +78 -2110
package/core/Entity.ts +136 -41
package/core/RequestContext.ts +85 -36
package/core/RequestLoaders.ts +89 -31
package/core/SchedulerManager.ts +13 -13
package/core/app/bootstrap.ts +133 -0
package/core/app/cors.ts +94 -0
package/core/app/graphqlSetup.ts +56 -0
package/core/app/healthEndpoints.ts +31 -0
package/core/app/metricsCollector.ts +27 -0
package/core/app/preparedStatementWarmup.ts +55 -0
package/core/app/processHandlers.ts +43 -0
package/core/app/requestRouter.ts +309 -0
package/core/app/restRegistry.ts +72 -0
package/core/app/shutdown.ts +97 -0
package/core/app/studioRouter.ts +83 -0
package/core/archetype/customTypes.ts +100 -0
package/core/archetype/decorators.ts +171 -0
package/core/archetype/fieldResolvers.ts +621 -0
package/core/archetype/helpers.ts +29 -0
package/core/archetype/relationLoader.ts +118 -0
package/core/archetype/schemaBuilder.ts +141 -0
package/core/archetype/weaver.ts +218 -0
package/core/archetype/zodSchemaBuilder.ts +527 -0
package/core/cache/CacheManager.ts +144 -9
package/core/components/BaseComponent.ts +12 -2
package/core/middleware/AccessLog.ts +8 -1
package/database/PreparedStatementCache.ts +17 -16
package/database/cancellable.ts +22 -0
package/database/instrumentedDb.ts +141 -0
package/docs/RFC_APP_REFACTOR.md +248 -0
package/docs/RFC_REFACTOR_TARGETS.md +251 -0
package/package.json +1 -1
package/query/ComponentInclusionNode.ts +5 -5
package/query/Query.ts +65 -48
package/service/ServiceRegistry.ts +7 -1
package/service/index.ts +4 -2
package/tests/integration/loaders/RequestLoaders.abort.test.ts +82 -0
package/tests/integration/query/Query.abort.test.ts +66 -0
package/tests/unit/cache/CacheManager.test.ts +152 -1
package/tests/unit/database/cancellable.test.ts +81 -0
package/tests/unit/database/instrumentedDb.test.ts +160 -0
package/tests/unit/entity/Entity.components.test.ts +73 -0
package/tests/unit/entity/Entity.drainSideEffects.test.ts +51 -0
package/tests/unit/entity/Entity.reload.test.ts +63 -0
package/tests/unit/entity/Entity.requireComponents.test.ts +72 -0
package/tests/unit/query/Query.emptyString.test.ts +69 -0
package/tests/unit/query/Query.test.ts +6 -4
package/tests/unit/scheduler/SchedulerManager.timeBased.test.ts +95 -0

package/core/app/requestRouter.ts ADDED Viewed

@@ -0,0 +1,309 @@
+import * as path from "path";
+import { logger as MainLogger } from "../Logger";
+import { getSerializedMetadataStorage } from "../metadata";
+import { addCorsHeaders, getCorsHeaders } from "./cors";
+import {
+    handleHealth,
+    handleReady,
+    handleRemoteHealth,
+} from "./healthEndpoints";
+import { routeStudio } from "./studioRouter";
+import { getDbStats } from "../../database/instrumentedDb";
+import type { RequestStats } from "../RequestContext";
+const logger = MainLogger.child({ scope: "App" });
+function combineSignals(signals: AbortSignal[]): AbortSignal {
+    const anyFn = (AbortSignal as any).any;
+    if (typeof anyFn === 'function') {
+        return anyFn.call(AbortSignal, signals);
+    }
+    const controller = new AbortController();
+    for (const s of signals) {
+        if (s.aborted) {
+            controller.abort((s as any).reason);
+            return controller.signal;
+        }
+        s.addEventListener('abort', () => controller.abort((s as any).reason), { once: true });
+    }
+    return controller.signal;
+}
+export async function handleRequest(app: any, req: Request): Promise<Response> {
+    const url = new URL(req.url);
+    const method = req.method;
+    const startTime = Date.now();
+    if (method === 'OPTIONS') {
+        return new Response(null, {
+            status: 204,
+            headers: getCorsHeaders(app.config.cors, req),
+        });
+    }
+    // Request timeout — combine framework wall-clock with client abort signal
+    // and rebind onto the request so downstream handlers (Yoga, REST) see
+    // cancellation propagation (C05).
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+        controller.abort(new Error(`Request timeout after 30000ms: ${method} ${url.pathname}`));
+        const stats = (req as any).__bunsaneStats as RequestStats | undefined;
+        logger.warn({
+            scope: 'App',
+            method,
+            path: url.pathname,
+            operationName: stats?.operationName,
+            dataLoaderCalls: stats?.dataLoaderCalls,
+            dbQueryCount: stats?.dbQueryCount,
+            msg: 'Request timeout',
+        }, `Request timeout: ${method} ${url.pathname}`);
+    }, 30000);
+    const combinedSignal = combineSignals([req.signal, controller.signal]);
+    req = new Request(req, { signal: combinedSignal });
+    const cors = app.config.cors;
+    const wrap = (response: Response) => addCorsHeaders(response, cors, req);
+    try {
+        if (url.pathname === "/health") {
+            const response = await handleHealth(app);
+            clearTimeout(timeoutId);
+            return wrap(response);
+        }
+        if (url.pathname === "/metrics") {
+            const metrics = await app.collectMetrics();
+            clearTimeout(timeoutId);
+            return wrap(new Response(JSON.stringify(metrics), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            }));
+        }
+        if (url.pathname === "/health/remote") {
+            const response = await handleRemoteHealth(app);
+            clearTimeout(timeoutId);
+            return wrap(response);
+        }
+        if (url.pathname === "/health/ready") {
+            const response = await handleReady(app);
+            clearTimeout(timeoutId);
+            return wrap(response);
+        }
+        if (url.pathname === "/openapi.json") {
+            clearTimeout(timeoutId);
+            return wrap(new Response(app.openAPISpecGenerator!.toJSON(), {
+                headers: { "Content-Type": "application/json" },
+            }));
+        }
+        if (url.pathname === "/docs") {
+            clearTimeout(timeoutId);
+            const swaggerUIHTML = `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>${app.name} Documentation</title>
+    <link rel="stylesheet" type="text/css" href="https://unpkg.com/swagger-ui-dist@5.10.3/swagger-ui.css" />
+    <style>
+        html { box-sizing: border-box; overflow: -moz-scrollbars-vertical; overflow-y: scroll; }
+        *, *:before, *:after { box-sizing: inherit; }
+        body { margin: 0; background: #fafafa; }
+    </style>
+</head>
+<body>
+    <div id="swagger-ui"></div>
+    <script src="https://unpkg.com/swagger-ui-dist@5.10.3/swagger-ui-bundle.js"></script>
+    <script>
+        window.onload = function() {
+            const ui = SwaggerUIBundle({
+                url: '/openapi.json',
+                dom_id: '#swagger-ui',
+                deepLinking: true,
+                presets: [
+                    SwaggerUIBundle.presets.apis,
+                    SwaggerUIBundle.presets.standalone
+                ],
+                plugins: [
+                    SwaggerUIBundle.plugins.DownloadUrl
+                ],
+                layout: "BaseLayout"
+            });
+        };
+    </script>
+</body>
+</html>`;
+            return wrap(new Response(swaggerUIHTML, {
+                headers: { "Content-Type": "text/html" },
+            }));
+        }
+        const studioApiResponse = await routeStudio(app, url, req, method);
+        if (studioApiResponse) {
+            clearTimeout(timeoutId);
+            return wrap(studioApiResponse);
+        }
+        if (
+            app.studioEnabled &&
+            (url.pathname === "/studio" || url.pathname.startsWith("/studio/"))
+        ) {
+            clearTimeout(timeoutId);
+            if (url.pathname.startsWith("/studio/api/")) {
+                return wrap(new Response(
+                    JSON.stringify({ error: "Studio API endpoint not found" }),
+                    { status: 404, headers: { "Content-Type": "application/json" } },
+                ));
+            }
+            if (!url.pathname.startsWith("/studio/assets/")) {
+                const studioIndexPath = path.join(
+                    import.meta.dirname,
+                    "..",
+                    "..",
+                    "studio",
+                    "dist",
+                    "index.html",
+                );
+                try {
+                    const studioFile = Bun.file(studioIndexPath);
+                    if (await studioFile.exists()) {
+                        let html = await studioFile.text();
+                        const metadata = getSerializedMetadataStorage();
+                        const metadataScript = `<script>window.bunsaneMetadata = ${JSON.stringify(metadata)};</script>`;
+                        html = html.replace("</head>", `${metadataScript}</head>`);
+                        return wrap(new Response(html, {
+                            headers: { "Content-Type": "text/html" },
+                        }));
+                    } else {
+                        return wrap(new Response(
+                            "Studio not built. Run `bun run build:studio` to build the studio.",
+                            { status: 404, headers: { "Content-Type": "text/plain" } },
+                        ));
+                    }
+                } catch (error) {
+                    console.log("Error loading studio index.html:", error);
+                    return wrap(new Response("Studio not available", {
+                        status: 404,
+                        headers: { "Content-Type": "text/plain" },
+                    }));
+                }
+            }
+        }
+        for (const [route, folder] of app.staticAssets) {
+            if (url.pathname.startsWith(route)) {
+                const relativePath = url.pathname.slice(route.length);
+                const filePath = path.join(folder, relativePath);
+                try {
+                    const file = Bun.file(filePath);
+                    if (await file.exists()) {
+                        clearTimeout(timeoutId);
+                        return wrap(new Response(file));
+                    }
+                } catch (error) {
+                    logger.error(`Error serving static file ${filePath}:`, error as any);
+                }
+            }
+        }
+        const endpointKey = `${method}:${url.pathname}`;
+        let endpoint = app.restEndpointMap.get(endpointKey);
+        if (!endpoint) {
+            for (const ep of app.restEndpoints) {
+                if (ep.method !== method) continue;
+                const pattern = ep.path.replace(/:[^/]+/g, '[^/]+');
+                const regex = new RegExp(`^${pattern}$`);
+                if (regex.test(url.pathname)) {
+                    endpoint = ep;
+                    break;
+                }
+            }
+        }
+        if (endpoint) {
+            try {
+                const result = await endpoint.handler(req);
+                const duration = Date.now() - startTime;
+                logger.trace(`REST ${method} ${url.pathname} completed in ${duration}ms`);
+                clearTimeout(timeoutId);
+                if (result instanceof Response) {
+                    return wrap(result);
+                } else {
+                    return wrap(new Response(JSON.stringify(result), {
+                        headers: { "Content-Type": "application/json" },
+                    }));
+                }
+            } catch (error) {
+                const duration = Date.now() - startTime;
+                logger.error(
+                    `Error in REST endpoint ${method} ${endpoint.path} after ${duration}ms`,
+                    error as any,
+                );
+                clearTimeout(timeoutId);
+                return wrap(new Response(
+                    JSON.stringify({
+                        error: "Internal server error",
+                        code: "INTERNAL_ERROR",
+                        ...(process.env.NODE_ENV === 'development' && {
+                            message: (error as Error)?.message,
+                        }),
+                    }),
+                    { status: 500, headers: { "Content-Type": "application/json" } },
+                ));
+            }
+        }
+        if (app.yoga) {
+            const response = await app.yoga(req);
+            const duration = Date.now() - startTime;
+            logger.trace(`GraphQL request completed in ${duration}ms`);
+            clearTimeout(timeoutId);
+            return response;
+        }
+        clearTimeout(timeoutId);
+        return wrap(new Response("Not Found", { status: 404 }));
+    } catch (error) {
+        const duration = Date.now() - startTime;
+        const stats = (req as any).__bunsaneStats as RequestStats | undefined;
+        logger.error(
+            {
+                scope: 'App',
+                method,
+                path: url.pathname,
+                duration,
+                operationName: stats?.operationName,
+                dataLoaderCalls: stats?.dataLoaderCalls,
+                dbQueryCount: stats?.dbQueryCount,
+                dbStats: getDbStats(),
+                err: error,
+            },
+            `Request failed after ${duration}ms: ${method} ${url.pathname}`,
+        );
+        clearTimeout(timeoutId);
+        if ((error as Error).name === "AbortError") {
+            return wrap(new Response(
+                JSON.stringify({ error: "Request timeout", code: "TIMEOUT_ERROR" }),
+                { status: 408, headers: { "Content-Type": "application/json" } },
+            ));
+        }
+        return wrap(new Response(
+            JSON.stringify({
+                error: "Internal server error",
+                code: "INTERNAL_ERROR",
+                ...(process.env.NODE_ENV === 'development' && {
+                    message: (error as Error)?.message,
+                }),
+            }),
+            { status: 500, headers: { "Content-Type": "application/json" } },
+        ));
+    }
+}

package/core/app/restRegistry.ts ADDED Viewed

@@ -0,0 +1,72 @@
+import { logger as MainLogger } from "../Logger";
+const logger = MainLogger.child({ scope: "App" });
+export function collectRestEndpoints(app: any, services: any[]): void {
+    for (const service of services) {
+        const endpoints = (service.constructor as any).httpEndpoints;
+        if (!endpoints) continue;
+        for (const endpoint of endpoints) {
+            const endpointInfo = {
+                method: endpoint.method,
+                path: endpoint.path,
+                handler: endpoint.handler.bind(service),
+                service: service,
+            };
+            logger.trace(
+                `Registered REST endpoint: [${endpoint.method}] ${endpoint.path} for service ${service.constructor.name}`,
+            );
+            app.restEndpoints.push(endpointInfo);
+            app.restEndpointMap.set(`${endpoint.method}:${endpoint.path}`, endpointInfo);
+            if ((endpoint.handler as any).swaggerOperation) {
+                const classTags = (service.constructor as any).swaggerClassTags || [];
+                const methodTags =
+                    (service.constructor as any).swaggerMethodTags?.[endpoint.handler.name] || [];
+                const allTags = [...classTags, ...methodTags];
+                logger.trace(
+                    `Generating OpenAPI spec for endpoint: [${endpoint.method}] ${endpoint.path} with tags: ${allTags.join(", ")}`,
+                );
+                const operation = { ...(endpoint.handler as any).swaggerOperation };
+                if (allTags.length > 0) {
+                    operation.tags = [...(operation.tags || []), ...allTags];
+                }
+                app.openAPISpecGenerator!.addEndpoint({
+                    method: endpoint.method,
+                    path: endpoint.path,
+                    operation,
+                });
+                logger.trace(
+                    `Registered OpenAPI spec for endpoint: [${endpoint.method}] ${endpoint.path}`,
+                );
+            } else if (app.enforceDocs) {
+                logger.warn(
+                    `No swagger operation found for endpoint: [${endpoint.method}] ${endpoint.path} in service ${service.constructor.name}`,
+                );
+                app.openAPISpecGenerator!.addEndpoint({
+                    method: endpoint.method,
+                    path: endpoint.path,
+                    operation: {
+                        summary: `No description for ${endpoint.path}. Don't use this endpoint until it's properly documented!`,
+                        requestBody: {
+                            content: {
+                                "application/json": {
+                                    schema: {},
+                                },
+                            },
+                        },
+                        responses: {
+                            "200": {
+                                description: "Success",
+                            },
+                        },
+                    },
+                });
+            }
+        }
+    }
+}

package/core/app/shutdown.ts ADDED Viewed

@@ -0,0 +1,97 @@
+import ApplicationLifecycle from "../ApplicationLifecycle";
+import { logger as MainLogger } from "../Logger";
+import { SchedulerManager } from "../SchedulerManager";
+import db from "../../database";
+import { setRemoteManager } from "../remote";
+const logger = MainLogger.child({ scope: "App" });
+export async function runShutdown(app: any): Promise<void> {
+    if (app.isShuttingDown) return;
+    app.isShuttingDown = true;
+    app.isReady = false;
+    const shutdownStart = Date.now();
+    logger.info({ scope: 'app', component: 'App', msg: 'Shutting down application', gracePeriodMs: app.shutdownGracePeriod });
+    const budgetRemaining = () => Math.max(500, app.shutdownGracePeriod - (Date.now() - shutdownStart));
+    if (app.server) {
+        try {
+            logger.info({ scope: 'app', component: 'App', msg: 'Draining HTTP connections' });
+            app.server.stop(false);
+            await waitForHttpDrain(app, budgetRemaining());
+            try { app.server.stop(true); } catch {}
+            logger.info({ scope: 'app', component: 'App', msg: 'HTTP server stopped' });
+        } catch (error) {
+            logger.warn({ scope: 'app', component: 'App', msg: 'HTTP server stop error', err: error });
+        }
+    }
+    try {
+        await SchedulerManager.getInstance().stop(Math.min(budgetRemaining(), 15_000));
+        logger.info({ scope: 'app', component: 'App', msg: 'Scheduler stopped' });
+    } catch (error) {
+        logger.warn({ scope: 'app', component: 'App', msg: 'Scheduler stop error', err: error });
+    }
+    if (app.remote) {
+        try {
+            await app.remote.shutdown();
+            setRemoteManager(null);
+            app.remote = null;
+            logger.info({ scope: 'app', component: 'App', msg: 'RemoteManager shutdown' });
+        } catch (error) {
+            logger.warn({ scope: 'app', component: 'App', msg: 'RemoteManager shutdown error', err: error });
+        }
+    }
+    try {
+        const { Entity } = await import('../Entity');
+        await Entity.drainPendingCacheOps(Math.min(budgetRemaining(), 5_000));
+        await Entity.drainPendingSideEffects(Math.min(budgetRemaining(), 5_000));
+    } catch (error) {
+        logger.warn({ scope: 'cache', component: 'App', msg: 'Entity cache op drain error', err: error });
+    }
+    try {
+        const { CacheManager } = await import('../cache/CacheManager');
+        await CacheManager.getInstance().shutdown();
+        logger.info({ scope: 'cache', component: 'App', msg: 'Cache shutdown completed' });
+    } catch (error) {
+        logger.warn({ scope: 'cache', component: 'App', msg: 'Cache shutdown error', err: error });
+    }
+    try {
+        db.close();
+        logger.info({ scope: 'app', component: 'App', msg: 'Database pool closed' });
+    } catch (error) {
+        logger.warn({ scope: 'app', component: 'App', msg: 'Database pool close error', err: error });
+    }
+    try {
+        if (app.phaseListener) {
+            ApplicationLifecycle.removePhaseListener(app.phaseListener);
+            app.phaseListener = null;
+        }
+        SchedulerManager.getInstance().disposeLifecycleIntegration();
+    } catch { /* ignore */ }
+    app.unregisterProcessHandlers();
+    logger.info({ scope: 'app', component: 'App', msg: 'Application shutdown completed', durationMs: Date.now() - shutdownStart });
+}
+export async function waitForHttpDrain(app: any, timeoutMs: number): Promise<void> {
+    if (!app.server) return;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const pending = (app.server as any).pendingRequests ?? 0;
+        if (pending === 0) return;
+        await new Promise((r) => setTimeout(r, 50));
+    }
+    const leftover = (app.server as any).pendingRequests ?? -1;
+    if (leftover > 0) {
+        logger.warn({ scope: 'app', component: 'App', msg: 'HTTP drain timeout, pending requests remaining', pendingRequests: leftover });
+    }
+}

package/core/app/studioRouter.ts ADDED Viewed

@@ -0,0 +1,83 @@
+import studioEndpoint from "../../endpoints";
+export async function routeStudio(
+    app: any,
+    url: URL,
+    req: Request,
+    method: string,
+): Promise<Response | null> {
+    if (!app.studioEnabled || !url.pathname.startsWith("/studio/api/")) return null;
+    if (url.pathname === "/studio/api/tables") {
+        return await studioEndpoint.getTables();
+    }
+    if (url.pathname === "/studio/api/stats") {
+        return await studioEndpoint.handleStudioStatsRequest();
+    }
+    if (url.pathname === "/studio/api/components") {
+        return await studioEndpoint.handleStudioComponentsRequest();
+    }
+    if (url.pathname === "/studio/api/query" && method === "POST") {
+        const body = await req.json();
+        return await studioEndpoint.handleStudioQueryRequest(body);
+    }
+    const studioApiPath = url.pathname.replace("/studio/api/", "");
+    const pathSegments = studioApiPath.split("/");
+    if (pathSegments[0] === "entity" && pathSegments[1]) {
+        const entityId = pathSegments[1];
+        return await studioEndpoint.handleEntityInspectorRequest(entityId);
+    }
+    if (pathSegments[0] === "table" && pathSegments[1]) {
+        const tableName = pathSegments[1];
+        if (method === "DELETE") {
+            const body = await req.json();
+            return await studioEndpoint.handleStudioTableDeleteRequest(tableName, body);
+        }
+        const limit = url.searchParams.get("limit");
+        const offset = url.searchParams.get("offset");
+        const search = url.searchParams.get("search");
+        return await studioEndpoint.handleStudioTableRequest(tableName, {
+            limit: limit ? parseInt(limit, 10) : undefined,
+            offset: offset ? parseInt(offset, 10) : undefined,
+            search: search ?? undefined,
+        });
+    }
+    if (pathSegments[0] === "arche-type" && pathSegments[1]) {
+        const archeTypeName = pathSegments[1];
+        if (method === "DELETE") {
+            const body = await req.json();
+            return await studioEndpoint.handleStudioArcheTypeDeleteRequest(archeTypeName, body);
+        }
+        const limit = url.searchParams.get("limit");
+        const offset = url.searchParams.get("offset");
+        const search = url.searchParams.get("search");
+        const includeDeleted = url.searchParams.get("include_deleted");
+        return await studioEndpoint.handleStudioArcheTypeRecordsRequest(archeTypeName, {
+            limit: limit ? parseInt(limit, 10) : undefined,
+            offset: offset ? parseInt(offset, 10) : undefined,
+            search: search ?? undefined,
+            include_deleted: includeDeleted === "true",
+        });
+    }
+    return new Response(
+        JSON.stringify({ error: "Studio API endpoint not found" }),
+        {
+            status: 404,
+            headers: { "Content-Type": "application/json" },
+        },
+    );
+}

package/core/archetype/customTypes.ts ADDED Viewed

@@ -0,0 +1,100 @@
+import { z, ZodObject } from "zod";
+import { asObjectType } from "@gqloom/zod";
+export const customTypeRegistry = new Map<any, any>();
+export const customTypeNameRegistry = new Map<any, string>();
+export const registeredCustomTypes = new Map<string, any>();
+export const customTypeSilks = new Map<string, any>();
+export const customTypeResolvers: any[] = [];
+export const inputTypeRegistry = new Map<any, string>();
+// Structural signature registry for input type deduplication
+// Maps structural signature -> registered input type name
+export const structuralSignatureRegistry = new Map<string, string>();
+let _generateZodStructuralSignature: ((schema: any) => string) | null = null;
+function getSignatureGenerator(): (schema: any) => string {
+    if (!_generateZodStructuralSignature) {
+        const { generateZodStructuralSignature } = require('../../gql/utils/TypeSignature');
+        _generateZodStructuralSignature = generateZodStructuralSignature;
+    }
+    return _generateZodStructuralSignature!;
+}
+export function registerCustomZodType(
+    type: any,
+    schema: any,
+    typeName?: string,
+    inputTypeName?: string
+) {
+    if (typeName && schema instanceof ZodObject) {
+        const shape = schema.shape;
+        const namedSchema = z.object({
+            __typename: z.literal(typeName).nullish(),
+            ...shape,
+        });
+        customTypeRegistry.set(type, namedSchema);
+        if (typeName) {
+            customTypeNameRegistry.set(type, typeName);
+            registeredCustomTypes.set(typeName, namedSchema);
+        }
+        if (inputTypeName) {
+            const inputSchema = z.object(shape).register(asObjectType, { name: inputTypeName });
+            registeredCustomTypes.set(inputTypeName, inputSchema);
+            inputTypeRegistry.set(type, inputTypeName);
+            try {
+                const generateSignature = getSignatureGenerator();
+                const signature = generateSignature(z.object(shape));
+                structuralSignatureRegistry.set(signature, inputTypeName);
+            } catch (e) {
+                // Signature registration is optional, don't fail if it errors
+            }
+        }
+    } else {
+        customTypeRegistry.set(type, schema);
+        if (typeName) {
+            customTypeNameRegistry.set(type, typeName);
+            registeredCustomTypes.set(typeName, schema);
+        }
+        if (inputTypeName && schema instanceof ZodObject) {
+            const inputSchema = schema.register(asObjectType, { name: inputTypeName });
+            registeredCustomTypes.set(inputTypeName, inputSchema);
+            inputTypeRegistry.set(type, inputTypeName);
+            try {
+                const generateSignature = getSignatureGenerator();
+                const signature = generateSignature(schema);
+                structuralSignatureRegistry.set(signature, inputTypeName);
+            } catch (e) {
+                // Signature registration is optional, don't fail if it errors
+            }
+        }
+    }
+}
+export function getRegisteredCustomTypes() {
+    return registeredCustomTypes;
+}
+/**
+ * Find a matching registered input type for a given Zod schema based on structural equivalence.
+ */
+export function findMatchingInputType(schema: any): string | null {
+    if (!schema) return null;
+    try {
+        const generateSignature = getSignatureGenerator();
+        const signature = generateSignature(schema);
+        return structuralSignatureRegistry.get(signature) || null;
+    } catch (e) {
+        return null;
+    }
+}
+export function getStructuralSignatureRegistry(): Map<string, string> {
+    return structuralSignatureRegistry;
+}