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

package/dist/static/buildSsg.js

@@ -0,0 +1,93 @@
+import { promises as fs } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const DEFAULT_ARGS = {
+    configFile: 'vite.config.ssg.ts',
+    mode: 'ssg',
+    outDir: 'ssg-dist',
+};
+const VITE_SSG_NODE_MODULE = 'vite-ssg/node';
+export function parseStaticSsgBuildArgs(argv) {
+    const args = { ...DEFAULT_ARGS };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === '--config' || arg === '-c') {
+            args.configFile = argv[index + 1] ?? args.configFile;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--config=')) {
+            args.configFile = arg.slice('--config='.length);
+            continue;
+        }
+        if (arg === '--mode') {
+            args.mode = argv[index + 1] ?? args.mode;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--mode=')) {
+            args.mode = arg.slice('--mode='.length);
+            continue;
+        }
+        if (arg === '--outDir') {
+            args.outDir = argv[index + 1] ?? args.outDir;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--outDir=')) {
+            args.outDir = arg.slice('--outDir='.length);
+        }
+    }
+    return args;
+}
+export async function buildStaticSsg(args = {}, options = {}) {
+    const buildArgs = { ...DEFAULT_ARGS, ...args };
+    const cwd = options.cwd ?? process.cwd();
+    try {
+        const { build } = await importViteSsgNode(cwd);
+        await build({ mode: buildArgs.mode }, { configFile: buildArgs.configFile });
+        return;
+    }
+    catch (error) {
+        if (isWindowsTempCleanupError(error) && (await renderedOutputExists(cwd, buildArgs.outDir))) {
+            console.warn('[build:ssg] vite-ssg rendered output, but Windows could not remove .vite-ssg-temp; continuing.');
+            return;
+        }
+        throw error;
+    }
+}
+async function importViteSsgNode(projectRoot) {
+    const projectRequire = createRequire(path.resolve(projectRoot, 'package.json'));
+    const resolved = projectRequire.resolve(VITE_SSG_NODE_MODULE);
+    return (await import(pathToFileURL(resolved).href));
+}
+export async function runStaticSsgBuildCli(argv = process.argv.slice(2)) {
+    await buildStaticSsg(parseStaticSsgBuildArgs(argv));
+}
+function isWindowsTempCleanupError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const withNodeFields = error;
+    return (withNodeFields.code === 'EBUSY' &&
+        withNodeFields.syscall === 'unlink' &&
+        typeof withNodeFields.path === 'string' &&
+        withNodeFields.path.includes(`${path.sep}.vite-ssg-temp${path.sep}`));
+}
+async function renderedOutputExists(projectRoot, outDir) {
+    const checks = [
+        { file: path.resolve(projectRoot, outDir, 'index.html'), minBytes: 1024 },
+        { file: path.resolve(projectRoot, outDir, '404.html'), minBytes: 256 },
+    ];
+    for (const check of checks) {
+        try {
+            const stat = await fs.stat(check.file);
+            if (!stat.isFile() || stat.size < check.minBytes)
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/static/index.d.ts

@@ -0,0 +1,4 @@
+export * from './packageStaticSite.js';
+export * from './packageNetlify.js';
+export * from './serveStaticSite.js';
+export * from './buildSsg.js';

package/dist/static/index.js

@@ -0,0 +1,4 @@
+export * from './packageStaticSite.js';
+export * from './packageNetlify.js';
+export * from './serveStaticSite.js';
+export * from './buildSsg.js';

package/dist/static/packageNetlify.d.ts

@@ -0,0 +1,28 @@
+type StaticSiteManifest = {
+    contract: string;
+    deployDir: string;
+    outputMode?: 'json-spa' | 'ssg';
+    pages: string[];
+    contentAssets: string[];
+    totalFiles: number;
+    totalBytes: number;
+};
+export type NetlifyPlanManifest = {
+    contract: string;
+    generatedAt: string;
+    dryRun: boolean;
+    deployDir: string;
+    shareProvider: string;
+    siteIdConfigured: boolean;
+    authTokenConfigured: boolean;
+    passwordConfigured: boolean;
+    files: Array<{
+        path: string;
+        bytes: number;
+    }>;
+    totalFiles: number;
+    totalBytes: number;
+    staticManifest: StaticSiteManifest;
+};
+export declare function packageNetlify(argv?: string[]): Promise<NetlifyPlanManifest>;
+export {};

package/dist/static/packageNetlify.js

@@ -0,0 +1,141 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { legacyContract, LEGACY_NAME_LOWER, LEGACY_PRIVATE_DIR, LEGACY_PUBLIC_DIR, } from '../shared/legacyNames.js';
+const REQUIRED_STATIC_CONTRACT = legacyContract('static-site-package.v1');
+const ENV_PREFIX = 'TUN' + 'DRA';
+const SHARE_PROVIDER_ENV = `${ENV_PREFIX}_SHARE_PROVIDER`;
+const SHARE_PASSWORD_ENV = `${ENV_PREFIX}_SHARE_PASSWORD`;
+function parseArgs(argv) {
+    const args = { check: false, dryRun: true };
+    for (const arg of argv) {
+        if (arg === '--check')
+            args.check = true;
+        if (arg === '--dry-run')
+            args.dryRun = true;
+    }
+    return args;
+}
+async function fileExists(abs) {
+    try {
+        const stat = await fs.stat(abs);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function listFiles(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (entry.name === '.vite')
+            continue;
+        const abs = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFiles(abs)));
+            continue;
+        }
+        files.push(abs);
+    }
+    return files.sort();
+}
+function toPosixRelative(root, abs) {
+    return path.relative(root, abs).replace(/\\/g, '/');
+}
+async function readStaticManifest(projectRoot) {
+    const manifestPath = path.resolve(projectRoot, LEGACY_PRIVATE_DIR, 'distribution', 'static-site-manifest.json');
+    const parsed = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+    if (parsed.contract !== REQUIRED_STATIC_CONTRACT) {
+        throw new Error(`[netlify-package] Unsupported static manifest contract: ${String(parsed.contract)}`);
+    }
+    return parsed;
+}
+async function readEnvFile(projectRoot) {
+    const envPath = path.resolve(projectRoot, ['.env', LEGACY_NAME_LOWER].join('.'));
+    if (!(await fileExists(envPath)))
+        return {};
+    const env = {};
+    const source = await fs.readFile(envPath, 'utf8');
+    for (const rawLine of source.split(/\r?\n/u)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const equals = line.indexOf('=');
+        if (equals <= 0)
+            continue;
+        const key = line.slice(0, equals).trim();
+        const value = line.slice(equals + 1).trim().replace(/^["']|["']$/g, '');
+        env[key] = value;
+    }
+    return env;
+}
+function readEnvValue(fileEnv, key) {
+    return process.env[key] ?? fileEnv[key] ?? '';
+}
+async function writeNetlifyStaticFiles(deployRoot, outputMode, password) {
+    const redirects = outputMode === 'ssg'
+        ? ['# SSG fallback', '/* /404.html 404', '']
+        : ['# Static SPA fallback', '/* /index.html 200', ''];
+    const headers = [
+        '/assets/*',
+        '  Cache-Control: public, max-age=31536000, immutable',
+        `/${LEGACY_PUBLIC_DIR}/*`,
+        '  Cache-Control: public, max-age=60',
+        '',
+    ];
+    if (password) {
+        if (/\s/u.test(password)) {
+            throw new Error('[netlify-package] Preview password cannot contain whitespace when using Netlify Basic-Auth.');
+        }
+        headers.push('/*', `  Basic-Auth: preview:${password}`, '');
+    }
+    await fs.writeFile(path.join(deployRoot, '_redirects'), redirects.join('\n'), 'utf8');
+    await fs.writeFile(path.join(deployRoot, '_headers'), headers.join('\n'), 'utf8');
+}
+async function buildNetlifyPlan(projectRoot, args) {
+    const staticManifest = await readStaticManifest(projectRoot);
+    const deployRoot = path.resolve(projectRoot, staticManifest.deployDir);
+    if (!(await fileExists(path.join(deployRoot, 'index.html')))) {
+        throw new Error('[netlify-package] Deploy directory is missing index.html. Run package:static first.');
+    }
+    const fileEnv = await readEnvFile(projectRoot);
+    const shareProvider = readEnvValue(fileEnv, SHARE_PROVIDER_ENV) || 'netlify';
+    const authToken = readEnvValue(fileEnv, 'NETLIFY_AUTH_TOKEN');
+    const siteId = readEnvValue(fileEnv, 'NETLIFY_SITE_ID');
+    const password = readEnvValue(fileEnv, SHARE_PASSWORD_ENV);
+    if (!args.check) {
+        await writeNetlifyStaticFiles(deployRoot, staticManifest.outputMode, password);
+    }
+    const files = await listFiles(deployRoot);
+    const fileEntries = await Promise.all(files.map(async (filePath) => ({
+        path: toPosixRelative(deployRoot, filePath),
+        bytes: (await fs.stat(filePath)).size,
+    })));
+    const totalBytes = fileEntries.reduce((sum, file) => sum + file.bytes, 0);
+    return {
+        contract: legacyContract('netlify-deploy-plan.v1'),
+        generatedAt: new Date().toISOString(),
+        dryRun: args.dryRun,
+        deployDir: staticManifest.deployDir,
+        shareProvider,
+        siteIdConfigured: siteId.length > 0,
+        authTokenConfigured: authToken.length > 0,
+        passwordConfigured: password.length > 0,
+        files: fileEntries,
+        totalFiles: fileEntries.length,
+        totalBytes,
+        staticManifest,
+    };
+}
+export async function packageNetlify(argv = process.argv.slice(2)) {
+    const projectRoot = process.cwd();
+    const args = parseArgs(argv);
+    const plan = await buildNetlifyPlan(projectRoot, args);
+    if (!args.check) {
+        const planPath = path.resolve(projectRoot, LEGACY_PRIVATE_DIR, 'distribution', 'netlify-deploy-plan.json');
+        await fs.mkdir(path.dirname(planPath), { recursive: true });
+        await fs.writeFile(planPath, `${JSON.stringify(plan, null, 2)}\n`, 'utf8');
+    }
+    console.log(`[netlify-package] ${plan.dryRun ? 'dry-run ' : ''}${plan.deployDir}: ${plan.totalFiles} files, auth=${plan.authTokenConfigured ? 'set' : 'missing'}, site=${plan.siteIdConfigured ? 'set' : 'missing'}`);
+    return plan;
+}

package/dist/static/packageStaticSite.d.ts

@@ -0,0 +1,19 @@
+export type StaticOutputMode = 'json-spa' | 'ssg';
+export interface PackageStaticSiteArgs {
+    outDir: string;
+    check: boolean;
+    mode: StaticOutputMode;
+}
+export interface StaticSiteManifest {
+    contract: string;
+    generatedAt: string;
+    deployDir: string;
+    outputMode: StaticOutputMode;
+    pages: string[];
+    requiredFiles: string[];
+    contentAssets: string[];
+    totalFiles: number;
+    totalBytes: number;
+}
+export declare function parsePackageStaticSiteArgs(argv: string[]): PackageStaticSiteArgs;
+export declare function packageStaticSite(argv?: string[], projectRoot?: string): Promise<StaticSiteManifest>;

package/dist/static/packageStaticSite.js

@@ -0,0 +1,144 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { LEGACY_CONFIG_FILE, legacyContract, LEGACY_PRIVATE_DIR } from '../shared/legacyNames.js';
+export function parsePackageStaticSiteArgs(argv) {
+    const args = { outDir: 'preview-dist', check: false, mode: 'json-spa' };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === '--check') {
+            args.check = true;
+            continue;
+        }
+        if (arg === '--outDir') {
+            args.outDir = argv[index + 1] ?? args.outDir;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--outDir=')) {
+            args.outDir = arg.slice('--outDir='.length);
+            continue;
+        }
+        if (arg === '--mode') {
+            args.mode = parseStaticOutputMode(argv[index + 1] ?? args.mode);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--mode=')) {
+            args.mode = parseStaticOutputMode(arg.slice('--mode='.length));
+        }
+    }
+    return args;
+}
+function parseStaticOutputMode(value) {
+    return value === 'ssg' ? 'ssg' : 'json-spa';
+}
+async function fileExists(abs) {
+    try {
+        const stat = await fs.stat(abs);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+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 readProjectConfig(projectRoot) {
+    const fallback = {
+        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 : {};
+        return {
+            pagePublishRoot: normalizeRelativePath(paths.pagePublishRoot, fallback.pagePublishRoot),
+        };
+    }
+    catch {
+        return fallback;
+    }
+}
+async function listFiles(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (entry.name === '.vite')
+            continue;
+        const abs = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFiles(abs)));
+            continue;
+        }
+        files.push(abs);
+    }
+    return files.sort();
+}
+async function readPageSlugs(projectRoot, config) {
+    const pagesRoot = path.resolve(projectRoot, config.pagePublishRoot);
+    try {
+        const entries = await fs.readdir(pagesRoot, { withFileTypes: true });
+        const slugs = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (await fileExists(path.join(pagesRoot, entry.name, 'index.vue')))
+                slugs.push(entry.name);
+        }
+        return slugs.sort();
+    }
+    catch {
+        return [];
+    }
+}
+function toPosixRelative(root, abs) {
+    return path.relative(root, abs).replace(/\\/g, '/');
+}
+async function buildManifest(projectRoot, args) {
+    const config = await readProjectConfig(projectRoot);
+    const deployRoot = path.resolve(projectRoot, args.outDir);
+    const requiredFiles = ['index.html', '404.html'];
+    const missing = [];
+    for (const fileName of requiredFiles) {
+        if (!(await fileExists(path.join(deployRoot, fileName))))
+            missing.push(fileName);
+    }
+    if (missing.length > 0) {
+        throw new Error(`[static-package] Missing required deploy files: ${missing.join(', ')}`);
+    }
+    const files = await listFiles(deployRoot);
+    const totalBytes = (await Promise.all(files.map(async (filePath) => (await fs.stat(filePath)).size))).reduce((sum, size) => sum + size, 0);
+    const contentAssets = files
+        .map((filePath) => toPosixRelative(deployRoot, filePath))
+        .filter((filePath) => filePath.startsWith('__tun' + 'dra/') && filePath.endsWith('/content.json'));
+    return {
+        contract: legacyContract('static-site-package.v1'),
+        generatedAt: new Date().toISOString(),
+        deployDir: toPosixRelative(projectRoot, deployRoot),
+        outputMode: args.mode,
+        pages: await readPageSlugs(projectRoot, config),
+        requiredFiles,
+        contentAssets,
+        totalFiles: files.length,
+        totalBytes,
+    };
+}
+export async function packageStaticSite(argv = process.argv.slice(2), projectRoot = process.cwd()) {
+    const args = parsePackageStaticSiteArgs(argv);
+    const manifest = await buildManifest(projectRoot, args);
+    if (!args.check) {
+        const manifestPath = path.resolve(projectRoot, LEGACY_PRIVATE_DIR, 'distribution', 'static-site-manifest.json');
+        await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+        await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    }
+    console.log(`[static-package] ${manifest.deployDir} (${manifest.outputMode}): ${manifest.totalFiles} files, ${manifest.contentAssets.length} content assets`);
+    return manifest;
+}

