@c7-digital/scribe 0.0.1

package/lib/src/config.d.ts

@@ -0,0 +1,224 @@
+import { z } from "zod";
+import type { RunOptions } from "./cli.js";
+declare const ModuleConfigSchema: z.ZodObject<{
+    alias: z.ZodOptional<z.ZodString>;
+    templates: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    interfaces: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    alias?: string | undefined;
+    templates?: string[] | undefined;
+    interfaces?: string[] | undefined;
+}, {
+    alias?: string | undefined;
+    templates?: string[] | undefined;
+    interfaces?: string[] | undefined;
+}>;
+declare const VendorPackageConfigSchema: z.ZodObject<{
+    alias: z.ZodOptional<z.ZodString>;
+    modules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        alias: z.ZodOptional<z.ZodString>;
+        templates: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        interfaces: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        alias?: string | undefined;
+        templates?: string[] | undefined;
+        interfaces?: string[] | undefined;
+    }, {
+        alias?: string | undefined;
+        templates?: string[] | undefined;
+        interfaces?: string[] | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    alias?: string | undefined;
+    modules?: Record<string, {
+        alias?: string | undefined;
+        templates?: string[] | undefined;
+        interfaces?: string[] | undefined;
+    }> | undefined;
+}, {
+    alias?: string | undefined;
+    modules?: Record<string, {
+        alias?: string | undefined;
+        templates?: string[] | undefined;
+        interfaces?: string[] | undefined;
+    }> | undefined;
+}>;
+declare const ConfigFileSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"1.0">;
+    input: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodObject<{
+        dir: z.ZodDefault<z.ZodString>;
+        bundle: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        dir: string;
+        bundle: boolean;
+    }, {
+        dir?: string | undefined;
+        bundle?: boolean | undefined;
+    }>>;
+    main: z.ZodOptional<z.ZodObject<{
+        pattern: z.ZodOptional<z.ZodString>;
+        modules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            alias: z.ZodOptional<z.ZodString>;
+            templates: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            interfaces: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            alias?: string | undefined;
+            templates?: string[] | undefined;
+            interfaces?: string[] | undefined;
+        }, {
+            alias?: string | undefined;
+            templates?: string[] | undefined;
+            interfaces?: string[] | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        modules?: Record<string, {
+            alias?: string | undefined;
+            templates?: string[] | undefined;
+            interfaces?: string[] | undefined;
+        }> | undefined;
+        pattern?: string | undefined;
+    }, {
+        modules?: Record<string, {
+            alias?: string | undefined;
+            templates?: string[] | undefined;
+            interfaces?: string[] | undefined;
+        }> | undefined;
+        pattern?: string | undefined;
+    }>>;
+    vendor: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        alias: z.ZodOptional<z.ZodString>;
+        modules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            alias: z.ZodOptional<z.ZodString>;
+            templates: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            interfaces: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            alias?: string | undefined;
+            templates?: string[] | undefined;
+            interfaces?: string[] | undefined;
+        }, {
+            alias?: string | undefined;
+            templates?: string[] | undefined;
+            interfaces?: string[] | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        alias?: string | undefined;
+        modules?: Record<string, {
+            alias?: string | undefined;
+            templates?: string[] | undefined;
+            interfaces?: string[] | undefined;
+        }> | undefined;
+    }, {
+        alias?: string | undefined;
+        modules?: Record<string, {
+            alias?: string | undefined;
+            templates?: string[] | undefined;
+            interfaces?: string[] | undefined;
+        }> | undefined;
+    }>>>;
+    compat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        versions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            hash: z.ZodString;
+            version: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+            hash: string;
+        }, {
+            version: string;
+            hash: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        versions: {
+            version: string;
+            hash: string;
+        }[];
+    }, {
+        versions?: {
+            version: string;
+            hash: string;
+        }[] | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    schema: "1.0";
+    main?: {
+        modules?: Record<string, {
+            alias?: string | undefined;
+            templates?: string[] | undefined;
+            interfaces?: string[] | undefined;
+        }> | undefined;
+        pattern?: string | undefined;
+    } | undefined;
+    vendor?: Record<string, {
+        alias?: string | undefined;
+        modules?: Record<string, {
+            alias?: string | undefined;
+            templates?: string[] | undefined;
+            interfaces?: string[] | undefined;
+        }> | undefined;
+    }> | undefined;
+    input?: string | undefined;
+    output?: {
+        dir: string;
+        bundle: boolean;
+    } | undefined;
+    compat?: Record<string, {
+        versions: {
+            version: string;
+            hash: string;
+        }[];
+    }> | undefined;
+}, {
+    schema: "1.0";
+    main?: {
+        modules?: Record<string, {
+            alias?: string | undefined;
+            templates?: string[] | undefined;
+            interfaces?: string[] | undefined;
+        }> | undefined;
+        pattern?: string | undefined;
+    } | undefined;
+    vendor?: Record<string, {
+        alias?: string | undefined;
+        modules?: Record<string, {
+            alias?: string | undefined;
+            templates?: string[] | undefined;
+            interfaces?: string[] | undefined;
+        }> | undefined;
+    }> | undefined;
+    input?: string | undefined;
+    output?: {
+        dir?: string | undefined;
+        bundle?: boolean | undefined;
+    } | undefined;
+    compat?: Record<string, {
+        versions?: {
+            version: string;
+            hash: string;
+        }[] | undefined;
+    }> | undefined;
+}>;
+export type ConfigFile = z.infer<typeof ConfigFileSchema>;
+export type ModuleOverride = z.infer<typeof ModuleConfigSchema>;
+export type VendorOverride = z.infer<typeof VendorPackageConfigSchema>;
+export interface ResolvedConfig {
+    input: string;
+    output: {
+        dir: string;
+        bundle: boolean;
+    };
+    main: {
+        pattern?: string;
+        modules?: Record<string, ModuleOverride>;
+    };
+    vendor?: Record<string, VendorOverride>;
+    compat: Record<string, {
+        versions: Array<{
+            hash: string;
+            version: string;
+        }>;
+    }>;
+    version?: string;
+    dryRun: boolean;
+}
+export declare function loadConfig(opts: RunOptions): Promise<ResolvedConfig>;
+export {};

