@luckystack/devkit 0.10.2 → 0.11.0

package/dist/internal/mapUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const getOrInit: <K, V>(map: Map<K, V>, key: K, factory: () => V) => V;
+export declare const mustGet: <K, V>(map: Map<K, V>, key: K, label: string) => V;

package/dist/loader.d.ts

@@ -0,0 +1,11 @@
+export declare const devApis: Record<string, unknown>;
+export declare const devSyncs: Record<string, unknown>;
+export declare const devFunctions: Record<string, unknown>;
+export declare const initializeAll: () => Promise<void>;
+export declare const initializeApis: () => Promise<void>;
+export declare const upsertApiFromFile: (filePath: string) => Promise<void>;
+export declare const removeApiFromFile: (filePath: string) => void;
+export declare const initializeSyncs: () => Promise<void>;
+export declare const upsertSyncFromFile: (filePath: string) => Promise<void>;
+export declare const removeSyncFromFile: (filePath: string) => void;
+export declare const initializeFunctions: () => Promise<void>;

package/dist/prismaClientCheck.d.ts

@@ -0,0 +1,19 @@
+/**
+ * True when a Prisma schema exists in the consumer project but the generated
+ * client output is absent — i.e. the consumer has not run `prisma generate`
+ * yet. This is the only condition under which we auto-generate (or surface the
+ * "run prisma:generate" hint), so an unrelated type-map failure never triggers
+ * the Prisma-specific path.
+ */
+export declare const isPrismaClientMissing: () => boolean;
+/**
+ * Runs `prisma generate` once. `prisma generate` only reads the schema —
+ * it needs NO database credentials — so this is safe to run on dev boot without
+ * any `.env` loading. Resolves to the child's exit code (0 on success). Spawn
+ * failures (ENOENT/EACCES) surface through the `tryCatch` tuple, not a throw.
+ *
+ * Uses the local `node_modules/.bin/prisma` binary directly (shell: false) to
+ * avoid shell invocation on Windows. Falls back to `npx prisma` with
+ * shell: false when the local binary is absent (e.g. prisma not yet installed).
+ */
+export declare const runPrismaGenerate: () => Promise<[Error | null, number | null]>;

package/dist/routeConventions.d.ts

@@ -0,0 +1,20 @@
+export declare const API_VERSION_TOKEN_REGEX: RegExp;
+export declare const SYNC_VERSION_TOKEN_REGEX: RegExp;
+export declare const API_VERSIONED_FILE_REGEX: RegExp;
+export declare const SYNC_SERVER_VERSIONED_FILE_REGEX: RegExp;
+export declare const SYNC_CLIENT_VERSIONED_FILE_REGEX: RegExp;
+export declare const SYNC_VERSIONED_FILE_REGEX: RegExp;
+export declare const ROUTE_NAMING_RULES: {
+    readonly api: '<name>_v<number>.ts';
+    readonly syncServer: '<name>_server_v<number>.ts';
+    readonly syncClient: '<name>_client_v<number>.ts';
+};
+export declare const ROUTE_NAMING_EXAMPLES: {
+    readonly api: 'updateUser_v1.ts';
+    readonly syncServer: 'updateCounter_server_v1.ts';
+    readonly syncClient: 'updateCounter_client_v1.ts';
+};
+export declare const isVersionedApiFileName: (fileName: string) => boolean;
+export declare const isVersionedSyncFileName: (fileName: string) => boolean;
+export declare const isVersionedSyncServerFileName: (fileName: string) => boolean;
+export declare const isVersionedSyncClientFileName: (fileName: string) => boolean;

package/dist/routeNamingValidation.d.ts

