@pithyjs/codex 0.1.0-beta.0

package/dist/readme-sync-cli.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * @codex
+ * {
+ *   "id": "pithy.codex.extraction.readme-sync-cli",
+ *   "title": "README Sync CLI",
+ *   "category": "plugin"
+ * }
+ *
+ * CLI for syncing README files with codex extraction data.
+ *
+ * Usage:
+ *   pnpm --filter @pithyjs/codex readme-sync [-- options]
+ *
+ * Options:
+ *   --root <path>       Project root directory (default: cwd)
+ *   --dry-run           Report changes without writing files
+ *   --verbose           Show detailed progress
+ */
+import { resolve } from 'node:path';
+import fs from 'node:fs/promises';
+import { syncAllReadmes } from './extraction/readme-sync.js';
+import { runExtractionPipeline } from './extraction/pipeline.js';
+function parseArgs(args) {
+    const options = {
+        root: process.cwd(),
+        dryRun: false,
+        verbose: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        // Handle --root=value syntax
+        if (arg.startsWith('--root=')) {
+            options.root = arg.slice('--root='.length);
+            continue;
+        }
+        switch (arg) {
+            case '--root': {
+                const next = args[i + 1];
+                if (!next || next.startsWith('-')) {
+                    console.error('Error: --root option requires a path argument.');
+                    process.exit(1);
+                }
+                options.root = next;
+                i++;
+                break;
+            }
+            case '--dry-run':
+                options.dryRun = true;
+                break;
+            case '--verbose':
+            case '-v':
+                options.verbose = true;
+                break;
+            case '--help':
+            case '-h':
+                printHelp();
+                process.exit(0);
+                break; // safety: unreachable but prevents fallthrough if exit is refactored
+            default:
+                if (arg.startsWith('-')) {
+                    console.warn(`Warning: unknown option "${arg}" (ignored)`);
+                }
+        }
+    }
+    return options;
+}
+function printHelp() {
+    console.log(`
+Codex README Sync
+
+Syncs README files by replacing <!-- @codex:auto --> markers with
+generated content from the extraction pipeline.
+
+Usage:
+  pithy-codex-readme-sync [options]
+  pnpm --filter @pithyjs/codex readme-sync [-- options]
+
+Options:
+  --root <path>       Project root directory (default: current directory)
+  --dry-run           Report changes without writing files
+  --verbose, -v       Show detailed progress
+  --help, -h          Show this help message
+
+Marker Syntax:
+  <!-- @codex:auto install="@pithyjs/pkg" -->...<!-- @codex:end -->
+  <!-- @codex:auto api="pithy.pkg.*" format="table" -->...<!-- @codex:end -->
+  <!-- @codex:auto examples="pithy.pkg.*" limit="3" -->...<!-- @codex:end -->
+  <!-- @codex:auto testing="pithy.pkg.*" -->...<!-- @codex:end -->
+
+Examples:
+  # Sync READMEs from project root
+  pithy-codex-readme-sync --root ../..
+
+  # Preview changes without writing
+  pithy-codex-readme-sync --root ../.. --dry-run --verbose
+`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const options = parseArgs(args);
+    options.root = resolve(options.root);
+    // Verify root exists
+    try {
+        const stat = await fs.stat(options.root);
+        if (!stat.isDirectory()) {
+            console.error(`Error: "${options.root}" is not a directory`);
+            process.exit(1);
+        }
+    }
+    catch {
+        console.error(`Error: Root directory "${options.root}" does not exist`);
+        process.exit(1);
+    }
+    if (options.verbose) {
+        console.log('README Sync');
+        console.log(`  Root: ${options.root}`);
+        console.log(`  Mode: ${options.dryRun ? 'dry-run' : 'write'}`);
+        console.log('');
+    }
+    // Always run extraction pipeline — it's the only reliable source of EnrichedComponent data
+    if (options.verbose)
+        console.log('Running extraction pipeline...');
+    const extractionResult = await runExtractionPipeline({
+        root: options.root,
+        analyzeTests: true,
+        linkReadmes: true,
+        extractRunnableExamples: true,
+    });
+    if (options.verbose) {
+        console.log(`  Found ${extractionResult.components.length} components`);
+        console.log('');
+    }
+    // Sync READMEs
+    if (options.verbose)
+        console.log('Syncing README files...');
+    const results = await syncAllReadmes(extractionResult, {
+        root: options.root,
+        dryRun: options.dryRun,
+        verbose: options.verbose,
+    });
+    // Summary
+    const changed = results.filter(r => r.changed);
+    const totalMarkers = results.reduce((sum, r) => sum + r.markersProcessed, 0);
+    const totalUpdated = results.reduce((sum, r) => sum + r.markersUpdated, 0);
+    const allWarnings = results.flatMap(r => r.warnings);
+    console.log('');
+    console.log(`README Sync complete:`);
+    console.log(`  Files scanned: ${results.length}`);
+    console.log(`  Files changed: ${changed.length}`);
+    console.log(`  Markers processed: ${totalMarkers}`);
+    console.log(`  Markers updated: ${totalUpdated}`);
+    if (allWarnings.length > 0) {
+        console.log(`  Warnings: ${allWarnings.length}`);
+        for (const w of allWarnings) {
+            console.log(`    - ${w}`);
+        }
+    }
+    if (options.dryRun && changed.length > 0) {
+        console.log('');
+        console.log('(dry-run mode — no files were written)');
+    }
+}
+main().catch(err => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

package/dist/review.d.ts

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

package/dist/review.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * @codex
+ * {
+ *   "id": "pithy.codex.review",
+ *   "title": "Entry Reviewer",
+ *   "category": "feature"
+ * }
+ *
+ * Generates review.md from pending codex entries using LLM.
+ */
+import fs from 'node:fs/promises';
+import { join, dirname, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+async function loadIndex(root) {
+    try {
+        const raw = await fs.readFile(join(root, 'codex.index.json'), 'utf8');
+        const j = JSON.parse(raw);
+        return (j.byId || {});
+    }
+    catch {
+        return {};
+    }
+}
+async function main() {
+    const root = process.argv.includes('--root')
+        ? process.argv[process.argv.indexOf('--root') + 1]
+        : join(__dirname, '../../..');
+    const proposalsDir = join(root, 'codex', '.proposals');
+    const files = await fs.readdir(proposalsDir).catch(() => []);
+    const items = files.filter(f => f.endsWith('.json'));
+    // Load existing index to determine change status
+    const indexById = await loadIndex(root);
+    let md = `# Codex Proposals Review\n\n`;
+    md += `Edit this file: mark accepted items with \`[x]\` then run \`pnpm -w --filter @pithyjs/codex apply\`.\n\n`;
+    if (items.length === 0) {
+        md += `*No proposals found. All components are up to date.*\n\n`;
+    }
+    else {
+        md += `## Summary\n\n`;
+        md += `Found **${items.length}** items requiring review:\n\n`;
+        // Categorize proposals
+        const newItems = [];
+        const changedItems = [];
+        for (const f of items) {
+            const p = join(proposalsDir, f);
+            const json = JSON.parse(await fs.readFile(p, 'utf8'));
+            const existing = indexById[json.id];
+            if (!existing) {
+                newItems.push(json.id);
+            }
+            else {
+                changedItems.push(json.id);
+            }
+        }
+        if (newItems.length > 0) {
+            md += `- **${newItems.length} NEW** components: ${newItems.join(', ')}\n`;
+        }
+        if (changedItems.length > 0) {
+            md += `- **${changedItems.length} CHANGED** components: ${changedItems.join(', ')}\n`;
+        }
+        md += `\n---\n\n`;
+        md += `## Proposals\n\n`;
+        for (const f of items) {
+            const p = join(proposalsDir, f);
+            const json = JSON.parse(await fs.readFile(p, 'utf8'));
+            const existing = indexById[json.id];
+            const status = existing ? 'CHANGED' : 'NEW';
+            const statusEmoji = status === 'NEW' ? '🆕' : '🔄';
+            md += `- [ ] ${statusEmoji} **${json.id}** — *${json.title || '(no title)'}* (${status})\n`;
+            md += `  - category: \`${json.category}\`\n`;
+            md += `  - tags: \`${(json.tags || []).join(', ')}\`\n`;
+            md += `  - related: \`${(json.related || []).join(', ')}\`\n`;
+            if (json.apis && json.apis.length > 0) {
+                md += `  - apis: \`${json.apis.map((api) => api.name).join(', ')}\`\n`;
+            }
+            if (json.meta?.hash) {
+                md += `  - hash: \`${json.meta.hash.substring(0, 8)}...\`\n`;
+            }
+            md += `  - file: \`${relative(root, p)}\`\n\n`;
+            md += '```json\n' + JSON.stringify(json, null, 2) + '\n```\n\n';
+        }
+    }
+    await fs.mkdir(proposalsDir, { recursive: true });
+    const reviewPath = join(proposalsDir, 'review.md');
+    await fs.writeFile(reviewPath, md);
+    console.log(`Review file: ${relative(root, reviewPath)}`);
+}
+main().catch(e => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/scan.d.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { CodexApiAnnotation } from './annotations.js';
+export interface Candidate {
+    id: string;
+    title: string;
+    category: string;
+    tags: string[];
+    files: string[];
+    hash?: string;
+    apis?: CodexApiAnnotation[];
+}
+/**
+ * Scans source files for @codex annotations and returns discovered components/APIs.
+ * @codexApi {"parent":"pithy.codex.scan","name":"scan","stability":"stable","signature":"(root: string, files?: string[]) => Promise<Candidate[]>"}
+ */
+export declare function scan(root: string, files?: string[]): Promise<Candidate[]>;
+/**
+ * Fold the per-file fingerprints of one `@codex` id into a single stable one.
+ *
+ * Sorts the COMPLETE list before hashing, which is what makes the result
+ * independent of scan order. Folding pairwise — `hash(sort([acc, next]))` —
+ * looks equivalent and is not: SHA-256 is not associative, so sorting at each
+ * step only commutes for two inputs. With three or more (and `pithy.doctor.rules`
+ * is declared by 22 files) a different scan order yields a different fingerprint
+ * for identical sources, which reports every entry as changed at random.
+ *
+ * @codexApi {"parent":"pithy.codex.scan","name":"combineFingerprints","stability":"internal","signature":"(fingerprints: string[]) => string"}
+ */
+export declare function combineFingerprints(fingerprints: string[]): string;

package/dist/scan.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+/**
+ * @codex
+ * {
+ *   "id": "pithy.codex.scan",
+ *   "title": "Source Scanner",
+ *   "category": "feature"
+ * }
+ *
+ * Scans source files for codex annotation candidates.
+ */
+import { createHash } from 'node:crypto';
+import { globby } from 'globby';
+import fs from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { discoverComponentsFromFile, createCanonicalFingerprint, } from './annotations.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Scans source files for @codex annotations and returns discovered components/APIs.
+ * @codexApi {"parent":"pithy.codex.scan","name":"scan","stability":"stable","signature":"(root: string, files?: string[]) => Promise<Candidate[]>"}
+ */
+export async function scan(root, files) {
+    // Pure annotation-based discovery
+    return await scanWithAnnotations(root, files);
+}
+/**
+ * Enhanced scanner that discovers components via annotations
+ * @param root - Repository root path
+ * @param files - Optional list of absolute file paths to scan (if omitted, scans all source files)
+ * @returns Array of candidates with hash and API metadata
+ */
+async function scanWithAnnotations(root, files) {
+    let sourceFiles;
+    const partial = files !== undefined && files.length > 0;
+    if (partial) {
+        // Scan only the provided files (filtered to .ts/.js/.mjs)
+        sourceFiles = files.filter(f => f.endsWith('.ts') || f.endsWith('.js') || f.endsWith('.mjs'));
+    }
+    else {
+        sourceFiles = await allSourceFiles(root);
+    }
+    // A partial scan — `sync --changed-only` — sees only the files git reports as
+    // changed. For an id declared by several files that is not enough: the
+    // fingerprint would cover only the changed declarations, and
+    // `buildEntryFromScan` replaces an entry's whole API list with whatever this
+    // scan produced, so editing one of `pithy.doctor.rules`' 22 files would both
+    // mis-fingerprint the entry and delete the other 21 files' APIs from it.
+    //
+    // So: find which ids the changed files touch, then pull in EVERY file in the
+    // repository that declares one of them before aggregating.
+    if (partial && sourceFiles.length > 0) {
+        sourceFiles = await withAllDeclarationsOf(root, sourceFiles);
+    }
+    if (process.env.NODE_ENV === 'development') {
+        console.log(`[Codex] Scanning ${sourceFiles.length} source files for annotations`);
+    }
+    const discoveredComponents = [];
+    // Process files in parallel for better performance
+    const discoveries = await Promise.all(sourceFiles.map(async (filePath) => {
+        try {
+            return await discoverComponentsFromFile(filePath);
+        }
+        catch (error) {
+            if (process.env.NODE_ENV === 'development') {
+                console.warn(`[Codex] Failed to scan file ${filePath}:`, error);
+            }
+            return [];
+        }
+    }));
+    // Flatten and merge discoveries
+    for (const fileDiscoveries of discoveries) {
+        discoveredComponents.push(...fileDiscoveries);
+    }
+    // Build candidates map with hash metadata
+    const candidatesMap = new Map();
+    /**
+     * Every per-file fingerprint contributing to each id, kept whole so the fold
+     * below can sort the COMPLETE list before hashing.
+     *
+     * Several files can declare one `@codex` id — `pithy.runtime.components` is
+     * declared by both `bindComponentsTags.ts` and `forwardedAttrs.ts`, and
+     * `pithy.doctor.rules` by 22 files. This used to do `existing.hash = hash`,
+     * so the file scanned LAST decided the fingerprint and a material change to
+     * any other was invisible to change detection: `sync` skipped the entry as
+     * unchanged and its documented digest silently drifted from the source.
+     *
+     * Folding pairwise as `hash(sort([acc, next]))` fixes two files but not three:
+     * SHA-256 is not associative, so sorting at each step cannot make the
+     * reduction commutative, and a different scan order would yield a different
+     * fingerprint for identical sources — spurious "changed" for the 22-file case.
+     * Sorting the whole list once is what actually makes it order-independent.
+     */
+    const fingerprintsById = new Map();
+    for (const component of discoveredComponents) {
+        const hash = createCanonicalFingerprint(component);
+        const existing = candidatesMap.get(component.id);
+        if (!existing) {
+            candidatesMap.set(component.id, {
+                id: component.id,
+                title: component.title,
+                category: component.category,
+                tags: [], // Will be populated from annotations or merged with glob tags
+                files: component.files,
+                hash,
+                apis: component.apis,
+            });
+            fingerprintsById.set(component.id, [hash]);
+        }
+        else {
+            // Merge files from multiple sources
+            existing.files = Array.from(new Set([...existing.files, ...component.files]));
+            // Collect every contributing fingerprint; they are folded into one after
+            // the loop. See `fingerprintsById`.
+            const fingerprints = fingerprintsById.get(component.id);
+            if (fingerprints)
+                fingerprints.push(hash);
+            // Merge APIs (deduplicate by name+signature)
+            const merged = [...(existing.apis || []), ...component.apis];
+            const seen = new Set();
+            existing.apis = merged.filter(api => {
+                const key = `${api.name}::${api.signature || ''}`;
+                if (seen.has(key))
+                    return false;
+                seen.add(key);
+                return true;
+            });
+        }
+    }
+    // Fold each id's contributing fingerprints into one, order-independently.
+    for (const [id, fingerprints] of fingerprintsById) {
+        const candidate = candidatesMap.get(id);
+        if (!candidate || fingerprints.length < 2)
+            continue;
+        candidate.hash = combineFingerprints(fingerprints);
+    }
+    if (process.env.NODE_ENV === 'development') {
+        console.log(`[Codex] Discovered ${candidatesMap.size} annotated components`);
+    }
+    return Array.from(candidatesMap.values());
+}
+// Debug run: node dist/scan.js
+if (process.argv[1]?.endsWith('scan.js')) {
+    const repoRoot = join(__dirname, '../../..');
+    scan(repoRoot).then(cs => console.log(JSON.stringify(cs, null, 2)));
+}
+/**
+ * Fold the per-file fingerprints of one `@codex` id into a single stable one.
+ *
+ * Sorts the COMPLETE list before hashing, which is what makes the result
+ * independent of scan order. Folding pairwise — `hash(sort([acc, next]))` —
+ * looks equivalent and is not: SHA-256 is not associative, so sorting at each
+ * step only commutes for two inputs. With three or more (and `pithy.doctor.rules`
+ * is declared by 22 files) a different scan order yields a different fingerprint
+ * for identical sources, which reports every entry as changed at random.
+ *
+ * @codexApi {"parent":"pithy.codex.scan","name":"combineFingerprints","stability":"internal","signature":"(fingerprints: string[]) => string"}
+ */
+export function combineFingerprints(fingerprints) {
+    return createHash('sha256')
+        .update([...fingerprints].sort().join(':'), 'utf8')
+        .digest('hex');
+}
+/** Every source file the scanner considers, for a full scan. */
+async function allSourceFiles(root) {
+    const sourceGlobs = [
+        'packages/*/src/**/*.ts',
+        'packages/*/src/**/*.js',
+        'packages/*/src/**/*.mjs',
+        'apps/*/src/**/*.ts',
+        'apps/*/src/**/*.js',
+        'apps/*/src/**/*.mjs',
+        'src/**/*.ts',
+        'src/**/*.js',
+        'src/**/*.mjs',
+    ];
+    return await globby(sourceGlobs, {
+        cwd: root,
+        absolute: true,
+        gitignore: true,
+    });
+}
+/**
+ * Widen a partial file set to include every other file declaring the same
+ * component ids, so a multi-file id is aggregated from all of its parts.
+ *
+ * Ids are read from the changed files first, then matched against the rest of
+ * the repository by a plain substring test on the id — cheap, and the id is a
+ * literal inside the annotation JSON, so anything declaring it contains it.
+ */
+async function withAllDeclarationsOf(root, changed) {
+    const ids = new Set();
+    for (const file of changed) {
+        try {
+            for (const c of await discoverComponentsFromFile(file))
+                ids.add(c.id);
+        }
+        catch {
+            // Unreadable or unparseable: the main scan below reports it.
+        }
+    }
+    if (ids.size === 0)
+        return changed;
+    const result = new Set(changed);
+    const candidates = (await allSourceFiles(root)).filter(f => !result.has(f));
+    await Promise.all(candidates.map(async (file) => {
+        try {
+            const content = await fs.readFile(file, 'utf8');
+            for (const id of ids) {
+                if (content.includes(id)) {
+                    result.add(file);
+                    return;
+                }
+            }
+        }
+        catch {
+            /* ignore unreadable files */
+        }
+    }));
+    return [...result];
+}

package/dist/schema.d.ts

@@ -0,0 +1,169 @@
+/**
+ * @codex
+ * {
+ *   "id": "pithy.codex.schema",
+ *   "title": "Entry Schema",
+ *   "category": "feature"
+ * }
+ *
+ * Zod validation schemas for codex entries.
+ */
+import { z } from 'zod';
+/** Zod schema for an API signature entry with name, stability, and optional signature.
+ * @codexApi {"parent":"pithy.codex.schema","name":"ApiSig","stability":"stable","signature":"z.ZodObject<{ name: string; stability: string; signature?: string }>"} */
+export declare const ApiSig: z.ZodObject<{
+    name: z.ZodString;
+    stability: z.ZodDefault<z.ZodEnum<["internal", "experimental", "stable", "deprecated"]>>;
+    signature: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    stability: "internal" | "experimental" | "stable" | "deprecated";
+    signature?: string | undefined;
+}, {
+    name: string;
+    stability?: "internal" | "experimental" | "stable" | "deprecated" | undefined;
+    signature?: string | undefined;
+}>;
+/** Zod schema defining the full structure of a codex entry.
+ * @codexApi {"parent":"pithy.codex.schema","name":"codexSchema","stability":"stable","signature":"z.ZodObject<CodexEntry>"} */
+export declare const codexSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    updated: z.ZodString;
+    public: z.ZodDefault<z.ZodBoolean>;
+    status: z.ZodDefault<z.ZodEnum<["draft", "experimental", "stable", "deprecated"]>>;
+    version: z.ZodDefault<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    related: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    dependsOn: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    apis: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        stability: z.ZodDefault<z.ZodEnum<["internal", "experimental", "stable", "deprecated"]>>;
+        signature: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        stability: "internal" | "experimental" | "stable" | "deprecated";
+        signature?: string | undefined;
+    }, {
+        name: string;
+        stability?: "internal" | "experimental" | "stable" | "deprecated" | undefined;
+        signature?: string | undefined;
+    }>, "many">>;
+    rids: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        critical: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        critical: boolean;
+        id: string;
+        text: string;
+    }, {
+        id: string;
+        text: string;
+        critical?: boolean | undefined;
+    }>, "many">>;
+    acceptance: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    tests_expected: z.ZodDefault<z.ZodObject<{
+        unit: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        integration: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        e2e: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        property: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        unit: string[];
+        integration: string[];
+        e2e: string[];
+        property: string[];
+        contract: string[];
+    }, {
+        unit?: string[] | undefined;
+        integration?: string[] | undefined;
+        e2e?: string[] | undefined;
+        property?: string[] | undefined;
+        contract?: string[] | undefined;
+    }>>;
+    summary: z.ZodOptional<z.ZodString>;
+    bodyPath: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodObject<{
+        hash: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        hash?: string | undefined;
+    }, {
+        hash?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    category: string;
+    status: "experimental" | "stable" | "deprecated" | "draft";
+    tags: string[];
+    updated: string;
+    public: boolean;
+    version: string;
+    related: string[];
+    dependsOn: string[];
+    apis: {
+        name: string;
+        stability: "internal" | "experimental" | "stable" | "deprecated";
+        signature?: string | undefined;
+    }[];
+    rids: {
+        critical: boolean;
+        id: string;
+        text: string;
+    }[];
+    acceptance: string[];
+    tests_expected: {
+        unit: string[];
+        integration: string[];
+        e2e: string[];
+        property: string[];
+        contract: string[];
+    };
+    owner?: string | undefined;
+    summary?: string | undefined;
+    bodyPath?: string | undefined;
+    meta?: {
+        hash?: string | undefined;
+    } | undefined;
+}, {
+    id: string;
+    title: string;
+    category: string;
+    updated: string;
+    status?: "experimental" | "stable" | "deprecated" | "draft" | undefined;
+    tags?: string[] | undefined;
+    public?: boolean | undefined;
+    version?: string | undefined;
+    owner?: string | undefined;
+    related?: string[] | undefined;
+    dependsOn?: string[] | undefined;
+    apis?: {
+        name: string;
+        stability?: "internal" | "experimental" | "stable" | "deprecated" | undefined;
+        signature?: string | undefined;
+    }[] | undefined;
+    rids?: {
+        id: string;
+        text: string;
+        critical?: boolean | undefined;
+    }[] | undefined;
+    acceptance?: string[] | undefined;
+    tests_expected?: {
+        unit?: string[] | undefined;
+        integration?: string[] | undefined;
+        e2e?: string[] | undefined;
+        property?: string[] | undefined;
+        contract?: string[] | undefined;
+    } | undefined;
+    summary?: string | undefined;
+    bodyPath?: string | undefined;
+    meta?: {
+        hash?: string | undefined;
+    } | undefined;
+}>;
+/** Inferred TypeScript type from the codex schema.
+ * @codexApi {"parent":"pithy.codex.schema","name":"CodexEntry","stability":"stable","signature":"z.infer<typeof codexSchema>"} */
+export type CodexEntry = z.infer<typeof codexSchema>;