package/lib/src/config.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import YAML from "yaml";
+// --- Zod schemas ---
+const TemplateListSchema = z.array(z.string()).optional();
+const ModuleConfigSchema = z.object({
+    alias: z.string().optional(),
+    templates: TemplateListSchema,
+    interfaces: z.array(z.string()).optional(),
+});
+const MainConfigSchema = z.object({
+    pattern: z.string().optional(),
+    modules: z.record(z.string(), ModuleConfigSchema).optional(),
+});
+const VendorPackageConfigSchema = z.object({
+    alias: z.string().optional(),
+    modules: z.record(z.string(), ModuleConfigSchema).optional(),
+});
+const CompatVersionSchema = z.object({
+    hash: z.string(),
+    version: z.string(),
+});
+const CompatPackageSchema = z.object({
+    versions: z.array(CompatVersionSchema).default([]),
+});
+const CompatConfigSchema = z.record(z.string(), CompatPackageSchema);
+const OutputConfigSchema = z.object({
+    dir: z.string().default("dist"),
+    bundle: z.boolean().default(true),
+});
+const ConfigFileSchema = z.object({
+    schema: z.literal("1.0"),
+    input: z.string().optional(),
+    output: OutputConfigSchema.optional(),
+    main: MainConfigSchema.optional(),
+    vendor: z.record(z.string(), VendorPackageConfigSchema).optional(),
+    compat: CompatConfigSchema.optional(),
+});
+export async function loadConfig(opts) {
+    let file;
+    if (opts.config) {
+        const raw = await readFile(resolve(opts.config), "utf-8");
+        const parsed = YAML.parse(raw);
+        file = ConfigFileSchema.parse(parsed);
+    }
+    const input = opts.input ?? file?.input ?? "./codegen/js";
+    const outputDir = opts.output ?? file?.output?.dir ?? "dist";
+    const bundle = file?.output?.bundle ?? true;
+    return {
+        input: resolve(input),
+        output: { dir: resolve(outputDir), bundle },
+        main: { pattern: file?.main?.pattern, modules: file?.main?.modules },
+        vendor: file?.vendor,
+        compat: file?.compat ?? {},
+        version: opts.version ?? process.env["DAR_VERSION"],
+        dryRun: opts.dryRun ?? false,
+    };
+}

package/lib/src/discover.d.ts

@@ -0,0 +1,13 @@
+import type { ResolvedConfig } from "./config.js";
+export type PackageRole = "main" | "vendor" | "stdlib";
+export interface DiscoveredPackage {
+    /** Directory name, e.g. "domain-verification-model-0.0.8" */
+    name: string;
+    /** Absolute path to the package directory */
+    path: string;
+    /** Classified role */
+    role: PackageRole;
+    /** Version extracted from directory name, e.g. "0.0.8" */
+    detectedVersion?: string;
+}
+export declare function discoverPackages(config: ResolvedConfig): Promise<DiscoveredPackage[]>;