@@ -0,0 +1,46 @@
+export interface RouteNamingIssue {
+    kind: 'api' | 'sync';
+    filePath: string;
+    reason: string;
+    expected: string;
+}
+export interface DuplicateRouteKeyIssue {
+    kind: 'api' | 'sync';
+    routeKey: string;
+    filePaths: string[];
+}
+export declare const isInsidePrivateRouteSubfolder: (fullPath: string) => boolean;
+export declare const isRouteSurfaceFile: (fullPath: string) => boolean;
+export declare const collectInvalidRouteNamingIssues: (srcDir: string) => RouteNamingIssue[];
+export declare const collectDuplicateNormalizedRouteKeyIssues: (srcDir: string) => DuplicateRouteKeyIssue[];
+export declare const formatRouteNamingIssues: ({ issues, context, }: {
+    issues: RouteNamingIssue[];
+    context: string;
+}) => string;
+export declare const formatDuplicateRouteKeyIssues: ({ issues, context, }: {
+    issues: DuplicateRouteKeyIssue[];
+    context: string;
+}) => string;
+export declare const assertValidRouteNaming: ({ srcDir, context, }: {
+    srcDir: string;
+    context: string;
+}) => void;
+export declare const assertNoDuplicateNormalizedRouteKeys: ({ srcDir, context, }: {
+    srcDir: string;
+    context: string;
+}) => void;
+export interface DuplicatePageRouteIssue {
+    /** Computed route after invisible-parent stripping (e.g. `/admin`). */
+    route: string;
+    /** All page.tsx files that resolve to this same route. */
+    filePaths: string[];
+}
+export declare const collectDuplicatePageRoutes: (srcDir: string) => DuplicatePageRouteIssue[];
+export declare const formatDuplicatePageRouteIssues: ({ issues, context, }: {
+    issues: DuplicatePageRouteIssue[];
+    context: string;
+}) => string;
+export declare const assertNoDuplicatePageRoutes: ({ srcDir, context, }: {
+    srcDir: string;
+    context: string;
+}) => void;

package/dist/routingRules.d.ts

@@ -0,0 +1,62 @@
+export interface RoutingRules {
+    /** Folder name that marks an API directory. Default: `_api`. */
+    apiMarker: string;
+    /** Folder name that marks a sync directory. Default: `_sync`. */
+    syncMarker: string;
+    /** Suffix matcher for API files: must end with `_v<number>.ts`. */
+    apiVersionRegex: RegExp;
+    /** Suffix matcher for sync server files: must end with `_server_v<number>.ts`. */
+    syncServerVersionRegex: RegExp;
+    /** Suffix matcher for sync client files: must end with `_client_v<number>.ts`. */
+    syncClientVersionRegex: RegExp;
+    /** Combined sync regex (server or client). */
+    syncVersionRegex: RegExp;
+    /**
+     * Predicate called for each candidate file/folder during discovery.
+     * Return `true` to skip. Path is provided as a forward-slash relative
+     * string from the workspace root (e.g. `src/dashboard/__tests__/foo_v1.ts`).
+     */
+    ignore: (relativePath: string) => boolean;
+    /**
+     * Single-character prefix that marks a folder as **invisible-parent** for
+     * page routing: `src/_housing/renting/page.tsx` resolves to `/renting`
+     * (the `_housing` segment is stripped from the URL). A `page.tsx` placed
+     * directly inside an `_<name>` folder is invalid (no URL segment left).
+     *
+     * Default: `'_'`. Override only if you need a different prefix scheme.
+     */
+    privateFolderPrefix: string;
+    /**
+     * Folder names that are reserved for framework-internal use and may NEVER
+     * host a `page.tsx`. Scaffold + page-discovery emit a hard error when a
+     * page is placed inside one. Extend (do not replace) the defaults if you
+     * add your own internal folder convention.
+     *
+     * Defaults: `_api`, `_sync`, `_function(s)`, `_component(s)`, `_provider(s)`,
+     * `_locale(s)`, `_socket(s)`, `_shared`, `_server`. The semantic markers
+     * (`_api`, `_sync`) are also reserved by the API/sync routers.
+     */
+    scaffoldIgnoredFolders: string[];
+    /**
+     * Optional predicate. Return `true` for a given absolute file path to
+     * disable template injection entirely for that file. Useful when a
+     * consumer wants to opt some part of the tree out of the scaffold
+     * (e.g. `/src/migrations/**` lives by hand). The argument is the
+     * absolute path the chokidar watcher provides; the predicate is
+     * called BEFORE the `isInApiFolder` / `isPageFile` checks fire.
+     */
+    disableTemplateInjection?: (filePath: string) => boolean;
+}
+export declare const registerRoutingRules: (overrides: Partial<RoutingRules>) => RoutingRules;
+export declare const getRoutingRules: () => RoutingRules;
+export declare const apiMarkerSegment: () => string;
+export declare const syncMarkerSegment: () => string;
+export declare const isApiFileName: (fileName: string) => boolean;
+export declare const isSyncServerFileName: (fileName: string) => boolean;
+export declare const isSyncClientFileName: (fileName: string) => boolean;
+export declare const isSyncFileName: (fileName: string) => boolean;
+export declare const isRouteTestFile: (fileNameOrPath: string) => boolean;
+export declare const isNonRouteDirectory: (directoryName: string) => boolean;
+import { type PagePathValidationResult as CoreResult } from '@luckystack/core';
+export type PagePathValidationResult = CoreResult;
+export declare const validatePagePath: (srcRelativePath: string) => PagePathValidationResult;

