@gradial/aci 0.1.41 → 0.1.43

package/dist/cli/materialize-template.d.mts

@@ -0,0 +1,19 @@
+/**
+ * Assemble a complete site tree from the SDK templates.
+ *
+ * @param {object} opts
+ * @param {string} opts.templatesDir  absolute path to the templates root
+ * @param {string} opts.framework     'nextjs' | 'astro'
+ * @param {string} opts.destDir       absolute destination (created if missing)
+ * @param {{siteName: string, version: string, aciVersion: string}} opts.vars
+ */
+export function materializeTemplate({ templatesDir, framework, destDir, vars }: {
+    templatesDir: string;
+    framework: string;
+    destDir: string;
+    vars: {
+        siteName: string;
+        version: string;
+        aciVersion: string;
+    };
+}): void;

package/dist/cli/materialize-template.mjs

@@ -0,0 +1,128 @@
+// TS reference engine for scaffolding a site from the SDK templates.
+//
+// `scripts/generate-starters.ts` (repo codegen for starters/*) calls
+// materializeTemplate, then applies the starter-content overlay as an
+// explicit stage on top. Customer scaffolding (`aci init`) is the Go CLI
+// (internal/transport/cli/cmd/init.go), which implements the same engine
+// semantics; scripts/test-starter-dev.mjs asserts the two engines produce
+// byte-identical output so they can never drift.
+// Spec: specs/features/starter-fresh-clone-dx (D-1).
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const EXCLUDE_PATTERNS = [
+    /node_modules/,
+    /\.DS_Store$/,
+    /package-lock\.json$/,
+    /\.git$/,
+    /storybook-static/,
+    /starter-content/,
+];
+const COMMON_DIRS = ['.aci', '.agents', '.content', 'eslint-rules'];
+const COMMON_ROOT_FILES = ['.nvmrc'];
+// Per-framework values rendered into shared templates (e.g. README.md.tmpl).
+// Derived here so `aci init` and `generate-starters` can never disagree.
+const FRAMEWORK_VARS = {
+    nextjs: { devUrl: 'http://localhost:3000', frameworkName: 'Next.js' },
+    astro: { devUrl: 'http://localhost:4321', frameworkName: 'Astro' },
+};
+// Exclusions match paths RELATIVE to the copy root: the SDK itself is often
+// installed under a node_modules/ directory (npm install, the npx cache), so
+// matching absolute paths would exclude every template file.
+function shouldExclude(relPath) {
+    return EXCLUDE_PATTERNS.some((pattern) => pattern.test(relPath));
+}
+function copyDirSync(src, dest, root = src) {
+    if (!fs.existsSync(src))
+        return;
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (shouldExclude(path.relative(root, srcPath)))
+            continue;
+        if (entry.isDirectory()) {
+            fs.mkdirSync(destPath, { recursive: true });
+            copyDirSync(srcPath, destPath, root);
+        }
+        else {
+            fs.mkdirSync(path.dirname(destPath), { recursive: true });
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+function renderTmplFiles(dir, vars, root = dir) {
+    if (!fs.existsSync(dir))
+        return;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (shouldExclude(path.relative(root, fullPath)))
+            continue;
+        if (entry.isDirectory()) {
+            renderTmplFiles(fullPath, vars, root);
+        }
+        else if (entry.name.endsWith('.tmpl')) {
+            let content = fs.readFileSync(fullPath, 'utf8');
+            for (const [key, value] of Object.entries(vars)) {
+                // Function replacement so `$` sequences in values (site names are
+                // user-controlled) are inserted literally, not as $-patterns.
+                content = content.replaceAll(`{{${key}}}`, () => value);
+            }
+            fs.writeFileSync(fullPath.replace(/\.tmpl$/, ''), content);
+            fs.unlinkSync(fullPath);
+        }
+    }
+}
+/**
+ * Assemble a complete site tree from the SDK templates.
+ *
+ * @param {object} opts
+ * @param {string} opts.templatesDir  absolute path to the templates root
+ * @param {string} opts.framework     'nextjs' | 'astro'
+ * @param {string} opts.destDir       absolute destination (created if missing)
+ * @param {{siteName: string, version: string, aciVersion: string}} opts.vars
+ */
+export function materializeTemplate({ templatesDir, framework, destDir, vars }) {
+    const commonDir = path.join(templatesDir, 'common');
+    const templateDir = path.join(templatesDir, framework, 'template');
+    if (!fs.existsSync(templateDir)) {
+        throw new Error(`unknown framework template: ${templateDir}`);
+    }
+    for (const key of ['siteName', 'version', 'aciVersion']) {
+        if (!vars[key])
+            throw new Error(`materializeTemplate: vars.${key} is required`);
+    }
+    fs.mkdirSync(destDir, { recursive: true });
+    for (const dir of COMMON_DIRS) {
+        copyDirSync(path.join(commonDir, dir), path.join(destDir, dir));
+    }
+    for (const file of COMMON_ROOT_FILES) {
+        const src = path.join(commonDir, file);
+        if (fs.existsSync(src))
+            fs.copyFileSync(src, path.join(destDir, file));
+    }
+    copyDirSync(path.join(commonDir, 'public', 'assets'), path.join(destDir, 'public', 'assets'));
+    const readmeTmpl = path.join(commonDir, 'README.md.tmpl');
+    if (fs.existsSync(readmeTmpl)) {
+        fs.copyFileSync(readmeTmpl, path.join(destDir, 'README.md.tmpl'));
+    }
+    copyDirSync(templateDir, destDir);
+    // Shared design-system sources overwrite any framework-template copies so
+    // design tokens can only come from templates/common. Contract sources are
+    // NOT copied here: a scaffold ships only the empty contracts barrel from the
+    // framework template; populated contracts arrive via the starter-content
+    // overlay stage (generate-starters.ts / `aci init --with-starter-content`).
+    copyDirSync(path.join(commonDir, 'design-system', 'tokens'), path.join(destDir, 'src', 'design-system', 'tokens'));
+    const stylesSrc = path.join(commonDir, 'design-system', 'styles.css');
+    if (fs.existsSync(stylesSrc)) {
+        fs.mkdirSync(path.join(destDir, 'src', 'design-system'), { recursive: true });
+        fs.copyFileSync(stylesSrc, path.join(destDir, 'src', 'design-system', 'styles.css'));
+    }
+    // npm pack drops `.gitignore` files from the published templates, so the
+    // framework templates ship `gitignore` and it is renamed on materialize.
+    const gitignore = path.join(destDir, 'gitignore');
+    if (fs.existsSync(gitignore)) {
+        fs.renameSync(gitignore, path.join(destDir, '.gitignore'));
+    }
+    renderTmplFiles(destDir, { ...FRAMEWORK_VARS[framework], ...vars });
+}

package/dist/cli/validate-content.d.mts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+export function validateContent(options: any): Promise<{
+    warnings?: any[] | undefined;
+    success: boolean;
+    pagesValidated: number;
+    blocksValidated: number;
+    errors: ({
+        page: string;
+        message: string;
+        fragment?: undefined;
+        component?: undefined;
+        path?: undefined;
+    } | {
+        fragment: string;
+        message: string;
+        page?: undefined;
+        component?: undefined;
+        path?: undefined;
+    } | {
+        fragment: string;
+        component: any;
+        message: string;
+        page?: undefined;
+        path?: undefined;
+    } | {
+        fragment: string;
+        component: any;
+        path: any;
+        message: any;
+        page?: undefined;
+    })[];
+}>;

package/dist/cli/validate-content.mjs

@@ -0,0 +1,464 @@
+#!/usr/bin/env node
+/**
+ * validate-content — validate authored page content against compiled JSON schemas.
+ *
+ * Usage:
+ *   node validate-content.mjs \
+ *     --registry <path-to-compiled-registry-dir> \
+ *     --compiled <path-to-compiled-content-dir>
+ *
+ * Prerequisites:
+ *   1. Run compile-registry to generate registry.json + schemas/*.schema.json
+ *   2. Run content build to generate compiled routes + fragments
+ *
+ * Validates every block in the COMPILED output against JSON schemas.
+ * This validates the build result — after DAM resolution, fragment inlining, etc.
+ * Fails with exit code 1 if any published page has validation errors.
+ * Warns (but does not fail) for draft pages.
+ *
+ * Uses the JSON schemas generated by compile-registry — portable, no React/CSS
+ * imports needed, same schemas usable by Go backend or other tools.
+ */
+import { realpathSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+if (isMainModule()) {
+    const args = parseArgs(process.argv.slice(2));
+    try {
+        const result = await validateContent(args);
+        console.log(JSON.stringify(result, null, 2));
+        if (!result.success)
+            process.exitCode = 1;
+    }
+    catch (error) {
+        console.error(JSON.stringify({
+            success: false,
+            errors: [{ message: String(error?.message ?? error) }],
+        }, null, 2));
+        process.exitCode = 1;
+    }
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function validateContent(options) {
+    if (!options.registry)
+        throw new Error('missing --registry (path to compiled registry directory)');
+    if (!options.compiled)
+        throw new Error('missing --compiled (path to compiled content output directory)');
+    const registryDir = path.resolve(options.registry);
+    const contentRoot = path.resolve(options.compiled);
+    // Load compiled registry
+    const registryPath = path.join(registryDir, 'registry.json');
+    const registryRaw = await readFile(registryPath, 'utf-8');
+    const registry = JSON.parse(registryRaw);
+    // Build schema map: component name → JSON Schema object
+    const schemaMap = new Map();
+    const knownComponents = new Set();
+    const componentMap = new Map();
+    for (const component of registry.components) {
+        knownComponents.add(component.name);
+        componentMap.set(component.name, component);
+        if (component.props) {
+            const schemaPath = path.join(registryDir, component.props);
+            const schemaRaw = await readFile(schemaPath, 'utf-8');
+            schemaMap.set(component.name, JSON.parse(schemaRaw));
+        }
+    }
+    // Find all compiled route files
+    const routesDir = path.join(contentRoot, 'routes');
+    const pageFiles = await findJsonFiles(routesDir);
+    const errors = [];
+    const warnings = [];
+    let pagesValidated = 0;
+    let blocksValidated = 0;
+    for (const pageFile of pageFiles) {
+        const relativePath = path.relative(contentRoot, pageFile);
+        let pageData;
+        try {
+            const raw = await readFile(pageFile, 'utf-8');
+            pageData = JSON.parse(raw);
+        }
+        catch (err) {
+            errors.push({ page: relativePath, message: `failed to parse JSON: ${err.message}` });
+            continue;
+        }
+        pagesValidated++;
+        const isPublished = pageData.status === 'published';
+        const collector = isPublished ? errors : warnings;
+        const blocks = collectBlocks(pageData);
+        for (const block of blocks) {
+            blocksValidated++;
+            if (!block || typeof block !== 'object') {
+                collector.push({
+                    page: relativePath,
+                    blockId: '<unknown>',
+                    message: 'page region entry must be a component block',
+                });
+                continue;
+            }
+            if (block.$type !== 'component') {
+                collector.push({
+                    page: relativePath,
+                    blockId: block.id ?? '<unknown>',
+                    path: '$type',
+                    message: 'block "$type" must be "component"',
+                });
+            }
+            if (!block.component) {
+                collector.push({
+                    page: relativePath,
+                    blockId: block.id ?? '<unknown>',
+                    message: 'block is missing "component" field',
+                });
+                continue;
+            }
+            // Check component exists in registry
+            if (!knownComponents.has(block.component)) {
+                collector.push({
+                    page: relativePath,
+                    blockId: block.id ?? '<unknown>',
+                    component: block.component,
+                    message: `unknown component: "${block.component}"`,
+                });
+                continue;
+            }
+            // Validate props against JSON Schema
+            const schema = schemaMap.get(block.component);
+            if (!schema)
+                continue; // no schema file — component registered but no schema to check
+            const props = block.props ?? {};
+            const issues = validateJsonSchema(props, schema, 'props');
+            for (const issue of issues) {
+                collector.push({
+                    page: relativePath,
+                    blockId: block.id ?? '<unknown>',
+                    component: block.component,
+                    path: issue.path,
+                    message: issue.message,
+                });
+            }
+            const nestedIssues = validateNestedSlots(block, componentMap, schemaMap);
+            for (const issue of nestedIssues) {
+                collector.push({
+                    page: relativePath,
+                    blockId: block.id ?? '<unknown>',
+                    component: block.component,
+                    ...issue,
+                });
+            }
+        }
+    }
+    // Also validate fragments
+    const fragmentsDir = path.join(contentRoot, 'fragments');
+    const fragmentFiles = await findJsonFiles(fragmentsDir);
+    for (const fragmentFile of fragmentFiles) {
+        const relativePath = path.relative(contentRoot, fragmentFile);
+        let fragmentData;
+        try {
+            const raw = await readFile(fragmentFile, 'utf-8');
+            fragmentData = JSON.parse(raw);
+        }
+        catch (err) {
+            errors.push({ fragment: relativePath, message: `failed to parse JSON: ${err.message}` });
+            continue;
+        }
+        if (!fragmentData.component)
+            continue;
+        blocksValidated++;
+        if (!knownComponents.has(fragmentData.component)) {
+            errors.push({
+                fragment: relativePath,
+                component: fragmentData.component,
+                message: `unknown component: "${fragmentData.component}"`,
+            });
+            continue;
+        }
+        const schema = schemaMap.get(fragmentData.component);
+        if (!schema)
+            continue;
+        const props = fragmentData.props ?? {};
+        const issues = validateJsonSchema(props, schema, 'props');
+        for (const issue of issues) {
+            errors.push({
+                fragment: relativePath,
+                component: fragmentData.component,
+                path: issue.path,
+                message: issue.message,
+            });
+        }
+    }
+    const success = errors.length === 0;
+    return {
+        success,
+        pagesValidated,
+        blocksValidated,
+        errors,
+        ...(warnings.length > 0 ? { warnings } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// Lightweight JSON Schema draft-2020-12 validator
+//
+// Covers the subset that Zod generates via z.toJSONSchema:
+//   type, required, properties, additionalProperties,
+//   minLength, minimum, maximum, enum, const,
+//   items, minItems, maxItems, anyOf, allOf, $ref (local)
+// ---------------------------------------------------------------------------
+function validateJsonSchema(value, schema, pathPrefix = '') {
+    const issues = [];
+    _validate(value, schema, pathPrefix, issues, schema);
+    return issues;
+}
+function _validate(value, schema, currentPath, issues, rootSchema) {
+    if (!schema || typeof schema !== 'object')
+        return;
+    // $ref — resolve local references
+    if (schema.$ref) {
+        const resolved = resolveRef(schema.$ref, rootSchema);
+        if (resolved) {
+            _validate(value, resolved, currentPath, issues, rootSchema);
+        }
+        return;
+    }
+    // anyOf — value must match at least one
+    if (Array.isArray(schema.anyOf)) {
+        const anyMatches = schema.anyOf.some((sub) => {
+            const subIssues = [];
+            _validate(value, sub, currentPath, subIssues, rootSchema);
+            return subIssues.length === 0;
+        });
+        if (!anyMatches) {
+            issues.push({ path: currentPath, message: `${currentPath}: does not match any allowed schema` });
+        }
+        return;
+    }
+    // allOf — value must match all
+    if (Array.isArray(schema.allOf)) {
+        for (const sub of schema.allOf) {
+            _validate(value, sub, currentPath, issues, rootSchema);
+        }
+        return;
+    }
+    // const
+    if ('const' in schema) {
+        if (value !== schema.const) {
+            issues.push({ path: currentPath, message: `${currentPath}: expected constant "${schema.const}", got ${JSON.stringify(value)}` });
+        }
+        return;
+    }
+    // enum
+    if (Array.isArray(schema.enum)) {
+        if (!schema.enum.includes(value)) {
+            issues.push({ path: currentPath, message: `${currentPath}: expected one of [${schema.enum.join(', ')}], got ${JSON.stringify(value)}` });
+        }
+        return;
+    }
+    // type checking
+    const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null;
+    if (types) {
+        const actualType = getJsonType(value);
+        const typeMatch = types.some((t) => t === actualType || (t === 'integer' && actualType === 'number' && Number.isInteger(value)));
+        if (!typeMatch) {
+            // Allow null for nullable schemas
+            if (value !== null || !types.includes('null')) {
+                issues.push({ path: currentPath, message: `${currentPath}: expected type ${types.join('|')}, got ${actualType}` });
+                return; // Stop further checks if type is wrong
+            }
+        }
+    }
+    if (value === null || value === undefined)
+        return;
+    // String checks
+    if (typeof value === 'string') {
+        if (typeof schema.minLength === 'number' && value.length < schema.minLength) {
+            issues.push({ path: currentPath, message: `${currentPath}: string length ${value.length} is less than minLength ${schema.minLength}` });
+        }
+        if (typeof schema.maxLength === 'number' && value.length > schema.maxLength) {
+            issues.push({ path: currentPath, message: `${currentPath}: string length ${value.length} exceeds maxLength ${schema.maxLength}` });
+        }
+    }
+    // Number checks
+    if (typeof value === 'number') {
+        if (typeof schema.minimum === 'number' && value < schema.minimum) {
+            issues.push({ path: currentPath, message: `${currentPath}: ${value} is less than minimum ${schema.minimum}` });
+        }
+        if (typeof schema.maximum === 'number' && value > schema.maximum) {
+            issues.push({ path: currentPath, message: `${currentPath}: ${value} exceeds maximum ${schema.maximum}` });
+        }
+    }
+    // Array checks
+    if (Array.isArray(value)) {
+        if (typeof schema.minItems === 'number' && value.length < schema.minItems) {
+            issues.push({ path: currentPath, message: `${currentPath}: array has ${value.length} items, minimum is ${schema.minItems}` });
+        }
+        if (typeof schema.maxItems === 'number' && value.length > schema.maxItems) {
+            issues.push({ path: currentPath, message: `${currentPath}: array has ${value.length} items, maximum is ${schema.maxItems}` });
+        }
+        if (schema.items) {
+            for (let i = 0; i < value.length; i++) {
+                _validate(value[i], schema.items, `${currentPath}[${i}]`, issues, rootSchema);
+            }
+        }
+    }
+    // Object checks
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        // Required fields
+        if (Array.isArray(schema.required)) {
+            for (const key of schema.required) {
+                if (!(key in value) || value[key] === undefined) {
+                    issues.push({ path: `${currentPath}.${key}`, message: `${currentPath}.${key}: required field is missing` });
+                }
+            }
+        }
+        // Properties
+        if (schema.properties) {
+            for (const [key, propSchema] of Object.entries(schema.properties)) {
+                if (key in value) {
+                    _validate(value[key], propSchema, `${currentPath}.${key}`, issues, rootSchema);
+                }
+            }
+        }
+    }
+}
+function getJsonType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+function resolveRef(ref, rootSchema) {
+    if (!ref.startsWith('#/'))
+        return null;
+    const parts = ref.slice(2).split('/');
+    let current = rootSchema;
+    for (const part of parts) {
+        current = current?.[part];
+    }
+    return current ?? null;
+}
+// ---------------------------------------------------------------------------
+// Content helpers
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Block ref validation — recursively validates nested blocks inside props.
+// ---------------------------------------------------------------------------
+function validateNestedSlots(parentBlock, componentMap, schemaMap, path = 'props') {
+    const issues = [];
+    const parentComponent = componentMap.get(parentBlock.component);
+    if (!parentComponent)
+        return issues;
+    const blockSlots = parentComponent.slots ?? {};
+    for (const [slotName, slot] of Object.entries(blockSlots)) {
+        const blocks = parentBlock.props?.[slotName];
+        if (!Array.isArray(blocks)) {
+            if (slot.required) {
+                issues.push({ path: `${path}.${slotName}`, message: `${parentBlock.component}: required block ref "${slotName}" has no children` });
+            }
+            continue;
+        }
+        if (!slot.multiple && blocks.length > 1) {
+            issues.push({ path: `${path}.${slotName}`, message: `${parentBlock.component}: block ref "${slotName}" allows at most one child` });
+        }
+        for (const [index, nestedBlock] of blocks.entries()) {
+            const nestedPath = `${path}.${slotName}[${index}]`;
+            if (!nestedBlock || typeof nestedBlock !== 'object' || typeof nestedBlock.component !== 'string') {
+                issues.push({ path: nestedPath, message: `${parentBlock.component}: block ref child must be a block` });
+                continue;
+            }
+            if (nestedBlock.$type !== 'component') {
+                issues.push({
+                    path: `${nestedPath}.$type`,
+                    message: `${parentBlock.component}: block ref child "$type" must be "component"`,
+                });
+                continue;
+            }
+            if (!componentMap.has(nestedBlock.component)) {
+                issues.push({ path: `${nestedPath}.component`, message: `${parentBlock.component}: unknown nested component "${nestedBlock.component}"` });
+                continue;
+            }
+            if (!slot.allowed.includes(nestedBlock.component)) {
+                issues.push({ path: `${nestedPath}.component`, message: `${parentBlock.component}: component "${nestedBlock.component}" is not allowed in block ref "${slotName}"` });
+            }
+            const childSchema = schemaMap.get(nestedBlock.component);
+            const childProps = nestedBlock.props ?? {};
+            if (childSchema) {
+                for (const issue of validateJsonSchema(childProps, childSchema, `${nestedPath}.props`)) {
+                    issues.push({ nestedComponent: nestedBlock.component, path: issue.path, message: `${parentBlock.component} → ${nestedBlock.component}: ${issue.message}` });
+                }
+            }
+            issues.push(...validateNestedSlots(nestedBlock, componentMap, schemaMap, nestedPath));
+        }
+    }
+    return issues;
+}
+function collectBlocks(pageData) {
+    const blocks = [];
+    if (pageData.regions && typeof pageData.regions === 'object') {
+        for (const region of Object.values(pageData.regions)) {
+            if (Array.isArray(region))
+                blocks.push(...region);
+            else if (region && typeof region === 'object' && Array.isArray(region.children))
+                blocks.push(...region.children);
+        }
+    }
+    if (Array.isArray(pageData.blocks))
+        blocks.push(...pageData.blocks);
+    return blocks;
+}
+async function findPageFiles(dir) {
+    return findFilesMatching(dir, (name) => name === '_index.json');
+}
+async function findJsonFiles(dir) {
+    return findFilesMatching(dir, (name) => name.endsWith('.json'));
+}
+async function findFilesMatching(dir, predicate) {
+    const results = [];
+    try {
+        await collectFiles(dir, predicate, results);
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT')
+            throw err;
+    }
+    return results;
+}
+async function collectFiles(dir, predicate, results) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            await collectFiles(full, predicate, results);
+        else if (predicate(entry.name))
+            results.push(full);
+    }
+}
+function parseArgs(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (!arg.startsWith('--'))
+            continue;
+        const body = arg.slice(2);
+        const equals = body.indexOf('=');
+        if (equals >= 0) {
+            out[body.slice(0, equals)] = body.slice(equals + 1);
+            continue;
+        }
+        out[body] = argv[++i];
+    }
+    return out;
+}
+function isMainModule() {
+    if (!process.argv[1])
+        return false;
+    try {
+        return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(path.resolve(process.argv[1]));
+    }
+    catch {
+        return false;
+    }
+}
+export { validateContent };

package/dist/cli/verify-next-cdn-routes.d.mts

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