package/lib/src/discover.js

@@ -0,0 +1,70 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { rcompare } from "semver";
+const STDLIB_PREFIXES = ["daml-prim-", "daml-stdlib-", "ghc-stdlib-"];
+const VENDOR_PREFIXES = ["splice-"];
+function globToRegex(pattern) {
+    return new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+}
+function classifyPackage(name, mainPattern, vendorPatterns) {
+    if (STDLIB_PREFIXES.some((p) => name.startsWith(p)))
+        return "stdlib";
+    if (mainPattern) {
+        if (globToRegex(mainPattern).test(name))
+            return "main";
+    }
+    // If vendor patterns are explicitly specified, only match those
+    if (vendorPatterns && vendorPatterns.length > 0) {
+        if (vendorPatterns.some((p) => globToRegex(p).test(name)))
+            return "vendor";
+        // If it doesn't match any vendor pattern and isn't main/stdlib, still classify
+        // based on known prefixes but mark as stdlib (skip it)
+        if (VENDOR_PREFIXES.some((p) => name.startsWith(p)))
+            return "stdlib";
+        // Non-vendor, non-stdlib, non-main pattern => candidate for main
+        return mainPattern ? "stdlib" : "main";
+    }
+    if (VENDOR_PREFIXES.some((p) => name.startsWith(p)))
+        return "vendor";
+    // If no mainPattern was given, non-stdlib non-vendor packages are candidates for main
+    return mainPattern ? "vendor" : "main";
+}
+function extractVersion(name) {
+    // Match trailing version: "my-project-0.1.0" -> "0.1.0"
+    const match = name.match(/-(\d+\.\d+\.\d+(?:[.-].*)?)$/);
+    return match?.[1];
+}
+export async function discoverPackages(config) {
+    const entries = await readdir(config.input, { withFileTypes: true });
+    const dirs = entries.filter((e) => e.isDirectory() || e.isSymbolicLink());
+    const vendorPatterns = config.vendor
+        ? Object.keys(config.vendor)
+        : undefined;
+    let packages = dirs.map((entry) => ({
+        name: entry.name,
+        path: join(config.input, entry.name),
+        role: classifyPackage(entry.name, config.main.pattern, vendorPatterns),
+        detectedVersion: extractVersion(entry.name),
+    }));
+    // If multiple main packages match (e.g., model-0.0.7, model-0.0.8, model-0.0.9),
+    // select the one matching config.version, or the latest version.
+    const mainPackages = packages.filter((p) => p.role === "main");
+    if (mainPackages.length > 1) {
+        const targetVersion = config.version;
+        let selected;
+        if (targetVersion) {
+            selected = mainPackages.find((p) => p.detectedVersion === targetVersion);
+            if (!selected) {
+                const names = mainPackages.map((p) => p.name).join(", ");
+                throw new Error(`Version ${targetVersion} not found among main packages: ${names}`);
+            }
+        }
+        else {
+            // Pick the latest version (sort semver descending)
+            selected = mainPackages.sort((a, b) => rcompare(a.detectedVersion ?? "0.0.0", b.detectedVersion ?? "0.0.0"))[0];
+        }
+        // Demote non-selected main packages to stdlib (they'll be included for bundling but not exported)
+        packages = packages.map((p) => p.role === "main" && p !== selected ? { ...p, role: "stdlib" } : p);
+    }
+    return packages;
+}

package/lib/src/generate/exports.d.ts

@@ -0,0 +1,13 @@
+import type { AnalyzedPackage } from "../analyze.js";
+/**
+ * Generate import statements for all modules across all packages.
+ *
+ * For main package modules: import from the module.js file directly.
+ * For vendor packages: import from lib/index.js (package-level) and
+ * also from individual modules if they're explicitly included.
+ */
+export declare function generateImports(mainPkg: AnalyzedPackage | undefined, vendorPkgs: AnalyzedPackage[], stdlibPkgs: AnalyzedPackage[]): string;
+/**
+ * Generate named export statements for all user-facing modules.
+ */
+export declare function generateExportStatements(mainPkg: AnalyzedPackage | undefined, vendorPkgs: AnalyzedPackage[]): string;

package/lib/src/generate/exports.js