package/dist/runtimeTypeResolver.d.ts

@@ -0,0 +1,15 @@
+type ResolveResult = {
+    status: 'success';
+    typeText: string;
+} | {
+    status: 'error';
+    message: string;
+};
+export declare const isUnresolvedTypeMarker: (value: string) => boolean;
+export declare const getUnresolvedTypeMessage: (value: string) => string;
+export declare const clearRuntimeTypeResolverCache: () => void;
+export declare const resolveRuntimeTypeText: ({ typeText, filePath, }: {
+    typeText: string;
+    filePath?: string;
+}) => ResolveResult;
+export {};

package/dist/supervisor.d.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+export type SupervisorRuntime = 'node' | 'bun';
+export interface ChildSpawnSpec {
+    command: string;
+    args: string[];
+    runtime: SupervisorRuntime;
+}
+export interface ResolveChildSpawnInput {
+    isBun: boolean;
+    execPath: string;
+    npmUserAgent: string | undefined;
+    npmExecPath: string | undefined;
+    tsxCliPath: string;
+    tsconfigServerArgs: string[];
+    entry: string;
+    fileExists: (candidate: string) => boolean;
+}
+export type ResolveChildSpawnResult = {
+    ok: true;
+    spec: ChildSpawnSpec;
+} | {
+    ok: false;
+    message: string;
+};
+export declare const resolveChildSpawn: ({ isBun, execPath, npmUserAgent, npmExecPath, tsxCliPath: tsxCli, tsconfigServerArgs: tsconfigArgs, entry, fileExists, }: ResolveChildSpawnInput) => ResolveChildSpawnResult;

package/dist/templateInjector.d.ts

