@roblawn/devtool-runtime 0.1.0-alpha.0 → 0.1.0-alpha.1

package/dist/theme-contract/ops/emitters.d.ts

@@ -13,10 +13,12 @@ export declare class Emit {
     static colorRuntimeVar(cssVarName: string, tokenPrefix: string, value: unknown): string;
     static shadowCompose(value: unknown): string;
     static border(value: string): string;
+    static borderSide(side: 't' | 'r' | 'b' | 'l', value: string): string;
     static borderComposite(value: unknown): string;
     static borderCompositeSide(side: 't' | 'r' | 'b' | 'l', value: unknown): string;
     static borderCompositeAxis(axis: 'x' | 'y', value: unknown): string;
     static divideBorder(value: string): string;
+    static leading(value: unknown): string;
     static divideComposite(value: unknown): string;
     static zIndex(value: unknown): string;
     static aspect(value: unknown): string;

package/dist/theme-contract/ops/emitters.js

@@ -1,6 +1,14 @@
 const CONTAINER_PASSTHROUGH_SPECIALS = new Set(['full', 'screen', 'fit', 'min', 'max']);
 const CONTAINER_ALIAS_PASSTHROUGH = new Set(['full', 'screen', 'fit', 'min', 'max', 'none']);
 const ASPECT_ALIAS_PASSTHROUGH = new Set(['auto', 'square', 'video', 'none']);
+const LEADING_NUMERIC_ALIASES = new Map([
+    [1, 'leading-none'],
+    [1.25, 'leading-tight'],
+    [1.375, 'leading-snug'],
+    [1.5, 'leading-normal'],
+    [1.625, 'leading-relaxed'],
+    [2, 'leading-loose'],
+]);
 export class Emit {
     static isEmpty(value) {
         return value === undefined || value === null || value === '' || value === false;
@@ -96,13 +104,29 @@ export class Emit {
     static border(value) {
         const numericValue = Number(String(value));
         if (!Number.isFinite(numericValue)) {
-            return Emit.isEmpty(value) ? 'border-1' : `border-(length:--border-${String(value)})`;
+            return Emit.isEmpty(value) ? 'border' : `border-(length:--border-${String(value)})`;
+        }
+        if (numericValue === 1) {
+            return 'border';
         }
         if (Number.isInteger(numericValue)) {
             return `border-${numericValue}`;
         }
         return `border-[${numericValue}px]`;
     }
+    static borderSide(side, value) {
+        const numericValue = Number(String(value));
+        if (!Number.isFinite(numericValue)) {
+            return Emit.isEmpty(value) ? `border-${side}` : `border-${side}-(length:--border-${String(value)})`;
+        }
+        if (numericValue === 1) {
+            return `border-${side}`;
+        }
+        if (Number.isInteger(numericValue)) {
+            return `border-${side}-${numericValue}`;
+        }
+        return `border-${side}-[${numericValue}px]`;
+    }
     static borderComposite(value) {
         return Emit.isEmpty(value) ? '' : `border-${String(value)}`;
     }
@@ -115,13 +139,25 @@ export class Emit {
     static divideBorder(value) {
         const numericValue = Number(String(value));
         if (!Number.isFinite(numericValue)) {
-            return Emit.isEmpty(value) ? '' : `divide-x-(--border-${String(value)})`;
+            return Emit.isEmpty(value) ? '' : `divide-x-(length:--border-${String(value)})`;
+        }
+        if (numericValue === 1) {
+            return 'divide-x';
         }
         if (Number.isInteger(numericValue)) {
             return `divide-x-${numericValue}`;
         }
         return `divide-x-[${numericValue}px]`;
     }
+    static leading(value) {
+        if (Emit.isEmpty(value))
+            return '';
+        const numericValue = Number(String(value));
+        if (Number.isFinite(numericValue)) {
+            return LEADING_NUMERIC_ALIASES.get(numericValue) ?? `leading-[${numericValue}]`;
+        }
+        return Emit.prefix('leading', value);
+    }
     static divideComposite(value) {
         return Emit.isEmpty(value) ? '' : `divide-border-${String(value)}`;
     }

package/dist/theme-contract/tokens/schemas/spacing.token.schema.d.ts

@@ -8,13 +8,20 @@ export declare const spacingTokenSchema: {
         readonly direction: "asc";
     };
     readonly initialTokens: {
-        readonly zero: "0px";
         readonly '2xs': "2px";
         readonly xs: "4px";
         readonly sm: "8px";
         readonly md: "12px";
         readonly lg: "16px";
-        readonly xl: "24px";
+        readonly xl: "20px";
+        readonly '2xl': "24px";
+        readonly '3xl': "32px";
+        readonly '4xl': "40px";
+        readonly '5xl': "48px";
+        readonly '6xl': "64px";
+        readonly '7xl': "80px";
+        readonly '8xl': "96px";
+        readonly '9xl': "128px";
     };
     readonly toCssVarName: (tokenKey: string) => string;
     readonly toCssVarValue: (_tokenKey: string, tokenValue: string) => string;

package/dist/theme-contract/tokens/schemas/spacing.token.schema.js

@@ -7,13 +7,20 @@ export const spacingTokenSchema = defineTokenFamilySchema({
     responsive: true,
     order: { type: 'numeric', direction: 'asc' },
     initialTokens: {
-        zero: '0px',
         '2xs': '2px',
         xs: '4px',
         sm: '8px',
         md: '12px',
         lg: '16px',
-        xl: '24px',
+        xl: '20px',
+        '2xl': '24px',
+        '3xl': '32px',
+        '4xl': '40px',
+        '5xl': '48px',
+        '6xl': '64px',
+        '7xl': '80px',
+        '8xl': '96px',
+        '9xl': '128px',
     },
     toCssVarName: (tokenKey) => `--spacing-${tokenKey}`,
     toCssVarValue: (_tokenKey, tokenValue) => pxTokenToRemValue(tokenValue),

package/dist/theme-contract/tokens/tokens.schema.d.ts

@@ -331,13 +331,20 @@ export declare const TOKEN_SCHEMAS: readonly [{
         readonly direction: "asc";
     };
     readonly initialTokens: {
-        readonly zero: "0px";
         readonly '2xs': "2px";
         readonly xs: "4px";
         readonly sm: "8px";
         readonly md: "12px";
         readonly lg: "16px";
-        readonly xl: "24px";
+        readonly xl: "20px";
+        readonly '2xl': "24px";
+        readonly '3xl': "32px";
+        readonly '4xl': "40px";
+        readonly '5xl': "48px";
+        readonly '6xl': "64px";
+        readonly '7xl': "80px";
+        readonly '8xl': "96px";
+        readonly '9xl': "128px";
     };
     readonly toCssVarName: (tokenKey: string) => string;
     readonly toCssVarValue: (_tokenKey: string, tokenValue: string) => string;

package/dist/vite/embeddedJsonPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from 'vite';
+export interface EmbeddedJsonAsset {
+    fileName: string;
+    sourcePath: string;
+}
+export declare function listEmbeddedJsonAssets(projectRoot: string): Promise<EmbeddedJsonAsset[]>;
+export declare function embeddedJsonPlugin(): Plugin;
+export default embeddedJsonPlugin;

package/dist/vite/embeddedJsonPlugin.js

@@ -0,0 +1,109 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { LEGACY_CONFIG_FILE, LEGACY_NAME_LOWER, LEGACY_PRIVATE_DIR, LEGACY_PUBLIC_DIR, } from '../shared/legacyNames.js';
+function toOutputPath(...parts) {
+    return parts.join('/').replace(/\\/g, '/');
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizeRelativePath(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const next = value.trim();
+    return next.length > 0 ? next : fallback;
+}
+async function listDirs(abs) {
+    try {
+        const entries = await fs.readdir(abs, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+async function fileExists(abs) {
+    try {
+        await fs.access(abs);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readEmbeddedJsonConfig(projectRoot) {
+    const fallback = {
+        pagePublishRoot: './src/pages',
+        privateRoot: `./${LEGACY_PRIVATE_DIR}`,
+    };
+    try {
+        const raw = JSON.parse(await fs.readFile(path.resolve(projectRoot, LEGACY_CONFIG_FILE), 'utf8'));
+        if (!isPlainObject(raw))
+            return fallback;
+        const paths = isPlainObject(raw.paths) ? raw.paths : {};
+        return {
+            pagePublishRoot: normalizeRelativePath(paths.pagePublishRoot, fallback.pagePublishRoot),
+            privateRoot: normalizeRelativePath(paths[`${LEGACY_NAME_LOWER}PrivateRoot`], fallback.privateRoot),
+        };
+    }
+    catch {
+        return fallback;
+    }
+}
+export async function listEmbeddedJsonAssets(projectRoot) {
+    const config = await readEmbeddedJsonConfig(projectRoot);
+    const privateRoot = path.resolve(projectRoot, config.privateRoot);
+    const pagePublishRoot = path.resolve(projectRoot, config.pagePublishRoot);
+    const assets = [];
+    const pagesRoot = path.resolve(privateRoot, 'pages');
+    for (const slug of await listDirs(pagesRoot)) {
+        const sourcePath = path.resolve(pagesRoot, slug, 'content.json');
+        const pageEntry = path.resolve(pagePublishRoot, slug, 'index.vue');
+        if (!(await fileExists(sourcePath)) || !(await fileExists(pageEntry)))
+            continue;
+        assets.push({
+            fileName: toOutputPath(LEGACY_PUBLIC_DIR, 'pages', slug, 'content.json'),
+            sourcePath,
+        });
+    }
+    const modulesRoot = path.resolve(privateRoot, 'modules');
+    for (const subType of await listDirs(modulesRoot)) {
+        const subRoot = path.resolve(modulesRoot, subType);
+        for (const slug of await listDirs(subRoot)) {
+            const slugRoot = path.resolve(subRoot, slug);
+            const rootJson = path.resolve(slugRoot, 'content.json');
+            if (await fileExists(rootJson)) {
+                assets.push({
+                    fileName: toOutputPath(LEGACY_PUBLIC_DIR, 'modules', subType, slug, 'content.json'),
+                    sourcePath: rootJson,
+                });
+            }
+            for (const instance of await listDirs(slugRoot)) {
+                const instanceJson = path.resolve(slugRoot, instance, 'content.json');
+                if (!(await fileExists(instanceJson)))
+                    continue;
+                assets.push({
+                    fileName: toOutputPath(LEGACY_PUBLIC_DIR, 'modules', subType, slug, instance, 'content.json'),
+                    sourcePath: instanceJson,
+                });
+            }
+        }
+    }
+    return assets;
+}
+export function embeddedJsonPlugin() {
+    return {
+        name: 'runtime-embedded-json',
+        apply: 'build',
+        async generateBundle() {
+            for (const asset of await listEmbeddedJsonAssets(process.cwd())) {
+                const source = await fs.readFile(asset.sourcePath, 'utf8');
+                this.emitFile({ type: 'asset', fileName: asset.fileName, source });
+            }
+        },
+    };
+}
+export default embeddedJsonPlugin;

package/dist/vite/index.d.ts

@@ -0,0 +1,4 @@
+export * from './embeddedJsonPlugin.js';
+export * from './localJsonPlugin.js';
+export * from './staticFallbackPlugin.js';
+export * from './ssgEntryPlugin.js';

package/dist/vite/index.js

@@ -0,0 +1,4 @@
+export * from './embeddedJsonPlugin.js';
+export * from './localJsonPlugin.js';
+export * from './staticFallbackPlugin.js';
+export * from './ssgEntryPlugin.js';

package/dist/vite/localJsonPlugin.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from 'vite';
+export declare function resolveRuntimeJsonPath(privateRoot: string, requestPath: string): string | null;
+export declare function localJsonPlugin(): Plugin;
+export default localJsonPlugin;

package/dist/vite/localJsonPlugin.js

@@ -0,0 +1,70 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { LEGACY_PRIVATE_DIR, LEGACY_PUBLIC_DIR } from '../shared/legacyNames.js';
+function sendJson(res, statusCode, body) {
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.end(body);
+}
+function decodeRequestPath(requestPath) {
+    try {
+        return decodeURIComponent(requestPath).replace(/\\/g, '/');
+    }
+    catch {
+        return null;
+    }
+}
+function isSafeSegment(value) {
+    return value.length > 0 && value !== '.' && value !== '..' && !value.includes('/');
+}
+function isPublicRuntimeJsonPath(rel) {
+    const parts = rel.split('/');
+    if (!parts.every(isSafeSegment))
+        return false;
+    if (parts.length === 3 && parts[0] === 'pages' && parts[2] === 'content.json')
+        return true;
+    if (parts.length === 4 && parts[0] === 'modules' && parts[3] === 'content.json')
+        return true;
+    return parts.length === 5 && parts[0] === 'modules' && parts[4] === 'content.json';
+}
+export function resolveRuntimeJsonPath(privateRoot, requestPath) {
+    const normalized = decodeRequestPath(requestPath);
+    if (!normalized)
+        return null;
+    const prefixes = [`/${LEGACY_PRIVATE_DIR}/`, `/${LEGACY_PUBLIC_DIR}/`];
+    const prefix = prefixes.find((candidate) => normalized.startsWith(candidate));
+    if (!prefix)
+        return null;
+    const rel = normalized.slice(prefix.length);
+    if (!isPublicRuntimeJsonPath(rel))
+        return null;
+    const resolved = path.resolve(privateRoot, rel);
+    const rootWithSep = privateRoot.endsWith(path.sep) ? privateRoot : `${privateRoot}${path.sep}`;
+    if (resolved !== privateRoot && !resolved.startsWith(rootWithSep))
+        return null;
+    return resolved;
+}
+export function localJsonPlugin() {
+    return {
+        name: 'runtime-local-json',
+        apply: 'serve',
+        configureServer(server) {
+            const privateRoot = path.resolve(process.cwd(), LEGACY_PRIVATE_DIR);
+            server.middlewares.use(async (req, res, next) => {
+                const url = req.url?.split('?')[0] ?? '';
+                const filePath = resolveRuntimeJsonPath(privateRoot, url);
+                if (!filePath) {
+                    next();
+                    return;
+                }
+                try {
+                    sendJson(res, 200, await fs.readFile(filePath, 'utf8'));
+                }
+                catch {
+                    sendJson(res, 404, JSON.stringify({ error: 'Local JSON not found' }));
+                }
+            });
+        },
+    };
+}
+export default localJsonPlugin;

package/dist/vite/ssgEntryPlugin.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from 'vite';
+export interface SsgEntryPluginOptions {
+    enabled?: boolean;
+    entry?: string;
+}
+export declare function ssgEntryPlugin(options?: SsgEntryPluginOptions): Plugin;
+export default ssgEntryPlugin;

package/dist/vite/ssgEntryPlugin.js

@@ -0,0 +1,21 @@
+export function ssgEntryPlugin(options = {}) {
+    const enabled = options.enabled ?? true;
+    const entry = options.entry ?? '/src/main.ssg.ts';
+    return {
+        name: 'runtime-ssg-entry',
+        apply: 'build',
+        transformIndexHtml: {
+            order: 'pre',
+            handler(html) {
+                if (!enabled)
+                    return html;
+                const next = html.replace(/(<script\b[^>]*\btype=["']module["'][^>]*\bsrc=["'])\/src\/main\.ts(["'][^>]*><\/script>)/, `$1${entry}$2`);
+                if (next === html && !html.includes(`src="${entry}"`) && !html.includes(`src='${entry}'`)) {
+                    throw new Error(`[runtime-ssg-entry] Could not replace the HTML module entry with ${entry}.`);
+                }
+                return next;
+            },
+        },
+    };
+}
+export default ssgEntryPlugin;

package/dist/vite/staticFallbackPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from 'vite';
+interface StaticFallbackConfig {
+    notFound: string;
+    pagePublishRoot: string;
+}
+export declare function resolveStaticFallbackConfig(projectRoot: string): Promise<StaticFallbackConfig>;
+export declare function staticFallbackPlugin(): Plugin;
+export default staticFallbackPlugin;

package/dist/vite/staticFallbackPlugin.js

@@ -0,0 +1,77 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { LEGACY_CONFIG_FILE } from '../shared/legacyNames.js';
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizePageSlug(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const slug = value.trim().replace(/^\/+|\/+$/g, '');
+    if (!slug || slug.includes('\\') || slug.split('/').some((part) => part === '..' || part === '.')) {
+        return fallback;
+    }
+    return slug;
+}
+function normalizeRelativePath(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const next = value.trim();
+    return next.length > 0 ? next : fallback;
+}
+async function fileExists(abs) {
+    try {
+        await fs.access(abs);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveStaticFallbackConfig(projectRoot) {
+    const fallback = {
+        notFound: '404',
+        pagePublishRoot: './src/pages',
+    };
+    try {
+        const raw = JSON.parse(await fs.readFile(path.resolve(projectRoot, LEGACY_CONFIG_FILE), 'utf8'));
+        if (!isPlainObject(raw))
+            return fallback;
+        const paths = isPlainObject(raw.paths) ? raw.paths : {};
+        const site = isPlainObject(raw.site) ? raw.site : {};
+        const systemPages = isPlainObject(site.systemPages) ? site.systemPages : {};
+        return {
+            notFound: normalizePageSlug(systemPages.notFound, fallback.notFound),
+            pagePublishRoot: normalizeRelativePath(paths.pagePublishRoot, fallback.pagePublishRoot),
+        };
+    }
+    catch {
+        return fallback;
+    }
+}
+export function staticFallbackPlugin() {
+    let projectRoot = process.cwd();
+    let outDir = path.resolve(projectRoot, 'dist');
+    let mode = 'production';
+    return {
+        name: 'runtime-static-fallbacks',
+        apply: 'build',
+        configResolved(config) {
+            projectRoot = config.root;
+            outDir = path.resolve(config.root, config.build.outDir);
+            mode = config.mode;
+        },
+        async closeBundle() {
+            const config = await resolveStaticFallbackConfig(projectRoot);
+            const notFoundPage = path.resolve(projectRoot, config.pagePublishRoot, config.notFound, 'index.vue');
+            if (mode === 'ssg' && !(await fileExists(notFoundPage)))
+                return;
+            const indexHtml = path.resolve(outDir, 'index.html');
+            const notFoundHtml = path.resolve(outDir, '404.html');
+            if (!(await fileExists(indexHtml)) || (await fileExists(notFoundHtml)))
+                return;
+            await fs.copyFile(indexHtml, notFoundHtml);
+        },
+    };
+}
+export default staticFallbackPlugin;

package/package.json

@@ -1,14 +1,14 @@
 {
 	"name": "@roblawn/devtool-runtime",
-	"version": "0.1.0-alpha.0",
-	"description": "Repo-safe runtime primitives for visual site authoring.",
-	"license": "SEE LICENSE IN LICENSE.md",
-	"type": "module",
+	"version": "0.1.0-alpha.1",
+	"description": "Repo-safe runtime primitives for visual site authoring.",
+	"license": "SEE LICENSE IN LICENSE.md",
+	"type": "module",
 	"files": ["dist"],
-	"publishConfig": {
-		"access": "public",
-		"registry": "https://registry.npmjs.org"
-	},
+	"publishConfig": {
+		"access": "public",
+		"registry": "https://registry.npmjs.org"
+	},
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
@@ -22,31 +22,43 @@
 			"types": "./dist/ak/index.d.ts",
 			"import": "./dist/ak/index.js"
 		},
-		"./theme-contract": {
-			"types": "./dist/theme-contract/index.d.ts",
-			"import": "./dist/theme-contract/index.js"
-		},
+		"./theme-contract": {
+			"types": "./dist/theme-contract/index.d.ts",
+			"import": "./dist/theme-contract/index.js"
+		},
 		"./cms": {
 			"types": "./dist/cms/index.d.ts",
 			"import": "./dist/cms/index.js"
 		},
+		"./content": {
+			"types": "./dist/content/index.d.ts",
+			"import": "./dist/content/index.js"
+		},
+		"./vite": {
+			"types": "./dist/vite/index.d.ts",
+			"import": "./dist/vite/index.js"
+		},
+		"./static": {
+			"types": "./dist/static/index.d.ts",
+			"import": "./dist/static/index.js"
+		},
 		"./types": {
 			"types": "./dist/types/index.d.ts",
 			"import": "./dist/types/index.js"
 		},
-		"./authoring": {
-			"types": "./dist/authoring/index.d.ts",
-			"import": "./dist/authoring/index.js"
-		},
-		"./layout": {
-			"types": "./dist/layout/index.d.ts",
-			"import": "./dist/layout/index.js"
-		},
-		"./schema": {
-			"types": "./dist/schema/index.d.ts",
-			"import": "./dist/schema/index.js"
-		}
-	},
+		"./authoring": {
+			"types": "./dist/authoring/index.d.ts",
+			"import": "./dist/authoring/index.js"
+		},
+		"./layout": {
+			"types": "./dist/layout/index.d.ts",
+			"import": "./dist/layout/index.js"
+		},
+		"./schema": {
+			"types": "./dist/schema/index.d.ts",
+			"import": "./dist/schema/index.js"
+		}
+	},
 	"scripts": {
 		"clean": "node ../scripts/clean-runtime-dist.mjs",
 		"build": "pnpm run clean && tsc -p tsconfig.json && pnpm run check:package-boundary",
@@ -54,12 +66,20 @@
 		"dev": "tsc -p tsconfig.json -w --preserveWatchOutput"
 	},
 	"peerDependencies": {
-		"vue": "^3.5.0",
+		"vite": "^6.0.0 || ^7.0.0",
+		"vue": "^3.5.34",
 		"zod": ">=3.24.0 <4"
 	},
+	"peerDependenciesMeta": {
+		"vite": {
+			"optional": true
+		}
+	},
 	"devDependencies": {
+		"@types/node": "^22.14.0",
 		"typescript": "^5.8.3",
-		"vue": "^3.5.13",
+		"vite": "^6.2.0",
+		"vue": "^3.5.34",
 		"zod": "3.24.3"
 	}
 }