@glossic/schema 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rody Huancas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,637 @@
+import { z } from 'zod';
+
+/** Where generate and scan write, relative to the workspace root. */
+declare const OutputConfigSchema: z.ZodObject<{
+    dir: z.ZodDefault<z.ZodString>;
+    manifest: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type OutputConfig = z.infer<typeof OutputConfigSchema>;
+/** Every option glossic accepts, with the default that applies when nothing sets it. */
+declare const GlossicConfigSchema: z.ZodObject<{
+    include: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    adapters: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    ignoreUnits: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    excludeFromContent: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    mergeChildrenInto: z.ZodDefault<z.ZodNumber>;
+    minUnitFiles: z.ZodDefault<z.ZodNumber>;
+    maxUnitFiles: z.ZodDefault<z.ZodNumber>;
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    lang: z.ZodDefault<z.ZodString>;
+    uiLang: z.ZodDefault<z.ZodEnum<{
+        en: "en";
+        es: "es";
+    }>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodDefault<z.ZodObject<{
+        dir: z.ZodDefault<z.ZodString>;
+        manifest: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * `GlossicConfig` is the config once the defaults are applied, so every key is
+ * present; `GlossicUserConfig` is the same shape as a person writes it.
+ */
+type GlossicConfig = z.infer<typeof GlossicConfigSchema>;
+type GlossicUserConfig = z.input<typeof GlossicConfigSchema>;
+/** Types a glossic.config.ts without making the project import zod. */
+declare const defineConfig: (config: GlossicUserConfig) => GlossicUserConfig;
+
+declare const UnitKindSchema: z.ZodEnum<{
+    file: "file";
+    directory: "directory";
+    module: "module";
+}>;
+type UnitKind = z.infer<typeof UnitKindSchema>;
+/** What a directory appears to hold, inferred from its name. */
+declare const RoleHintSchema: z.ZodEnum<{
+    components: "components";
+    config: "config";
+    controllers: "controllers";
+    dtos: "dtos";
+    entities: "entities";
+    hooks: "hooks";
+    middleware: "middleware";
+    models: "models";
+    routes: "routes";
+    services: "services";
+    tests: "tests";
+    utils: "utils";
+}>;
+type RoleHint = z.infer<typeof RoleHintSchema>;
+/** One documentable file: where it lives, its language and its size. */
+declare const FileFactSchema: z.ZodObject<{
+    path: z.ZodString;
+    language: z.ZodString;
+    bytes: z.ZodNumber;
+}, z.core.$strip>;
+type FileFact = z.infer<typeof FileFactSchema>;
+declare const LanguageCountSchema: z.ZodObject<{
+    language: z.ZodString;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+type LanguageCount = z.infer<typeof LanguageCountSchema>;
+/** What any adapter can state about a unit, whatever the language. */
+declare const BaseFactsSchema: z.ZodObject<{
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        language: z.ZodString;
+        bytes: z.ZodNumber;
+    }, z.core.$strip>>;
+    testFiles: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        language: z.ZodString;
+        bytes: z.ZodNumber;
+    }, z.core.$strip>>;
+    ignoredFiles: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        language: z.ZodString;
+        bytes: z.ZodNumber;
+    }, z.core.$strip>>;
+    languages: z.ZodArray<z.ZodObject<{
+        language: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+    roleHint: z.ZodNullable<z.ZodEnum<{
+        components: "components";
+        config: "config";
+        controllers: "controllers";
+        dtos: "dtos";
+        entities: "entities";
+        hooks: "hooks";
+        middleware: "middleware";
+        models: "models";
+        routes: "routes";
+        services: "services";
+        tests: "tests";
+        utils: "utils";
+    }>>;
+}, z.core.$strip>;
+type BaseFacts = z.infer<typeof BaseFactsSchema>;
+declare const SymbolKindSchema: z.ZodEnum<{
+    function: "function";
+    enum: "enum";
+    type: "type";
+    class: "class";
+    const: "const";
+    interface: "interface";
+    method: "method";
+    other: "other";
+}>;
+type SymbolKind = z.infer<typeof SymbolKindSchema>;
+/** One declaration a language-aware adapter recognised. */
+declare const SymbolFactSchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        function: "function";
+        enum: "enum";
+        type: "type";
+        class: "class";
+        const: "const";
+        interface: "interface";
+        method: "method";
+        other: "other";
+    }>;
+    file: z.ZodString;
+    signature: z.ZodOptional<z.ZodString>;
+    exported: z.ZodBoolean;
+    line: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type SymbolFact = z.infer<typeof SymbolFactSchema>;
+declare const SymbolFactsSchema: z.ZodObject<{
+    symbols: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            function: "function";
+            enum: "enum";
+            type: "type";
+            class: "class";
+            const: "const";
+            interface: "interface";
+            method: "method";
+            other: "other";
+        }>;
+        file: z.ZodString;
+        signature: z.ZodOptional<z.ZodString>;
+        exported: z.ZodBoolean;
+        line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type SymbolFacts = z.infer<typeof SymbolFactsSchema>;
+/** One HTTP route a framework-aware adapter recognised. */
+declare const RouteFactSchema: z.ZodObject<{
+    method: z.ZodString;
+    path: z.ZodString;
+    handler: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RouteFact = z.infer<typeof RouteFactSchema>;
+/** What a framework-aware adapter adds on top of the base facts. */
+declare const FrameworkFactsSchema: z.ZodObject<{
+    name: z.ZodString;
+    role: z.ZodOptional<z.ZodString>;
+    routes: z.ZodArray<z.ZodObject<{
+        method: z.ZodString;
+        path: z.ZodString;
+        handler: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    dependencies: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type FrameworkFacts = z.infer<typeof FrameworkFactsSchema>;
+/** Everything known about a unit; `producedBy` names the adapters that contributed. */
+declare const FactsSchema: z.ZodObject<{
+    base: z.ZodObject<{
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            language: z.ZodString;
+            bytes: z.ZodNumber;
+        }, z.core.$strip>>;
+        testFiles: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            language: z.ZodString;
+            bytes: z.ZodNumber;
+        }, z.core.$strip>>;
+        ignoredFiles: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            language: z.ZodString;
+            bytes: z.ZodNumber;
+        }, z.core.$strip>>;
+        languages: z.ZodArray<z.ZodObject<{
+            language: z.ZodString;
+            count: z.ZodNumber;
+        }, z.core.$strip>>;
+        roleHint: z.ZodNullable<z.ZodEnum<{
+            components: "components";
+            config: "config";
+            controllers: "controllers";
+            dtos: "dtos";
+            entities: "entities";
+            hooks: "hooks";
+            middleware: "middleware";
+            models: "models";
+            routes: "routes";
+            services: "services";
+            tests: "tests";
+            utils: "utils";
+        }>>;
+    }, z.core.$strip>;
+    symbols: z.ZodOptional<z.ZodObject<{
+        symbols: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                function: "function";
+                enum: "enum";
+                type: "type";
+                class: "class";
+                const: "const";
+                interface: "interface";
+                method: "method";
+                other: "other";
+            }>;
+            file: z.ZodString;
+            signature: z.ZodOptional<z.ZodString>;
+            exported: z.ZodBoolean;
+            line: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    framework: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        role: z.ZodOptional<z.ZodString>;
+        routes: z.ZodArray<z.ZodObject<{
+            method: z.ZodString;
+            path: z.ZodString;
+            handler: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        dependencies: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    producedBy: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type Facts = z.infer<typeof FactsSchema>;
+/** A documentable chunk of a project: the thing one page of documentation describes. */
+declare const UnitSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+    kind: z.ZodEnum<{
+        file: "file";
+        directory: "directory";
+        module: "module";
+    }>;
+    name: z.ZodString;
+    path: z.ZodString;
+    facts: z.ZodObject<{
+        base: z.ZodObject<{
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                language: z.ZodString;
+                bytes: z.ZodNumber;
+            }, z.core.$strip>>;
+            testFiles: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                language: z.ZodString;
+                bytes: z.ZodNumber;
+            }, z.core.$strip>>;
+            ignoredFiles: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                language: z.ZodString;
+                bytes: z.ZodNumber;
+            }, z.core.$strip>>;
+            languages: z.ZodArray<z.ZodObject<{
+                language: z.ZodString;
+                count: z.ZodNumber;
+            }, z.core.$strip>>;
+            roleHint: z.ZodNullable<z.ZodEnum<{
+                components: "components";
+                config: "config";
+                controllers: "controllers";
+                dtos: "dtos";
+                entities: "entities";
+                hooks: "hooks";
+                middleware: "middleware";
+                models: "models";
+                routes: "routes";
+                services: "services";
+                tests: "tests";
+                utils: "utils";
+            }>>;
+        }, z.core.$strip>;
+        symbols: z.ZodOptional<z.ZodObject<{
+            symbols: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                kind: z.ZodEnum<{
+                    function: "function";
+                    enum: "enum";
+                    type: "type";
+                    class: "class";
+                    const: "const";
+                    interface: "interface";
+                    method: "method";
+                    other: "other";
+                }>;
+                file: z.ZodString;
+                signature: z.ZodOptional<z.ZodString>;
+                exported: z.ZodBoolean;
+                line: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        framework: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            role: z.ZodOptional<z.ZodString>;
+            routes: z.ZodArray<z.ZodObject<{
+                method: z.ZodString;
+                path: z.ZodString;
+                handler: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            dependencies: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        producedBy: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    hash: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Unit = z.infer<typeof UnitSchema>;
+declare const RelationKindSchema: z.ZodEnum<{
+    imports: "imports";
+    calls: "calls";
+    extends: "extends";
+    implements: "implements";
+    injects: "injects";
+    exposes: "exposes";
+    references: "references";
+    contains: "contains";
+}>;
+type RelationKind = z.infer<typeof RelationKindSchema>;
+/** A directed edge between two units, by unit id. */
+declare const RelationSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    kind: z.ZodEnum<{
+        imports: "imports";
+        calls: "calls";
+        extends: "extends";
+        implements: "implements";
+        injects: "injects";
+        exposes: "exposes";
+        references: "references";
+        contains: "contains";
+    }>;
+    weight: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type Relation = z.infer<typeof RelationSchema>;
+
+/** The tool that defines the project list, or "none" for a single-project repo. */
+declare const WorkspaceToolSchema: z.ZodEnum<{
+    pnpm: "pnpm";
+    "npm-workspaces": "npm-workspaces";
+    turbo: "turbo";
+    nx: "nx";
+    lerna: "lerna";
+    none: "none";
+}>;
+type WorkspaceTool = z.infer<typeof WorkspaceToolSchema>;
+/** One package inside the workspace. */
+declare const ProjectSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    rootDir: z.ZodString;
+    packageManager: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Project = z.infer<typeof ProjectSchema>;
+/** The scanned repository and the projects found inside it. */
+declare const WorkspaceSchema: z.ZodObject<{
+    name: z.ZodString;
+    root: z.ZodString;
+    isMonorepo: z.ZodBoolean;
+    tool: z.ZodEnum<{
+        pnpm: "pnpm";
+        "npm-workspaces": "npm-workspaces";
+        turbo: "turbo";
+        nx: "nx";
+        lerna: "lerna";
+        none: "none";
+    }>;
+    packageManager: z.ZodOptional<z.ZodString>;
+    projects: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        rootDir: z.ZodString;
+        packageManager: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type Workspace = z.infer<typeof WorkspaceSchema>;
+
+/** What every adapter call receives: the workspace being scanned and the resolved config. */
+interface AdapterContext {
+    root: string;
+    workspace: Workspace;
+    config: GlossicConfig;
+}
+interface DiscoverContext extends AdapterContext {
+    project: Project;
+}
+/** A unit as discovery found it: paths only, before a single file has been read. */
+interface DiscoveredUnit {
+    id: string;
+    projectId: string;
+    name: string;
+    path: string;
+    files: string[];
+    testFiles: string[];
+    ignoredFiles: string[];
+}
+interface ExtractContext extends DiscoverContext {
+    units: DiscoveredUnit[];
+}
+interface ExtractResult {
+    units: Unit[];
+    relations: Relation[];
+}
+/**
+ * Turns a project's files into units. `detect` decides whether this adapter
+ * claims the project; the first one that says yes wins.
+ */
+interface Adapter {
+    readonly name: string;
+    detect(ctx: DiscoverContext): Promise<boolean>;
+    discover(ctx: DiscoverContext): Promise<DiscoveredUnit[]>;
+    extract(ctx: ExtractContext): Promise<ExtractResult>;
+}
+
+/** Why a completion failed, in the vocabulary every provider maps its own errors onto. */
+type ProviderErrorCode = "not-installed" | "unauthenticated" | "timeout" | "rate-limit" | "server" | "exit-code" | "invalid-output" | "invalid-content" | "refused" | "api";
+interface ProviderErrorOptions {
+    provider: string;
+    code: ProviderErrorCode;
+    message: string;
+    detail?: string | undefined;
+    cause?: unknown;
+}
+/**
+ * A completion failure carrying a code, so callers can react to the kind of
+ * failure without parsing the message.
+ */
+declare class ProviderError extends Error {
+    readonly provider: string;
+    readonly code: ProviderErrorCode;
+    readonly detail: string | undefined;
+    constructor(options: ProviderErrorOptions);
+}
+declare const isProviderError: (value: unknown) => value is ProviderError;
+/** True for the codes worth another attempt: timeout, rate limit, server error. */
+declare const isRetryableProviderError: (value: unknown) => boolean;
+
+/** Bumped by hand when the manifest shape changes. */
+declare const MANIFEST_VERSION = "1";
+/** A whole scan, serialised. `generatedAt` is its only volatile field. */
+declare const ManifestSchema: z.ZodObject<{
+    version: z.ZodString;
+    generatedAt: z.ZodString;
+    workspace: z.ZodObject<{
+        name: z.ZodString;
+        root: z.ZodString;
+        isMonorepo: z.ZodBoolean;
+        tool: z.ZodEnum<{
+            pnpm: "pnpm";
+            "npm-workspaces": "npm-workspaces";
+            turbo: "turbo";
+            nx: "nx";
+            lerna: "lerna";
+            none: "none";
+        }>;
+        packageManager: z.ZodOptional<z.ZodString>;
+        projects: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            rootDir: z.ZodString;
+            packageManager: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    units: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodString;
+        kind: z.ZodEnum<{
+            file: "file";
+            directory: "directory";
+            module: "module";
+        }>;
+        name: z.ZodString;
+        path: z.ZodString;
+        facts: z.ZodObject<{
+            base: z.ZodObject<{
+                files: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    language: z.ZodString;
+                    bytes: z.ZodNumber;
+                }, z.core.$strip>>;
+                testFiles: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    language: z.ZodString;
+                    bytes: z.ZodNumber;
+                }, z.core.$strip>>;
+                ignoredFiles: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    language: z.ZodString;
+                    bytes: z.ZodNumber;
+                }, z.core.$strip>>;
+                languages: z.ZodArray<z.ZodObject<{
+                    language: z.ZodString;
+                    count: z.ZodNumber;
+                }, z.core.$strip>>;
+                roleHint: z.ZodNullable<z.ZodEnum<{
+                    components: "components";
+                    config: "config";
+                    controllers: "controllers";
+                    dtos: "dtos";
+                    entities: "entities";
+                    hooks: "hooks";
+                    middleware: "middleware";
+                    models: "models";
+                    routes: "routes";
+                    services: "services";
+                    tests: "tests";
+                    utils: "utils";
+                }>>;
+            }, z.core.$strip>;
+            symbols: z.ZodOptional<z.ZodObject<{
+                symbols: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    kind: z.ZodEnum<{
+                        function: "function";
+                        enum: "enum";
+                        type: "type";
+                        class: "class";
+                        const: "const";
+                        interface: "interface";
+                        method: "method";
+                        other: "other";
+                    }>;
+                    file: z.ZodString;
+                    signature: z.ZodOptional<z.ZodString>;
+                    exported: z.ZodBoolean;
+                    line: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            framework: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                role: z.ZodOptional<z.ZodString>;
+                routes: z.ZodArray<z.ZodObject<{
+                    method: z.ZodString;
+                    path: z.ZodString;
+                    handler: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                dependencies: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            producedBy: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        hash: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    relations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        kind: z.ZodEnum<{
+            imports: "imports";
+            calls: "calls";
+            extends: "extends";
+            implements: "implements";
+            injects: "injects";
+            exposes: "exposes";
+            references: "references";
+            contains: "contains";
+        }>;
+        weight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type Manifest = z.infer<typeof ManifestSchema>;
+
+/** One prompt on its way to a provider, in terms no provider owns. */
+declare const CompletionRequestSchema: z.ZodObject<{
+    system: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type CompletionRequest = z.infer<typeof CompletionRequestSchema>;
+/** Token counts a provider reports back, when it reports them at all. */
+declare const CompletionUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    cacheReadTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type CompletionUsage = z.infer<typeof CompletionUsageSchema>;
+/** The prose a provider wrote, plus whatever it can say about what it cost. */
+declare const CompletionResultSchema: z.ZodObject<{
+    text: z.ZodString;
+    model: z.ZodString;
+    usage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    costUsd: z.ZodOptional<z.ZodNumber>;
+    raw: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+type CompletionResult = z.infer<typeof CompletionResultSchema>;
+/** Writes prose from a prompt. `available` is what provider auto-detection probes. */
+interface Provider {
+    readonly name: string;
+    available(): Promise<boolean>;
+    complete(request: CompletionRequest): Promise<CompletionResult>;
+}
+
+/** Rewrites a native path with posix separators, so output matches on every OS. */
+declare const toPosix: (value: string) => string;
+/** Posix path from one location to another, "." when they are the same. */
+declare const relativePosix: (from: string, target: string) => string;
+/** Joins two posix fragments, tolerating "." or "" on either side. */
+declare const joinPosix: (base: string, segment: string) => string;
+
+/** Total order over strings, so a sort never depends on the machine's locale. */
+declare const compareStrings: (a: string, b: string) => number;
+/** Sorts a copy by a string key, leaving the input untouched. */
+declare const sortBy: <T>(values: readonly T[], key: (value: T) => string) => T[];
+
+export { type Adapter, type AdapterContext, type BaseFacts, BaseFactsSchema, type CompletionRequest, CompletionRequestSchema, type CompletionResult, CompletionResultSchema, type CompletionUsage, CompletionUsageSchema, type DiscoverContext, type DiscoveredUnit, type ExtractContext, type ExtractResult, type Facts, FactsSchema, type FileFact, FileFactSchema, type FrameworkFacts, FrameworkFactsSchema, type GlossicConfig, GlossicConfigSchema, type GlossicUserConfig, type LanguageCount, LanguageCountSchema, MANIFEST_VERSION, type Manifest, ManifestSchema, type OutputConfig, OutputConfigSchema, type Project, ProjectSchema, type Provider, ProviderError, type ProviderErrorCode, type ProviderErrorOptions, type Relation, type RelationKind, RelationKindSchema, RelationSchema, type RoleHint, RoleHintSchema, type RouteFact, RouteFactSchema, type SymbolFact, SymbolFactSchema, type SymbolFacts, SymbolFactsSchema, type SymbolKind, SymbolKindSchema, type Unit, type UnitKind, UnitKindSchema, UnitSchema, type Workspace, WorkspaceSchema, type WorkspaceTool, WorkspaceToolSchema, compareStrings, defineConfig, isProviderError, isRetryableProviderError, joinPosix, relativePosix, sortBy, toPosix };

package/dist/index.js

@@ -0,0 +1,245 @@
+import { z } from 'zod';
+import path from 'path';
+
+// src/config.ts
+var OutputConfigSchema = z.object({
+  dir: z.string().default("docs"),
+  manifest: z.string().default(".glossic/manifest.json")
+});
+var GlossicConfigSchema = z.object({
+  include: z.array(z.string()).default(["**/*"]),
+  exclude: z.array(z.string()).default(["**/node_modules/**", "**/dist/**", "**/vendor/**"]),
+  adapters: z.array(z.string()).default(["nestjs", "treesitter", "generic"]),
+  ignoreUnits: z.array(z.string()).default([
+    "*.config.ts",
+    "*.config.mts",
+    "*.config.cts",
+    "*.config.js",
+    "*.config.mjs",
+    "*.config.cjs",
+    "*.config.json",
+    "tsconfig*.json",
+    "package.json",
+    ".*",
+    "**/migrations/**",
+    "**/migration/**",
+    "**/seeders/**",
+    "**/seeds/**",
+    "**/__generated__/**",
+    "**/generated/**",
+    "**/*.generated.*"
+  ]),
+  excludeFromContent: z.array(z.string()).default(["**/*.test.*", "**/*.spec.*", "**/__tests__/**"]),
+  mergeChildrenInto: z.number().int().positive().default(25),
+  minUnitFiles: z.number().int().positive().default(3),
+  maxUnitFiles: z.number().int().positive().default(10),
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  lang: z.string().default("en"),
+  uiLang: z.enum(["en", "es"]).default("en"),
+  temperature: z.number().min(0).max(2).optional(),
+  output: OutputConfigSchema.default({ dir: "docs", manifest: ".glossic/manifest.json" }),
+  concurrency: z.number().int().positive().default(3),
+  timeoutMs: z.number().int().positive().default(3e5)
+});
+var defineConfig = (config) => config;
+
+// src/errors.ts
+var RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "timeout",
+  "rate-limit",
+  "server"
+]);
+var ProviderError = class extends Error {
+  provider;
+  code;
+  detail;
+  constructor(options) {
+    super(options.message, options.cause === void 0 ? {} : { cause: options.cause });
+    this.name = "ProviderError";
+    this.provider = options.provider;
+    this.code = options.code;
+    this.detail = options.detail;
+  }
+};
+var isProviderError = (value) => {
+  return value instanceof ProviderError;
+};
+var isRetryableProviderError = (value) => {
+  return isProviderError(value) && RETRYABLE_CODES.has(value.code);
+};
+var WorkspaceToolSchema = z.enum([
+  "pnpm",
+  "npm-workspaces",
+  "turbo",
+  "nx",
+  "lerna",
+  "none"
+]);
+var ProjectSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  rootDir: z.string().min(1),
+  packageManager: z.string().optional()
+});
+var WorkspaceSchema = z.object({
+  name: z.string().min(1),
+  root: z.string().min(1),
+  isMonorepo: z.boolean(),
+  tool: WorkspaceToolSchema,
+  packageManager: z.string().optional(),
+  projects: z.array(ProjectSchema)
+});
+var UnitKindSchema = z.enum(["directory", "module", "file"]);
+var RoleHintSchema = z.enum([
+  "components",
+  "config",
+  "controllers",
+  "dtos",
+  "entities",
+  "hooks",
+  "middleware",
+  "models",
+  "routes",
+  "services",
+  "tests",
+  "utils"
+]);
+var FileFactSchema = z.object({
+  path: z.string().min(1),
+  language: z.string().min(1),
+  bytes: z.number().int().nonnegative()
+});
+var LanguageCountSchema = z.object({
+  language: z.string().min(1),
+  count: z.number().int().positive()
+});
+var BaseFactsSchema = z.object({
+  files: z.array(FileFactSchema),
+  testFiles: z.array(FileFactSchema),
+  ignoredFiles: z.array(FileFactSchema),
+  languages: z.array(LanguageCountSchema),
+  roleHint: RoleHintSchema.nullable()
+});
+var SymbolKindSchema = z.enum([
+  "class",
+  "const",
+  "enum",
+  "function",
+  "interface",
+  "method",
+  "type",
+  "other"
+]);
+var SymbolFactSchema = z.object({
+  name: z.string().min(1),
+  kind: SymbolKindSchema,
+  file: z.string().min(1),
+  signature: z.string().optional(),
+  exported: z.boolean(),
+  line: z.number().int().positive().optional()
+});
+var SymbolFactsSchema = z.object({
+  symbols: z.array(SymbolFactSchema)
+});
+var RouteFactSchema = z.object({
+  method: z.string().min(1),
+  path: z.string().min(1),
+  handler: z.string().optional()
+});
+var FrameworkFactsSchema = z.object({
+  name: z.string().min(1),
+  role: z.string().optional(),
+  routes: z.array(RouteFactSchema),
+  dependencies: z.array(z.string())
+});
+var FactsSchema = z.object({
+  base: BaseFactsSchema,
+  symbols: SymbolFactsSchema.optional(),
+  framework: FrameworkFactsSchema.optional(),
+  producedBy: z.array(z.string().min(1)).min(1)
+});
+var UnitSchema = z.object({
+  id: z.string().min(1),
+  projectId: z.string().min(1),
+  kind: UnitKindSchema,
+  name: z.string().min(1),
+  path: z.string().min(1),
+  facts: FactsSchema,
+  hash: z.string().min(1),
+  summary: z.string().optional()
+});
+var RelationKindSchema = z.enum([
+  "imports",
+  "calls",
+  "extends",
+  "implements",
+  "injects",
+  "exposes",
+  "references",
+  "contains"
+]);
+var RelationSchema = z.object({
+  from: z.string().min(1),
+  to: z.string().min(1),
+  kind: RelationKindSchema,
+  weight: z.number().optional()
+});
+
+// src/manifest.ts
+var MANIFEST_VERSION = "1";
+var ManifestSchema = z.object({
+  version: z.string().min(1),
+  generatedAt: z.string().min(1),
+  workspace: WorkspaceSchema,
+  units: z.array(UnitSchema).default([]),
+  relations: z.array(RelationSchema).default([])
+});
+var CompletionRequestSchema = z.object({
+  system: z.string().optional(),
+  prompt: z.string().min(1),
+  model: z.string().optional(),
+  maxTokens: z.number().int().positive().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  metadata: z.record(z.string(), z.unknown()).default({})
+});
+var CompletionUsageSchema = z.object({
+  inputTokens: z.number().int().nonnegative(),
+  outputTokens: z.number().int().nonnegative(),
+  cacheReadTokens: z.number().int().nonnegative().optional()
+});
+var CompletionResultSchema = z.object({
+  text: z.string(),
+  model: z.string(),
+  usage: CompletionUsageSchema.optional(),
+  costUsd: z.number().nonnegative().optional(),
+  raw: z.unknown().optional()
+});
+var toPosix = (value) => value.split(path.sep).join("/");
+var relativePosix = (from, target) => {
+  const relative = toPosix(path.relative(from, target));
+  return relative === "" ? "." : relative;
+};
+var joinPosix = (base, segment) => {
+  if (base === "." || base === "") {
+    return segment;
+  }
+  if (segment === "." || segment === "") {
+    return base;
+  }
+  return `${base}/${segment}`;
+};
+
+// src/utils/strings.ts
+var compareStrings = (a, b) => {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+};
+var sortBy = (values, key) => {
+  return [...values].sort((a, b) => compareStrings(key(a), key(b)));
+};
+
+export { BaseFactsSchema, CompletionRequestSchema, CompletionResultSchema, CompletionUsageSchema, FactsSchema, FileFactSchema, FrameworkFactsSchema, GlossicConfigSchema, LanguageCountSchema, MANIFEST_VERSION, ManifestSchema, OutputConfigSchema, ProjectSchema, ProviderError, RelationKindSchema, RelationSchema, RoleHintSchema, RouteFactSchema, SymbolFactSchema, SymbolFactsSchema, SymbolKindSchema, UnitKindSchema, UnitSchema, WorkspaceSchema, WorkspaceToolSchema, compareStrings, defineConfig, isProviderError, isRetryableProviderError, joinPosix, relativePosix, sortBy, toPosix };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config.ts","../src/errors.ts","../src/workspace.ts","../src/unit.ts","../src/manifest.ts","../src/provider.ts","../src/utils/paths.ts","../src/utils/strings.ts"],"names":["z"],"mappings":"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","file":"index.js","sourcesContent":["import { z } from \"zod\";\n\n/** Where generate and scan write, relative to the workspace root. */\nexport const OutputConfigSchema = z.object({\n  dir     : z.string().default(\"docs\"),\n  manifest: z.string().default(\".glossic/manifest.json\"),\n});\nexport type OutputConfig = z.infer<typeof OutputConfigSchema>;\n\n\n/** Every option glossic accepts, with the default that applies when nothing sets it. */\nexport const GlossicConfigSchema = z.object({\n  include    : z.array(z.string()).default([\"**/*\"]),\n  exclude    : z.array(z.string()).default([\"**/node_modules/**\", \"**/dist/**\", \"**/vendor/**\"]),\n  adapters   : z.array(z.string()).default([\"nestjs\", \"treesitter\", \"generic\"]),\n  ignoreUnits: z\n    .array(z.string())\n    .default([\n      \"*.config.ts\",\n      \"*.config.mts\",\n      \"*.config.cts\",\n      \"*.config.js\",\n      \"*.config.mjs\",\n      \"*.config.cjs\",\n      \"*.config.json\",\n      \"tsconfig*.json\",\n      \"package.json\",\n      \".*\",\n      \"**/migrations/**\",\n      \"**/migration/**\",\n      \"**/seeders/**\",\n      \"**/seeds/**\",\n      \"**/__generated__/**\",\n      \"**/generated/**\",\n      \"**/*.generated.*\",\n    ]),\n\n  excludeFromContent: z\n    .array(z.string())\n    .default([\"**/*.test.*\", \"**/*.spec.*\", \"**/__tests__/**\"]),\n\n  mergeChildrenInto: z.number().int().positive().default(25),\n  minUnitFiles     : z.number().int().positive().default(3),\n  maxUnitFiles     : z.number().int().positive().default(10),\n  provider         : z.string().optional(),\n  model            : z.string().optional(),\n  lang             : z.string().default(\"en\"),\n  uiLang           : z.enum([\"en\", \"es\"]).default(\"en\"),\n  temperature      : z.number().min(0).max(2).optional(),\n  output           : OutputConfigSchema.default({ dir: \"docs\", manifest: \".glossic/manifest.json\" }),\n  concurrency      : z.number().int().positive().default(3),\n  timeoutMs        : z.number().int().positive().default(300_000),\n});\n\n\n/**\n * `GlossicConfig` is the config once the defaults are applied, so every key is\n * present; `GlossicUserConfig` is the same shape as a person writes it.\n */\nexport type GlossicConfig     = z.infer<typeof GlossicConfigSchema>;\nexport type GlossicUserConfig = z.input<typeof GlossicConfigSchema>;\n\n/** Types a glossic.config.ts without making the project import zod. */\nexport const defineConfig = (config: GlossicUserConfig): GlossicUserConfig => config;\n","/** Why a completion failed, in the vocabulary every provider maps its own errors onto. */\nexport type ProviderErrorCode =\n  | \"not-installed\"\n  | \"unauthenticated\"\n  | \"timeout\"\n  | \"rate-limit\"\n  | \"server\"\n  | \"exit-code\"\n  | \"invalid-output\"\n  | \"invalid-content\"\n  | \"refused\"\n  | \"api\";\n\n\nconst RETRYABLE_CODES: ReadonlySet<ProviderErrorCode> = new Set([\n  \"timeout\",\n  \"rate-limit\",\n  \"server\",\n]);\n\nexport interface ProviderErrorOptions {\n  provider : string;\n  code     : ProviderErrorCode;\n  message  : string;\n  detail  ?: string | undefined;\n  cause   ?: unknown;\n}\n\n/**\n * A completion failure carrying a code, so callers can react to the kind of\n * failure without parsing the message.\n */\nexport class ProviderError extends Error {\n  readonly provider: string;\n  readonly code    : ProviderErrorCode;\n  readonly detail  : string | undefined;\n\n  constructor(options: ProviderErrorOptions) {\n    super(options.message, options.cause === undefined ? {} : { cause: options.cause });\n    this.name     = \"ProviderError\";\n    this.provider = options.provider;\n    this.code     = options.code;\n    this.detail   = options.detail;\n  }\n}\n\nexport const isProviderError = (value: unknown): value is ProviderError => {\n  return value instanceof ProviderError;\n}\n\n/** True for the codes worth another attempt: timeout, rate limit, server error. */\nexport const isRetryableProviderError = (value: unknown): boolean => {\n  return isProviderError(value) && RETRYABLE_CODES.has(value.code);\n}\n","import { z } from \"zod\";\n\n/** The tool that defines the project list, or \"none\" for a single-project repo. */\nexport const WorkspaceToolSchema = z.enum([\n  \"pnpm\",\n  \"npm-workspaces\",\n  \"turbo\",\n  \"nx\",\n  \"lerna\",\n  \"none\",\n]);\n\nexport type WorkspaceTool = z.infer<typeof WorkspaceToolSchema>;\n\n\n/** One package inside the workspace. */\nexport const ProjectSchema = z.object({\n  id            : z.string().min(1),\n  name          : z.string().min(1),\n  rootDir       : z.string().min(1),\n  packageManager: z.string().optional(),\n});\n\nexport type Project = z.infer<typeof ProjectSchema>;\n\n\n/** The scanned repository and the projects found inside it. */\nexport const WorkspaceSchema = z.object({\n  name          : z.string().min(1),\n  root          : z.string().min(1),\n  isMonorepo    : z.boolean(),\n  tool          : WorkspaceToolSchema,\n  packageManager: z.string().optional(),\n  projects      : z.array(ProjectSchema),\n});\n\nexport type Workspace = z.infer<typeof WorkspaceSchema>;\n","import { z } from \"zod\";\n\nexport const UnitKindSchema = z.enum([\"directory\", \"module\", \"file\"]);\nexport type UnitKind = z.infer<typeof UnitKindSchema>;\n\n/** What a directory appears to hold, inferred from its name. */\nexport const RoleHintSchema = z.enum([\n  \"components\",\n  \"config\",\n  \"controllers\",\n  \"dtos\",\n  \"entities\",\n  \"hooks\",\n  \"middleware\",\n  \"models\",\n  \"routes\",\n  \"services\",\n  \"tests\",\n  \"utils\",\n]);\nexport type RoleHint = z.infer<typeof RoleHintSchema>;\n\n\n/** One documentable file: where it lives, its language and its size. */\nexport const FileFactSchema = z.object({\n  path    : z.string().min(1),\n  language: z.string().min(1),\n  bytes   : z.number().int().nonnegative(),\n});\nexport type FileFact = z.infer<typeof FileFactSchema>;\n\n\nexport const LanguageCountSchema = z.object({\n  language: z.string().min(1),\n  count   : z.number().int().positive(),\n});\nexport type LanguageCount = z.infer<typeof LanguageCountSchema>;\n\n\n/** What any adapter can state about a unit, whatever the language. */\nexport const BaseFactsSchema = z.object({\n  files       : z.array(FileFactSchema),\n  testFiles   : z.array(FileFactSchema),\n  ignoredFiles: z.array(FileFactSchema),\n  languages   : z.array(LanguageCountSchema),\n  roleHint    : RoleHintSchema.nullable(),\n});\nexport type BaseFacts = z.infer<typeof BaseFactsSchema>;\n\n\nexport const SymbolKindSchema = z.enum([\n  \"class\",\n  \"const\",\n  \"enum\",\n  \"function\",\n  \"interface\",\n  \"method\",\n  \"type\",\n  \"other\",\n]);\nexport type SymbolKind = z.infer<typeof SymbolKindSchema>;\n\n\n/** One declaration a language-aware adapter recognised. */\nexport const SymbolFactSchema = z.object({\n  name     : z.string().min(1),\n  kind     : SymbolKindSchema,\n  file     : z.string().min(1),\n  signature: z.string().optional(),\n  exported : z.boolean(),\n  line     : z.number().int().positive().optional(),\n});\nexport type SymbolFact = z.infer<typeof SymbolFactSchema>;\n\n\nexport const SymbolFactsSchema = z.object({\n  symbols: z.array(SymbolFactSchema),\n});\nexport type SymbolFacts = z.infer<typeof SymbolFactsSchema>;\n\n\n/** One HTTP route a framework-aware adapter recognised. */\nexport const RouteFactSchema = z.object({\n  method : z.string().min(1),\n  path   : z.string().min(1),\n  handler: z.string().optional(),\n});\nexport type RouteFact = z.infer<typeof RouteFactSchema>;\n\n\n/** What a framework-aware adapter adds on top of the base facts. */\nexport const FrameworkFactsSchema = z.object({\n  name        : z.string().min(1),\n  role        : z.string().optional(),\n  routes      : z.array(RouteFactSchema),\n  dependencies: z.array(z.string()),\n});\nexport type FrameworkFacts = z.infer<typeof FrameworkFactsSchema>;\n\n\n/** Everything known about a unit; `producedBy` names the adapters that contributed. */\nexport const FactsSchema = z.object({\n  base      : BaseFactsSchema,\n  symbols   : SymbolFactsSchema.optional(),\n  framework : FrameworkFactsSchema.optional(),\n  producedBy: z.array(z.string().min(1)).min(1),\n});\nexport type Facts = z.infer<typeof FactsSchema>;\n\n\n/** A documentable chunk of a project: the thing one page of documentation describes. */\nexport const UnitSchema = z.object({\n  id       : z.string().min(1),\n  projectId: z.string().min(1),\n  kind     : UnitKindSchema,\n  name     : z.string().min(1),\n  path     : z.string().min(1),\n  facts    : FactsSchema,\n  hash     : z.string().min(1),\n  summary  : z.string().optional(),\n});\nexport type Unit = z.infer<typeof UnitSchema>;\n\n\nexport const RelationKindSchema = z.enum([\n  \"imports\",\n  \"calls\",\n  \"extends\",\n  \"implements\",\n  \"injects\",\n  \"exposes\",\n  \"references\",\n  \"contains\",\n]);\nexport type RelationKind = z.infer<typeof RelationKindSchema>;\n\n\n/** A directed edge between two units, by unit id. */\nexport const RelationSchema = z.object({\n  from  : z.string().min(1),\n  to    : z.string().min(1),\n  kind  : RelationKindSchema,\n  weight: z.number().optional(),\n});\nexport type Relation = z.infer<typeof RelationSchema>;\n","import { z } from \"zod\";\nimport { WorkspaceSchema } from \"./workspace.js\";\nimport { RelationSchema, UnitSchema } from \"./unit.js\";\n\n/** Bumped by hand when the manifest shape changes. */\nexport const MANIFEST_VERSION = \"1\";\n\n\n/** A whole scan, serialised. `generatedAt` is its only volatile field. */\nexport const ManifestSchema = z.object({\n  version    : z.string().min(1),\n  generatedAt: z.string().min(1),\n  workspace  : WorkspaceSchema,\n  units      : z.array(UnitSchema).default([]),\n  relations  : z.array(RelationSchema).default([]),\n});\nexport type Manifest = z.infer<typeof ManifestSchema>;\n","import { z } from \"zod\";\n\n/** One prompt on its way to a provider, in terms no provider owns. */\nexport const CompletionRequestSchema = z.object({\n  system     : z.string().optional(),\n  prompt     : z.string().min(1),\n  model      : z.string().optional(),\n  maxTokens  : z.number().int().positive().optional(),\n  temperature: z.number().min(0).max(2).optional(),\n  metadata   : z.record(z.string(), z.unknown()).default({}),\n});\nexport type CompletionRequest = z.infer<typeof CompletionRequestSchema>;\n\n\n/** Token counts a provider reports back, when it reports them at all. */\nexport const CompletionUsageSchema = z.object({\n  inputTokens    : z.number().int().nonnegative(),\n  outputTokens   : z.number().int().nonnegative(),\n  cacheReadTokens: z.number().int().nonnegative().optional(),\n});\nexport type CompletionUsage = z.infer<typeof CompletionUsageSchema>;\n\n\n/** The prose a provider wrote, plus whatever it can say about what it cost. */\nexport const CompletionResultSchema = z.object({\n  text   : z.string(),\n  model  : z.string(),\n  usage  : CompletionUsageSchema.optional(),\n  costUsd: z.number().nonnegative().optional(),\n  raw    : z.unknown().optional(),\n});\nexport type CompletionResult = z.infer<typeof CompletionResultSchema>;\n\n\n/** Writes prose from a prompt. `available` is what provider auto-detection probes. */\nexport interface Provider {\n  readonly name                       : string;\n  available()                         : Promise<boolean>;\n  complete(request: CompletionRequest): Promise<CompletionResult>;\n}\n","import path from \"node:path\";\n\n/** Rewrites a native path with posix separators, so output matches on every OS. */\nexport const toPosix = (value: string): string => value.split(path.sep).join(\"/\");\n\n\n/** Posix path from one location to another, \".\" when they are the same. */\nexport const relativePosix = (from: string, target: string): string => {\n  const relative = toPosix(path.relative(from, target));\n  return relative === \"\" ? \".\" : relative;\n};\n\n\n/** Joins two posix fragments, tolerating \".\" or \"\" on either side. */\nexport const joinPosix = (base: string, segment: string): string => {\n  if (base === \".\" || base === \"\") {\n    return segment;\n  }\n\n  if (segment === \".\" || segment === \"\") {\n    return base;\n  }\n  \n  return `${base}/${segment}`;\n};\n","\n/** Total order over strings, so a sort never depends on the machine's locale. */\nexport const compareStrings = (a: string, b: string): number => {\n  if (a < b) return -1;\n  if (a > b) return 1;\n\n  return 0;\n};\n\n/** Sorts a copy by a string key, leaving the input untouched. */\nexport const sortBy = <T>(values: readonly T[], key: (value: T) => string): T[] => {\n  return [...values].sort((a, b) => compareStrings(key(a), key(b)));\n}\n"]}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@glossic/schema",
+  "version": "0.1.0",
+  "description": "Zod schemas and inferred types shared across glossic",
+  "keywords": [
+    "documentation",
+    "docs",
+    "docs-as-code",
+    "glossic",
+    "schema",
+    "zod",
+    "types"
+  ],
+  "license": "MIT",
+  "author": "Rody Huancas",
+  "homepage": "https://github.com/rody-huancas/glosik#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rody-huancas/glosik.git",
+    "directory": "packages/schema"
+  },
+  "bugs": {
+    "url": "https://github.com/rody-huancas/glosik/issues"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "zod": "^4.1.5"
+  }
+}