@@ -0,0 +1,60 @@
+export declare const isEmptyFile: (filePath: string) => boolean;
+export declare const isInApiFolder: (filePath: string) => boolean;
+export declare const isInSyncFolder: (filePath: string) => boolean;
+export declare const isPageFile: (filePath: string) => boolean;
+export declare const isSyncServerFile: (filePath: string) => boolean;
+export declare const isSyncClientFile: (filePath: string) => boolean;
+export declare const getRouteFilenameValidationMessage: (filePath: string) => string | null;
+/**
+ * Get the paired sync file path (server -> client or client -> server)
+ */
+export declare const getPairedSyncFile: (filePath: string) => string | null;
+/**
+ * Check if a paired sync file exists
+ */
+export declare const hasPairedFile: (filePath: string) => boolean;
+/**
+ * Extract page path from a sync file path (e.g., "examples" from "src/examples/_sync/test_server_v1.ts")
+ */
+export declare const extractSyncPagePath: (filePath: string) => string;
+/**
+ * Extract sync name from a sync file path (e.g., "test" from "src/examples/_sync/test_server_v1.ts")
+ */
+export declare const extractSyncName: (filePath: string) => string;
+/**
+ * Extract clientInput type body from a sync file's SyncParams interface
+ * Returns the content between the braces of clientInput: { ... }
+ */
+export declare const extractClientInputFromFile: (filePath: string) => string | null;
+/**
+ * Extract clientInput type from the generated apiTypes.generated.ts file
+ * Used when the server file is already deleted but we need to migrate types to client
+ */
+export declare const extractClientInputFromGeneratedTypes: (pagePath: string, syncName: string) => string | null;
+/**
+ * Calculate the relative path prefix (e.g., '../../../') to reach project root from a file
+ * @param filePath - Absolute or relative path to the file
+ * @returns The relative path prefix to reach project root
+ */
+export declare const calculateRelativePath: (filePath: string) => string;
+export declare const injectTemplate: (filePath: string) => Promise<boolean>;
+export declare const shouldInjectTemplate: (filePath: string, options?: {
+    isNewFile?: boolean;
+}) => boolean;
+/**
+ * Update a client file to use the paired template (imports types from generated file)
+ * Called when a _server.ts is created and _client.ts already exists
+ * PRESERVES user's main function code!
+ */
+export declare const updateClientFileForPairedServer: (clientFilePath: string) => Promise<boolean>;
+/**
+ * Update a client file when the paired server file is deleted
+ * Preserves user's main function code while:
+ * - Inlining clientInput types
+ * - Removing serverOutput from SyncParams and main function params
+ */
+export declare const updateClientFileForDeletedServer: (clientFilePath: string, clientInputTypes: string) => Promise<boolean>;
+/**
+ * Inject server template with pre-filled clientInput types (from existing client file)
+ */
+export declare const injectServerTemplateWithClientInput: (serverFilePath: string, clientInputTypes: string) => Promise<boolean>;