@@ -0,0 +1,65 @@
+/**
+ * Generate import statements for all modules across all packages.
+ *
+ * For main package modules: import from the module.js file directly.
+ * For vendor packages: import from lib/index.js (package-level) and
+ * also from individual modules if they're explicitly included.
+ */
+export function generateImports(mainPkg, vendorPkgs, stdlibPkgs) {
+    const lines = [];
+    lines.push("// Generated by @c7-digital/scribe");
+    lines.push("");
+    // Main package modules
+    if (mainPkg) {
+        for (const mod of mainPkg.modules) {
+            const relPath = `./${mainPkg.name}/lib/${mod.modulePath}.js`;
+            lines.push(`import * as ${mod.alias} from '${relPath}';`);
+        }
+    }
+    // Vendor packages: import both the package-level index and specific modules
+    for (const vendor of vendorPkgs) {
+        // Package-level import (gives access to packageId)
+        const pkgAlias = sanitizeAlias(vendor.name);
+        lines.push(`import * as ${pkgAlias} from './${vendor.name}/lib/index.js';`);
+        // Individual module imports
+        for (const mod of vendor.modules) {
+            const relPath = `./${vendor.name}/lib/${mod.modulePath}.js`;
+            lines.push(`import * as ${mod.alias} from '${relPath}';`);
+        }
+    }
+    // Stdlib packages: import package-level (needed for bundling, not exported)
+    for (const stdlib of stdlibPkgs) {
+        const alias = sanitizeAlias(stdlib.name);
+        lines.push(`import * as ${alias} from './${stdlib.name}/lib/index.js';`);
+    }
+    lines.push("");
+    lines.push("import * as version from './version.js';");
+    return lines.join("\n");
+}
+/**
+ * Generate named export statements for all user-facing modules.
+ */
+export function generateExportStatements(mainPkg, vendorPkgs) {
+    const lines = [];
+    // Collect all export names
+    const exportNames = [];
+    if (mainPkg) {
+        for (const mod of mainPkg.modules) {
+            exportNames.push(mod.alias);
+        }
+    }
+    for (const vendor of vendorPkgs) {
+        for (const mod of vendor.modules) {
+            exportNames.push(mod.alias);
+        }
+    }
+    if (exportNames.length > 0) {
+        lines.push(`export { ${exportNames.join(", ")} };`);
+    }
+    lines.push("export { PACKAGE_VERSION } from './version.js';");
+    return lines.join("\n");
+}
+/** Sanitize a package directory name to a valid JS identifier. */
+function sanitizeAlias(name) {
+    return name.replace(/[-. ]/g, "_");
+}

package/lib/src/generate/index.d.ts

@@ -0,0 +1,13 @@
+import type { AnalyzedPackage } from "../analyze.js";
+import type { ResolvedConfig } from "../config.js";
+export { generateImports, generateExportStatements } from "./exports.js";
+export { generateRegistry } from "./registry.js";
+export { generateTypeDefs, generateVersionTypeDef } from "./types.js";
+export interface GenerateResult {
+    mainPkg?: AnalyzedPackage;
+    vendorPkgs: AnalyzedPackage[];
+    stdlibPkgs: AnalyzedPackage[];
+    outputDir: string;
+    files: string[];
+}
+export declare function generate(packages: AnalyzedPackage[], config: ResolvedConfig): Promise<GenerateResult>;

package/lib/src/generate/index.js