package/dist/static/serveStaticSite.d.ts

@@ -0,0 +1,9 @@
+export type ServeStaticMode = 'json-spa' | 'ssg';
+export interface ServeStaticSiteArgs {
+    host: string;
+    mode: ServeStaticMode;
+    outDir: string;
+    port: number;
+}
+export declare function parseServeStaticSiteArgs(argv: string[]): ServeStaticSiteArgs;
+export declare function serveStaticSite(argv?: string[], projectRoot?: string): Promise<void>;

package/dist/static/serveStaticSite.js

@@ -0,0 +1,143 @@
+import { createServer } from 'node:http';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+const contentTypes = {
+    '.css': 'text/css; charset=utf-8',
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.txt': 'text/plain; charset=utf-8',
+};
+export function parseServeStaticSiteArgs(argv) {
+    const args = {
+        host: '127.0.0.1',
+        mode: 'json-spa',
+        outDir: 'preview-dist',
+        port: 4173,
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === '--host') {
+            args.host = argv[index + 1] ?? args.host;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--host='))
+            args.host = arg.slice('--host='.length);
+        if (arg === '--mode') {
+            args.mode = parseMode(argv[index + 1] ?? args.mode);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--mode='))
+            args.mode = parseMode(arg.slice('--mode='.length));
+        if (arg === '--outDir') {
+            args.outDir = argv[index + 1] ?? args.outDir;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--outDir='))
+            args.outDir = arg.slice('--outDir='.length);
+        if (arg === '--port') {
+            args.port = parsePort(argv[index + 1] ?? String(args.port));
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--port='))
+            args.port = parsePort(arg.slice('--port='.length));
+    }
+    return args;
+}
+function parseMode(value) {
+    return value === 'ssg' ? 'ssg' : 'json-spa';
+}
+function parsePort(value) {
+    const port = Number(value);
+    if (Number.isInteger(port) && port > 0 && port < 65536)
+        return port;
+    return 4173;
+}
+function decodeRequestPath(req) {
+    const rawPath = new URL(req.url ?? '/', 'http://localhost').pathname;
+    try {
+        return decodeURIComponent(rawPath);
+    }
+    catch {
+        return '/';
+    }
+}
+function requestToCandidates(requestPath) {
+    const clean = requestPath.replace(/^\/+/, '');
+    if (!clean || clean.endsWith('/'))
+        return [path.join(clean, 'index.html')];
+    const ext = path.extname(clean);
+    return ext ? [clean] : [`${clean}.html`, path.join(clean, 'index.html')];
+}
+function resolveInside(root, relativePath) {
+    const resolved = path.resolve(root, relativePath);
+    const relative = path.relative(root, resolved);
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        return null;
+    return resolved;
+}
+async function fileExists(filePath) {
+    try {
+        const stat = await fs.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function findRequestFile(root, requestPath) {
+    for (const candidate of requestToCandidates(requestPath)) {
+        const resolved = resolveInside(root, candidate);
+        if (resolved && (await fileExists(resolved)))
+            return resolved;
+    }
+    return null;
+}
+async function sendFile(res, filePath, statusCode) {
+    const ext = path.extname(filePath);
+    res.writeHead(statusCode, {
+        'Cache-Control': ext === '.html' ? 'no-cache' : 'public, max-age=31536000, immutable',
+        'Content-Type': contentTypes[ext] ?? 'application/octet-stream',
+    });
+    res.end(await fs.readFile(filePath));
+}
+async function handleRequest(root, mode, req, res) {
+    const requestPath = decodeRequestPath(req);
+    const filePath = await findRequestFile(root, requestPath);
+    if (filePath) {
+        await sendFile(res, filePath, 200);
+        return;
+    }
+    const fallback = mode === 'ssg' ? '404.html' : 'index.html';
+    const fallbackPath = resolveInside(root, fallback);
+    if (fallbackPath && (await fileExists(fallbackPath))) {
+        await sendFile(res, fallbackPath, mode === 'ssg' ? 404 : 200);
+        return;
+    }
+    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+    res.end('Not found');
+}
+export async function serveStaticSite(argv = process.argv.slice(2), projectRoot = process.cwd()) {
+    const args = parseServeStaticSiteArgs(argv);
+    const root = path.resolve(projectRoot, args.outDir);
+    if (!(await fileExists(path.join(root, 'index.html')))) {
+        throw new Error(`[serve-static] Missing ${args.outDir}/index.html. Build first.`);
+    }
+    const server = createServer((req, res) => {
+        handleRequest(root, args.mode, req, res).catch((error) => {
+            res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
+            res.end(error instanceof Error ? error.message : 'Internal server error');
+        });
+    });
+    await new Promise((resolve) => {
+        server.listen(args.port, args.host, () => {
+            console.log(`[serve-static] ${args.mode} ${args.outDir} -> http://${args.host}:${args.port}/`);
+            resolve();
+        });
+    });
+}

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

@@ -315,16 +315,7 @@ const CORE_DESIGN_OP_CONFIG_RAW = {
             step: 0.5,
         },
         private: true,
-        resolve: (v) => {
-            const numericValue = Number(String(v));
-            if (!Number.isFinite(numericValue)) {
-                return Emit.isEmpty(v) ? 'border-t' : `border-t-(length:--border-${String(v)})`;
-            }
-            if (Number.isInteger(numericValue)) {
-                return `border-t-${numericValue}`;
-            }
-            return `border-t-[${numericValue}px]`;
-        },
+        resolve: (v) => Emit.borderSide('t', v),
     },
     borderWidthR: {
         tokenFamily: 'borderWidth',
@@ -336,16 +327,7 @@ const CORE_DESIGN_OP_CONFIG_RAW = {
             step: 0.5,
         },
         private: true,
-        resolve: (v) => {
-            const numericValue = Number(String(v));
-            if (!Number.isFinite(numericValue)) {
-                return Emit.isEmpty(v) ? 'border-r' : `border-r-(length:--border-${String(v)})`;
-            }
-            if (Number.isInteger(numericValue)) {
-                return `border-r-${numericValue}`;
-            }
-            return `border-r-[${numericValue}px]`;
-        },
+        resolve: (v) => Emit.borderSide('r', v),
     },
     borderWidthB: {
         tokenFamily: 'borderWidth',
@@ -357,16 +339,7 @@ const CORE_DESIGN_OP_CONFIG_RAW = {
             step: 0.5,
         },
         private: true,
-        resolve: (v) => {
-            const numericValue = Number(String(v));
-            if (!Number.isFinite(numericValue)) {
-                return Emit.isEmpty(v) ? 'border-b' : `border-b-(length:--border-${String(v)})`;
-            }
-            if (Number.isInteger(numericValue)) {
-                return `border-b-${numericValue}`;
-            }
-            return `border-b-[${numericValue}px]`;
-        },
+        resolve: (v) => Emit.borderSide('b', v),
     },
     borderWidthL: {
         tokenFamily: 'borderWidth',
@@ -378,16 +351,7 @@ const CORE_DESIGN_OP_CONFIG_RAW = {
             step: 0.5,
         },
         private: true,
-        resolve: (v) => {
-            const numericValue = Number(String(v));
-            if (!Number.isFinite(numericValue)) {
-                return Emit.isEmpty(v) ? 'border-l' : `border-l-(length:--border-${String(v)})`;
-            }
-            if (Number.isInteger(numericValue)) {
-                return `border-l-${numericValue}`;
-            }
-            return `border-l-[${numericValue}px]`;
-        },
+        resolve: (v) => Emit.borderSide('l', v),
     },
     borderColor: {
         tokenFamily: 'color',
@@ -528,13 +492,7 @@ const CORE_DESIGN_OP_CONFIG_RAW = {
             step: 0.001,
         },
         private: true,
-        resolve: (v) => {
-            const numericValue = Number(String(v));
-            if (Number.isFinite(numericValue)) {
-                return `leading-[${numericValue}]`;
-            }
-            return Emit.prefix('leading', v);
-        },
+        resolve: (v) => Emit.leading(v),
     },
     tracking: {
         tokenFamily: 'tracking',