package/dist/templateRegistry.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The six template kinds the framework ships out of the box. Consumers may
+ * register additional kinds (e.g. `page_marketing`) via `registerTemplateKind`.
+ */
+export type BuiltInTemplateKind = 'api' | 'sync_server' | 'sync_client_paired' | 'sync_client_standalone' | 'page_plain' | 'page_dashboard';
+export type TemplateKind = BuiltInTemplateKind | (string & {});
+export declare const BUILT_IN_TEMPLATE_KINDS: readonly BuiltInTemplateKind[];
+export declare const BUILT_IN_TEMPLATE_FILENAMES: Record<BuiltInTemplateKind, string>;
+/**
+ * Structural classification of the file an injection is being computed for.
+ * `templateInjector.ts` derives this from the folder + filename conventions
+ * (controlled separately via `registerRoutingRules`). Selection rules match
+ * against it to choose a template kind.
+ */
+export interface TemplateMatchContext {
+    /** Absolute path of the file being created. */
+    filePath: string;
+    /** Structural kind derived from the route conventions. */
+    fileKind: 'api' | 'sync_server' | 'sync_client' | 'page';
+    /** For `sync_client`: whether a paired `_server_v<N>.ts` exists on disk. */
+    hasPairedServer: boolean;
+    /** Path relative to `src/` (forward slashes), or `null` if outside src. */
+    srcRelativePath: string | null;
+}
+/** A single template-selection rule. First matching rule (by priority) wins. */
+export interface TemplateRule {
+    kind: TemplateKind;
+    match: (ctx: TemplateMatchContext) => boolean;
+    /** Higher runs first. Built-in defaults use 10 (specific) / 0 (catch-all). */
+    priority: number;
+}
+export interface RegisterTemplateKindOptions {
+    /** Predicate deciding when this kind is chosen. */
+    match: (ctx: TemplateMatchContext) => boolean;
+    /** Optional inline template body (same as calling `registerTemplate`). */
+    content?: string;
+    /** Higher runs first. Defaults to 100 so consumer kinds beat the built-ins. */
+    priority?: number;
+}
+export declare const DEFAULT_DASHBOARD_PATH_PATTERN: RegExp;
+/**
+ * Override the template body for a given kind. Subsequent injections emit the
+ * supplied content with the standard `{{REL_PATH}}` / `{{PAGE_PATH}}` /
+ * `{{SYNC_NAME}}` placeholder substitution. Resolution order in the injector
+ * is: consumer file (`.luckystack/templates/<kind>.template.*`) → this
+ * override → bundled disk template.
+ */
+export declare const registerTemplate: (kind: TemplateKind, content: string) => void;
+/** Read the registered content override for a kind, or `null` when none. */
+export declare const getRegisteredTemplate: (kind: TemplateKind) => string | null;
+/** Drop every content override. Test-only. */
+export declare const clearTemplateOverrides: () => void;
+/** Diagnostic: kinds that currently have a content override. */
+export declare const listRegisteredTemplateKinds: () => readonly TemplateKind[];
+/**
+ * Register a selection rule. Rules are evaluated by descending `priority`,
+ * ties broken by descending registration order (so a later registration —
+ * e.g. a consumer overlay — beats an earlier same-priority default).
+ */
+export declare const registerTemplateRule: (rule: TemplateRule) => void;
+/**
+ * Register a brand-new template kind: its selection predicate plus (optionally)
+ * its inline content. Equivalent to `registerTemplateRule` + `registerTemplate`
+ * in one call. Default priority 100 so custom kinds win over the built-ins.
+ */
+export declare const registerTemplateKind: (kind: TemplateKind, options: RegisterTemplateKindOptions) => void;
+/** Drop every selection rule (including the built-in defaults). */
+export declare const clearTemplateRules: () => void;
+/** Read the active rules in evaluation order (priority desc, then newest first). */
+export declare const getTemplateRules: () => readonly TemplateRule[];
+/** Evaluate the active rules against a context; returns the first matching kind. */
+export declare const resolveTemplateKind: (ctx: TemplateMatchContext) => TemplateKind | null;
+export declare const registerDefaultTemplateRules: () => void;
+/**
+ * Test-only: clear rules + content overrides AND re-arm the defaults guard so
+ * `registerDefaultTemplateRules()` can repopulate a clean baseline.
+ */
+export declare const resetTemplateRegistryForTests: () => void;

package/dist/typeMap/apiMeta.d.ts

@@ -0,0 +1,42 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+export declare const extractHttpMethod: (filePath: string, apiName: string) => HttpMethod;
+export declare const extractRateLimit: (filePath: string) => number | false | undefined;
+/**
+ * Reads the `export const validation` declaration from an API/sync source
+ * file. Supports `'strict'`, `'relaxed'`, and `{ input: 'skip' | 'strict' }`.
+ * Returns undefined when the export is absent (consumer hasn't opted out).
+ */
+export type ApiValidationMode = 'strict' | 'relaxed' | {
+    input: 'skip' | 'strict';
+};
+export declare const extractValidation: (filePath: string) => ApiValidationMode | undefined;
+/**
+ * AST-extracted JSDoc `@docs` metadata for a route file. Parsed from JSDoc
+ * blocks attached to top-level statements (typically the `main` export).
+ *
+ * Convention (matches docs-ui renderer in `packages/docs-ui/src/docsHtml.ts`):
+ *
+ *   /\*\*
+ *    * Description sentence.
+ *    * @docs owner @mathijs
+ *    * @docs tags admin, internal, deprecated-soon
+ *    * @docs deprecated use api/billing/getInvoice/v2 instead
+ *    *\/
+ *   export const main = async (...) => {...};
+ *
+ * `@docs deprecated` without a reason -> `true` (renders as red "deprecated"
+ * badge without explanation). With a reason -> `string` (renders the
+ * explanation). `@docs tags` is comma-split + trimmed. Unknown sub-keys are
+ * silently ignored so future tags don't break the parser.
+ */
+export interface DocsMeta {
+    owner?: string;
+    tags?: string[];
+    deprecated?: string | true;
+}
+export declare const extractDocsMeta: (filePath: string) => DocsMeta | undefined;
+export declare const extractAuth: (filePath: string) => {
+    login: boolean;
+    additional?: Record<string, unknown>[];
+    hasAdditional: boolean;
+};