@@ -0,0 +1,91 @@
+import { mkdir, writeFile, symlink, readdir, rm, copyFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { generateImports, generateExportStatements } from "./exports.js";
+import { generateRegistry } from "./registry.js";
+import { generateTypeDefs, generateVersionTypeDef } from "./types.js";
+import { bundle } from "../transform.js";
+export { generateImports, generateExportStatements } from "./exports.js";
+export { generateRegistry } from "./registry.js";
+export { generateTypeDefs, generateVersionTypeDef } from "./types.js";
+export async function generate(packages, config) {
+    const mainPkg = packages.find((p) => p.role === "main");
+    const vendorPkgs = packages.filter((p) => p.role === "vendor");
+    const stdlibPkgs = packages.filter((p) => p.role === "stdlib");
+    // Determine version for the main package
+    const version = config.version ?? mainPkg?.version ?? "0.0.0";
+    if (mainPkg) {
+        mainPkg.version = version;
+    }
+    if (config.dryRun) {
+        printSummary(mainPkg, vendorPkgs, config);
+        return { mainPkg, vendorPkgs, stdlibPkgs, outputDir: config.output.dir, files: [] };
+    }
+    // Prepare a staging directory (.scribe/) adjacent to output
+    const outputDir = config.output.dir;
+    const srcDir = resolve(outputDir, "..", ".scribe");
+    // Clean and recreate .scribe/
+    await rm(srcDir, { recursive: true, force: true });
+    await mkdir(srcDir, { recursive: true });
+    // Symlink all input packages into src/
+    const inputEntries = await readdir(config.input, { withFileTypes: true });
+    for (const entry of inputEntries) {
+        if (entry.isDirectory() || entry.isSymbolicLink()) {
+            const target = resolve(join(config.input, entry.name));
+            const link = join(srcDir, entry.name);
+            await symlink(target, link);
+        }
+    }
+    // Generate version.js
+    await writeFile(join(srcDir, "version.js"), `export const PACKAGE_VERSION = '${version}';\n`);
+    // Generate index.js
+    const indexJs = [
+        generateImports(mainPkg, vendorPkgs, stdlibPkgs),
+        "",
+        generateExportStatements(mainPkg, vendorPkgs),
+        generateRegistry(mainPkg, vendorPkgs, config),
+    ].join("\n");
+    await writeFile(join(srcDir, "index.js"), indexJs);
+    // Generate index.d.ts
+    const indexDts = generateTypeDefs(mainPkg, vendorPkgs);
+    await writeFile(join(srcDir, "index.d.ts"), indexDts);
+    // Generate version.d.ts
+    await writeFile(join(srcDir, "version.d.ts"), generateVersionTypeDef());
+    const files = [".scribe/index.js", ".scribe/index.d.ts", ".scribe/version.js", ".scribe/version.d.ts"];
+    // Bundle if configured
+    if (config.output.bundle) {
+        console.log("Bundling with Vite...");
+        await bundle(srcDir, outputDir);
+        // Copy type declarations to output dir
+        await copyFile(join(srcDir, "index.d.ts"), join(outputDir, "index.d.ts"));
+        await copyFile(join(srcDir, "version.d.ts"), join(outputDir, "version.d.ts"));
+        files.push("dist/codegen.js", "dist/index.js", "dist/version.js", "dist/index.d.ts", "dist/version.d.ts");
+    }
+    printSummary(mainPkg, vendorPkgs, config);
+    return { mainPkg, vendorPkgs, stdlibPkgs, outputDir, files };
+}
+function printSummary(mainPkg, vendorPkgs, config) {
+    console.log("");
+    console.log("Scribe complete:");
+    if (mainPkg) {
+        const templateCount = mainPkg.modules.reduce((acc, m) => acc + m.members.filter((t) => t.kind === "template").length, 0);
+        const interfaceCount = mainPkg.modules.reduce((acc, m) => acc + m.members.filter((t) => t.kind === "interface").length, 0);
+        const parts = [`${mainPkg.modules.length} modules`, `${templateCount} templates`];
+        if (interfaceCount > 0)
+            parts.push(`${interfaceCount} interfaces`);
+        console.log(`  Main: ${mainPkg.name} (${parts.join(", ")})`);
+    }
+    for (const vendor of vendorPkgs) {
+        const templateCount = vendor.modules.reduce((acc, m) => acc + m.members.filter((t) => t.kind === "template").length, 0);
+        const interfaceCount = vendor.modules.reduce((acc, m) => acc + m.members.filter((t) => t.kind === "interface").length, 0);
+        const parts = [`${vendor.modules.length} modules`];
+        if (templateCount > 0)
+            parts.push(`${templateCount} templates`);
+        if (interfaceCount > 0)
+            parts.push(`${interfaceCount} interfaces`);
+        console.log(`  Vendor: ${vendor.name} (${parts.join(", ")})`);
+    }
+    if (config.dryRun) {
+        console.log("  (dry run -- no files written)");
+    }
+    console.log("");
+}

package/lib/src/generate/registry.d.ts

@@ -0,0 +1,9 @@
+import type { AnalyzedPackage } from "../analyze.js";
+import type { ResolvedConfig } from "../config.js";
+/**
+ * Generate the versionedRegistry function and all registration calls.
+ *
+ * The generated function conforms to the VersionedRegistry type from
+ * @c7-digital/ledger (structurally, without importing it).
+ */
+export declare function generateRegistry(mainPkg: AnalyzedPackage | undefined, vendorPkgs: AnalyzedPackage[], config: ResolvedConfig): string;