package/dist/typeMap/discovery.d.ts

@@ -0,0 +1,3 @@
+export declare const findAllApiFiles: (srcDir: string) => string[];
+export declare const findAllSyncServerFiles: (srcDir: string) => string[];
+export declare const findAllSyncClientFiles: (srcDir: string) => string[];

package/dist/typeMap/emitterArtifacts.d.ts

@@ -0,0 +1,94 @@
+export interface DocsMetaSnapshot {
+    owner?: string;
+    tags?: string[];
+    deprecated?: string | true;
+}
+export interface ApiTypeEntry {
+    input: string;
+    output: string;
+    stream: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    rateLimit: number | false | undefined;
+    auth: unknown;
+    version: string;
+    meta?: DocsMetaSnapshot;
+}
+interface ApiDocsEntry {
+    page: string;
+    name: string;
+    version: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    input: string;
+    output: string;
+    stream: string;
+    rateLimit: number | false | undefined;
+    auth: unknown;
+    path: string;
+    meta?: DocsMetaSnapshot;
+}
+interface SyncDocsEntry {
+    page: string;
+    name: string;
+    version: string;
+    clientInput: string;
+    serverOutput: string;
+    clientOutput: string;
+    serverStream: string;
+    clientStream: string;
+    path: string;
+    meta?: DocsMetaSnapshot;
+}
+export interface GeneratedDocsData {
+    apis: Record<string, ApiDocsEntry[]>;
+    syncs: Record<string, SyncDocsEntry[]>;
+}
+export interface SyncTypeEntry {
+    clientInput: string;
+    serverOutput: string;
+    clientOutput: string;
+    serverStream: string;
+    clientStream: string;
+    version: string;
+    hasServer: boolean;
+    hasClient: boolean;
+    meta?: DocsMetaSnapshot;
+    serverMeta?: SyncServerMeta;
+}
+export interface SyncServerMeta {
+    auth: unknown;
+    rateLimit: number | false | undefined;
+}
+export declare const stripSymbolKeyedMembers: (text: string) => string;
+export interface DiagnosticsEntry {
+    route: string;
+    kind: 'api' | 'sync';
+    field: string;
+    fallback: string;
+    reason: string;
+    detail?: string;
+}
+export interface GeneratedDiagnosticsData {
+    generatedAt: string;
+    totalRoutes: number;
+    fallbackCount: number;
+    fallbacks: DiagnosticsEntry[];
+}
+export declare const buildTypeMapArtifacts: ({ typesByPage, syncTypesByPage, namedImports, defaultImports, functionsInterface, }: {
+    typesByPage: Map<string, Map<string, ApiTypeEntry>>;
+    syncTypesByPage: Map<string, Map<string, SyncTypeEntry>>;
+    namedImports: Map<string, Set<string>>;
+    defaultImports: Map<string, string>;
+    functionsInterface: string;
+}) => {
+    content: string;
+    docsData: GeneratedDocsData;
+    schemasContent: string;
+    diagnosticsData: GeneratedDiagnosticsData;
+};
+export declare const writeTypeMapArtifacts: ({ content, docsData, schemasContent, diagnosticsData, }: {
+    content: string;
+    docsData: GeneratedDocsData;
+    schemasContent?: string;
+    diagnosticsData?: GeneratedDiagnosticsData;
+}) => void;
+export {};

package/dist/typeMap/extractionDiagnostics.d.ts

@@ -0,0 +1,16 @@
+export type ExtractionKind = 'api' | 'sync';
+export interface ExtractionFailure {
+    filePath: string;
+    kind: ExtractionKind;
+    field: string;
+    message: string;
+}
+export declare const recordExtractionOutcome: ({ filePath, kind, field, error, }: {
+    filePath: string;
+    kind: ExtractionKind;
+    field: string;
+    error: unknown;
+}) => void;
+export declare const findExtractionFailure: (route: string, kind: ExtractionKind, field: string) => string | undefined;
+export declare const clearExtractionFailures: () => void;
+export declare const getExtractionFailures: () => ExtractionFailure[];

package/dist/typeMap/extractors.d.ts

@@ -0,0 +1,18 @@
+import { ExpandedTypeResult } from './tsProgram.js';
+export type TypeExtractionResult = ExpandedTypeResult;
+export declare const getInputTypeFromFile: (filePath: string) => string;
+export declare const getInputTypeDetailsFromFile: (filePath: string) => TypeExtractionResult;
+export declare const getOutputTypeFromFile: (filePath: string) => string;
+export declare const getApiStreamPayloadTypeFromFile: (filePath: string) => string;
+export declare const getApiStreamPayloadTypeDetailsFromFile: (filePath: string) => TypeExtractionResult;
+export declare const getOutputTypeDetailsFromFile: (filePath: string) => TypeExtractionResult;
+export declare const getSyncClientDataType: (filePath: string) => string;
+export declare const getSyncClientDataTypeDetailsFromFile: (filePath: string) => TypeExtractionResult;
+export declare const getSyncServerOutputType: (filePath: string) => string;
+export declare const getSyncServerStreamPayloadTypeFromFile: (filePath: string) => string;
+export declare const getSyncServerStreamPayloadTypeDetailsFromFile: (filePath: string) => TypeExtractionResult;
+export declare const getSyncServerOutputTypeDetailsFromFile: (filePath: string) => TypeExtractionResult;
+export declare const getSyncClientOutputType: (filePath: string) => string;
+export declare const getSyncClientStreamPayloadTypeFromFile: (filePath: string) => string;
+export declare const getSyncClientStreamPayloadTypeDetailsFromFile: (filePath: string) => TypeExtractionResult;
+export declare const getSyncClientOutputTypeDetailsFromFile: (filePath: string) => TypeExtractionResult;

package/dist/typeMap/functionsMeta.d.ts

@@ -0,0 +1,5 @@
+import { ImportCollectors } from './typeContext.js';
+export declare const stripLineComments: (value: string) => string;
+export declare const normalizeInlineType: (value: string) => string;
+export declare const portableInferredValueType: (inferred: string, sourceFilePath: string, exportName: string) => string | null;
+export declare const generateServerFunctions: (collectors: ImportCollectors) => string;

package/dist/typeMap/routeMeta.d.ts

@@ -0,0 +1,6 @@
+export declare const extractPagePath: (filePath: string) => string;
+export declare const extractApiName: (filePath: string) => string;
+export declare const extractApiVersion: (filePath: string) => string;
+export declare const extractSyncPagePath: (filePath: string) => string;
+export declare const extractSyncName: (filePath: string) => string;
+export declare const extractSyncVersion: (filePath: string) => string;

package/dist/typeMap/tsApi.d.ts

@@ -0,0 +1,12 @@
+import { type Project, type Snapshot, type TranspileOutput } from 'typescript-7-api/sync';
+import type { ScriptKind, SourceFile } from 'typescript-7-api/ast';
+export interface TsconfigProject {
+    project: Project;
+    snapshot: Snapshot;
+}
+export declare const openTsconfigProject: (tsconfigPath: string) => TsconfigProject;
+export declare const getServerProgram: () => Project;
+export declare const invalidateProgramCache: () => void;
+export declare const disposeTsApi: () => void;
+export declare const parseSourceText: (fileName: string, text: string, scriptKind?: ScriptKind) => SourceFile;
+export declare const transpileSourceText: (fileName: string, text: string) => TranspileOutput;

package/dist/typeMap/tsProgram.d.ts

@@ -0,0 +1,41 @@
+import { type Checker, type Symbol as TsSymbol, type Type } from 'typescript-7-api/sync';
+export interface UnresolvedTypeSymbol {
+    name: string;
+    sourceFile?: string;
+    importPath?: string;
+}
+export interface ExpandedTypeResult {
+    text: string;
+    unresolvedSymbols: UnresolvedTypeSymbol[];
+}
+export declare class UnsupportedWireTypeError extends Error {
+    constructor(typeName: string);
+}
+export declare const getDeclarationFileName: (symbol: TsSymbol) => string | undefined;
+interface ExpandState {
+    stackTypeIds: Set<number>;
+    /**
+     * Model what the CLIENT actually receives, not what the handler returns.
+     *
+     * Everything on an OUTPUT path crosses the wire as JSON — socket.io's default
+     * parser is `JSON.stringify`, and the HTTP route does the same. JSON has no
+     * `Date`: `Date.prototype.toJSON()` turns it into an ISO string. So emitting
+     * `createdAt: Date` was a lie that TypeScript happily endorsed —
+     * `user.createdAt.getTime()` compiled and then threw at runtime.
+     *
+     * OUTPUTS ONLY. Wire-safe inputs stay unprojected because their text feeds
+     * `validateInputByType`, which is fail-closed. `extractors.ts` separately
+     * rejects Date input annotations: JSON cannot deliver the promised instance.
+     */
+    wireProjection: boolean;
+}
+export interface ExpandOptions {
+    /**
+     * Emit what the client RECEIVES rather than what the handler returns.
+     * Pass `true` for every OUTPUT type; never for an input (see `ExpandState`).
+     */
+    wireProjection?: boolean;
+}
+export declare const expandTypeDetailed: (type: Type, checker: Checker, depth?: number, state?: ExpandState, options?: ExpandOptions) => ExpandedTypeResult;
+export declare const expandType: (type: Type, checker: Checker, depth?: number) => string;
+export {};

package/dist/typeMap/typeContext.d.ts

@@ -0,0 +1,21 @@
+export interface FileImport {
+    source: string;
+    isDefault: boolean;
+    originalName?: string;
+}
+export interface ImportCollectors {
+    namedImports: Map<string, Set<string>>;
+    defaultImports: Map<string, string>;
+}
+export declare const parseFileTypeContext: (content: string) => {
+    availableExports: Set<string>;
+    fileImports: Map<string, FileImport>;
+};
+export declare const sanitizeTypeAndCollectImports: ({ type, filePath, availableExports, fileImports, collectors, knownGenerics, }: {
+    type: string;
+    filePath: string;
+    availableExports: Set<string>;
+    fileImports: Map<string, FileImport>;
+    collectors: ImportCollectors;
+    knownGenerics?: Set<string>;
+}) => string;

package/dist/typeMap/zodEmitter.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Convert a TypeScript type expression string (as emitted into the generated
+ * file) into a Zod schema source string.
+ *
+ * Returns `null` when the input can't be parsed as a type — callers should
+ * fall back to `z.any()` in that case.
+ */
+export declare const typeTextToZodSource: (typeText: string) => string | null;

package/dist/typeMapGenerator.d.ts

@@ -0,0 +1,5 @@
+interface GenerateTypeMapOptions {
+    quiet?: boolean;
+}
+export declare const generateTypeMapFile: (options?: GenerateTypeMapOptions) => void;
+export {};