@stdout-design/core 0.1.1 → 0.1.2

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as isZodObject, n as PropValidationError, o as validateProps, r as PropValidationIssue, s as zodToJsonSchemaShape, t as PropSchema } from "./validation-BUNZnc-5.mjs";
+import { a as validateProps, i as isZodObject, n as PropValidationError, o as zodToJsonSchemaShape, t as PropSchema } from "./validation-MigzRuji.mjs";
 import { z } from "zod";
 import { fromJsx } from "takumi-js/helpers/jsx";
 import { ComponentType } from "react";
@@ -42,8 +42,13 @@ declare const studioConfigSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>;
 }, z.core.$strip>;
+declare const parseStudioConfig: (raw: unknown) => {
+  config: StudioConfig;
+} | {
+  issues: string;
+};
 //#endregion
-//#region src/shared/render.d.ts
+//#region src/engine/render.d.ts
 interface CompiledTemplate {
   node: Node;
   stylesheets: string[];
@@ -85,7 +90,7 @@ declare const logInfo: (message: string, context?: Record<string, unknown>) => v
 declare const logWarn: (message: string, context?: Record<string, unknown>) => void;
 declare const logError: (code: ErrorCode, message: string, context?: Record<string, unknown>) => void;
 //#endregion
-//#region src/node/cache-keys.d.ts
+//#region src/cache/cache-keys.d.ts
 /**
  * Cache key derivation, shared by every component that needs to name a
  * cache entry consistently. Pulled out of the old monolithic RenderCache
@@ -108,7 +113,7 @@ interface PixelCacheKeyInput {
 declare const createCompileCacheKey: (input: CompileCacheKeyInput) => string;
 declare const createPixelCacheKey: (input: PixelCacheKeyInput) => string;
 //#endregion
-//#region src/node/render-cache.d.ts
+//#region src/cache/render-cache.d.ts
 interface CacheStats {
   compiled: {
     entries: number;
@@ -176,7 +181,7 @@ declare class RenderCache {
   private requireEviction;
 }
 //#endregion
-//#region src/node/takumi-types-shim.d.ts
+//#region src/engine/takumi-types-shim.d.ts
 /**
  * Type-only shim for `@takumi-rs/core` (as re-exported by `takumi-js/node`).
  *
@@ -276,7 +281,7 @@ interface MeasuredNode {
   runs: MeasuredTextRun[];
 }
 //#endregion
-//#region src/node/renderer.d.ts
+//#region src/engine/renderer.d.ts
 /**
  * Preload a font once and reuse it across many renders without re-passing
  * its bytes on every call. Optional -- per Takumi's v2 guidance, passing
@@ -317,35 +322,51 @@ declare const measureTemplate: (template: CompiledTemplate, options?: RenderOpti
  */
 declare const renderAutoSized: (template: CompiledTemplate, options?: RenderOptions, signal?: AbortSignal) => Promise<RenderOutput>;
 //#endregion
-//#region src/batch/types.d.ts
-type OutputFormat = "webp" | "png" | "jpeg" | "ico" | "raw";
-interface MatrixCell {
-  rowIndex: number;
-  rowKey: string;
-  locale: string;
-  preset: Pick<Preset, "id" | "width" | "height">;
-  props: Record<string, unknown>;
+//#region src/project/project-paths.d.ts
+interface ProjectPaths {
+  configPath: string;
+  defaultCacheDir: string;
+  localesDir: string;
+  templatesDir: string;
+}
+declare const resolveProjectPaths: (rootDir: string) => ProjectPaths;
+//#endregion
+//#region src/cache/open-cache.d.ts
+interface OpenCacheOptions {
+  cacheDir?: string;
+  maxSizeMB?: number;
 }
-interface RenderOneInput {
-  compiledTemplate: CompiledTemplate;
-  templateId: string;
-  contentHash: string;
+declare const openCache: (rootDir: string, options?: OpenCacheOptions) => Promise<RenderCache>;
+//#endregion
+//#region src/assets/assets-resolver.d.ts
+interface AssetsForLocale {
+  fonts: Font[];
+  fontFamilies?: string[];
+  lang: string | undefined;
   props: Record<string, unknown>;
-  width: number;
-  height: number;
-  locale?: string;
-  format?: OutputFormat;
-  cache: RenderCache;
-  outDir: string;
-  filename: string;
-  signal?: AbortSignal;
-  renderOptions?: Pick<RenderOptions, "fonts" | "fontFamilies" | "lang"> & Record<string, unknown>;
 }
-interface RenderOneOutput {
-  outputPath: string;
-  cacheHit: boolean;
-  durationMs: number;
+interface FontResolutionResult {
+  fonts: Font[];
+  fontFamilies: string[];
 }
+interface AssetsResolverOptions {
+  fetchFonts?: (localeId: string) => Promise<FontResolutionResult | null>;
+  localeData?: Record<string, unknown>;
+  loadLocaleData?: (locale: string) => Promise<Record<string, unknown>>;
+  preResolvedFonts?: Font[];
+  preResolvedFontFamilies?: string[];
+}
+declare const resolveAssetsForLocale: (localeId: string, props: Record<string, unknown>, options?: AssetsResolverOptions) => Promise<AssetsForLocale>;
+//#endregion
+//#region src/batch/loaders.d.ts
+interface LoadedTemplate {
+  module: TemplateModule;
+  contentHash: string;
+}
+declare const importTemplateForBatch: (rootDir: string, componentPath: string, templateId: string) => Promise<LoadedTemplate>;
+declare const loadConfig: (rootDir: string) => Promise<StudioConfig>;
+//#endregion
+//#region src/batch/types.d.ts
 interface ManifestEntry {
   rowIndex: number;
   locale: string;
@@ -366,49 +387,9 @@ interface Manifest {
   }[];
 }
 //#endregion
-//#region src/batch/matrix.d.ts
-interface MatrixLocaleInput {
-  id: string;
-  data?: Record<string, unknown>;
-}
-interface DataRow {
-  key?: string;
-  id?: string;
-  slug?: string;
-  [key: string]: unknown;
-}
-interface MatrixInput {
-  rows: DataRow[];
-  locales: MatrixLocaleInput[];
-  presets: Pick<Preset, "id" | "width" | "height">[];
-  baseProps?: Record<string, unknown>;
-}
-/**
- * Expands rows × locales × presets into a flat array of matrix cells.
- * Locale data is merged into props during expansion so each cell carries
- * fully resolved props.
- */
-declare const expandMatrix: (input: MatrixInput) => MatrixCell[];
-//#endregion
-//#region src/batch/render-one.d.ts
-declare const renderOne: (input: RenderOneInput) => Promise<RenderOneOutput>;
-//#endregion
-//#region src/batch/naming.d.ts
-interface NamingOptions {
-  templateId: string;
-  locale: string;
-  presetId: string;
-  rowKey: string;
-  format?: string;
-}
-declare const generateOutputFilename: (options: NamingOptions) => string;
-//#endregion
-//#region src/batch/manifest.d.ts
-declare const writeManifest: (filePath: string, manifest: Manifest) => Promise<void>;
-//#endregion
-//#region src/batch/single.d.ts
+//#region src/orchestrate/single.d.ts
 interface SingleInput {
-  component: ComponentType<any>;
+  component: ComponentType<Record<string, unknown>>;
   propsSchema: PropSchema;
   props: Record<string, unknown>;
   preset: {
@@ -424,6 +405,55 @@ interface SingleOutput {
 }
 declare const renderComponent: (input: SingleInput) => Promise<SingleOutput>;
 //#endregion
+//#region src/orchestrate/types.d.ts
+type OutputFormat = "webp" | "png" | "jpeg" | "ico" | "raw";
+interface OrchestrateRenderInput {
+  component?: ComponentType<Record<string, unknown>>;
+  compiledTemplate?: CompiledTemplate;
+  templateContentHash: string;
+  templateId: string;
+  props: Record<string, unknown>;
+  propsSchema?: PropSchema;
+  locale?: string;
+  loadLocaleData?: (locale: string) => Promise<Record<string, unknown>>;
+  fonts?: Font[];
+  fontFamilies?: string[];
+  width: number;
+  height: number;
+  cache: RenderCache;
+  format?: OutputFormat;
+  signal?: AbortSignal;
+}
+interface OrchestrateRenderResult {
+  bytes: Buffer;
+  width: number;
+  height: number;
+  format: string;
+  cacheHit: boolean;
+  durationMs: number;
+}
+interface OrchestrateMeasureInput {
+  component?: ComponentType<Record<string, unknown>>;
+  compiledTemplate?: CompiledTemplate;
+  templateContentHash: string;
+  templateId: string;
+  props: Record<string, unknown>;
+  propsSchema?: PropSchema;
+  locale?: string;
+  loadLocaleData?: (locale: string) => Promise<Record<string, unknown>>;
+  cache: RenderCache;
+  signal?: AbortSignal;
+}
+interface OrchestrateMeasureResult {
+  width: number;
+  height: number;
+  durationMs: number;
+}
+//#endregion
+//#region src/orchestrate/orchestrate.d.ts
+declare const orchestrateRender: (input: OrchestrateRenderInput) => Promise<OrchestrateRenderResult>;
+declare const orchestrateMeasure: (input: OrchestrateMeasureInput) => Promise<OrchestrateMeasureResult>;
+//#endregion
 //#region src/batch/batch.d.ts
 interface BatchInput {
   rootDir: string;
@@ -444,17 +474,4 @@ interface BatchOutput {
 }
 declare const runBatch: (input: BatchInput) => Promise<BatchOutput>;
 //#endregion
-//#region src/batch/loaders.d.ts
-interface LoadedTemplate {
-  module: TemplateModule;
-  contentHash: string;
-}
-declare const loadConfig: (rootDir: string) => Promise<StudioConfig>;
-declare const importTemplateForBatch: (rootDir: string, componentPath: string, templateId: string) => Promise<LoadedTemplate>;
-declare const parseDataFile: (filePath: string) => Promise<Record<string, unknown>[]>;
-declare const resolveLocales: (rootDir: string, localeCodes: string[], templateId: string) => Promise<{
-  id: string;
-  data?: Record<string, unknown>;
-}[]>;
-//#endregion
-export { AppError, type BatchInput, type BatchOutput, type CacheStats, type CompileCacheKeyInput, type CompiledTemplate, type DataRow, ErrorCode, type ErrorCode as ErrorCodeType, type Font, type LoadedTemplate, type LogLevel, type Manifest, type ManifestEntry, type MatrixCell, type MatrixInput, type MatrixLocaleInput, type NamingOptions, type PixelCacheKeyInput, type Preset, PropValidationError, type PropValidationIssue, RenderCache, type RenderCacheOptions, type RenderOneInput, type RenderOneOutput, type RenderOptions, type RenderOutput, type SingleInput, type SingleOutput, type StudioConfig, type TemplateEntry, type TemplateModule, compileTemplate, expandMatrix, generateOutputFilename, importTemplateForBatch, isZodObject, loadConfig, logDebug, logError, logInfo, logWarn, measureTemplate, parseDataFile, registerFont, renderAutoSized, renderComponent, renderOne, renderToPixels, resolveLocales, runBatch, studioConfigSchema, validateProps, writeManifest, zodToJsonSchemaShape };
+export { AppError, type AssetsForLocale, type AssetsResolverOptions, type BatchInput, type BatchOutput, type CacheStats, type CompiledTemplate, ErrorCode, type ErrorCode as ErrorCodeType, type FontResolutionResult, type LogLevel, type Manifest, type ManifestEntry, type OpenCacheOptions, type OrchestrateMeasureInput, type OrchestrateMeasureResult, type OrchestrateRenderInput, type OrchestrateRenderResult, PropValidationError, RenderCache, type RenderCacheOptions, type RenderOutput, type SingleInput, type SingleOutput, type StudioConfig, type TemplateModule, compileTemplate, importTemplateForBatch, isZodObject, loadConfig, logDebug, logError, logInfo, logWarn, measureTemplate, openCache, orchestrateMeasure, orchestrateRender, parseStudioConfig, registerFont, renderAutoSized, renderComponent, renderToPixels, resolveAssetsForLocale, resolveProjectPaths, runBatch, studioConfigSchema, validateProps, zodToJsonSchemaShape };

package/dist/index.mjs

@@ -12,9 +12,9 @@ import { Database } from "bun:sqlite";
 import { Kysely, sql } from "kysely";
 import { BunSqliteDialect } from "kysely-bun-sqlite";
 import { Renderer } from "takumi-js/node";
-import { createElement } from "react";
 import { googleFonts } from "@takumi-rs/helpers";
 import { pathToFileURL } from "node:url";
+import { createElement } from "react";
 //#region src/shared/config-schema.ts
 const templateEntrySchema = z.object({
 	componentPath: z.string().min(1, "componentPath is required"),
@@ -33,8 +33,13 @@ const studioConfigSchema = z.object({
 	presets: z.array(presetSchema),
 	templates: z.record(z.string(), templateEntrySchema)
 });
+const parseStudioConfig = (raw) => {
+	const parsed = studioConfigSchema.safeParse(raw);
+	if (!parsed.success) return { issues: parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ") };
+	return { config: parsed.data };
+};
 //#endregion
-//#region src/shared/render.ts
+//#region src/engine/render.ts
 const compileTemplate = async (element, options) => {
 	const result = await fromJsx(element, options);
 	return {
@@ -94,11 +99,11 @@ const logError = (code, message, context) => {
 	console.error(`[${timestamp()}] ERROR [${code}] ${message}${stringifyContext(context)}`);
 };
 //#endregion
-//#region src/node/cache-keys.ts
+//#region src/cache/cache-keys.ts
 const createCompileCacheKey = (input) => createHash("sha256").update(`${input.templateId}\u0000${input.templateContentHash}\u0000${input.propsJSON}`).digest("hex").slice(0, 16);
 const createPixelCacheKey = (input) => createHash("sha256").update(`${input.templateContentHash}\u0000${input.propsJSON}\u0000${input.width}x${input.height}\u0000${input.format ?? "png"}`).digest("hex").slice(0, 32);
 //#endregion
-//#region src/node/compile-cache.ts
+//#region src/cache/compile-cache.ts
 /**
 * CompileCache: in-memory compile-result cache.
 *
@@ -176,7 +181,7 @@ var CompileCache = class {
 	}
 };
 //#endregion
-//#region src/node/concurrency-limiter.ts
+//#region src/cache/concurrency-limiter.ts
 /**
 * Bounds how many concurrent operations (writes/reads through FsStore)
 * run at once. Exists to cap the "N concurrent large-buffer renders spike
@@ -210,7 +215,7 @@ var ConcurrencyLimiter = class {
 	}
 };
 //#endregion
-//#region src/node/eviction-coordinator.ts
+//#region src/cache/eviction-coordinator.ts
 const DEFAULT_DEBOUNCE_MS = 250;
 /**
 * Coordinates eviction across both time (debouncing) and processes
@@ -296,7 +301,7 @@ var EvictionCoordinator = class {
 	}
 };
 //#endregion
-//#region src/node/fs-store.ts
+//#region src/cache/fs-store.ts
 const defaultFsPrimitives = {
 	existsSync,
 	readFile,
@@ -415,7 +420,7 @@ var FsStore = class {
 	}
 };
 //#endregion
-//#region src/node/metadata-store.ts
+//#region src/cache/metadata-store.ts
 const BUSY_TIMEOUT_MS = 5e3;
 const toRow = (r) => ({
 	contentHash: r.content_hash,
@@ -598,7 +603,7 @@ var MetadataStore = class {
 	}
 };
 //#endregion
-//#region src/node/render-cache.ts
+//#region src/cache/render-cache.ts
 const DEFAULT_MAX_SIZE_MB = 500;
 /**
 * Content-addressed two-stage render cache -- coordinator.
@@ -781,7 +786,7 @@ var RenderCache = class {
 	}
 };
 //#endregion
-//#region src/node/takumi-types-shim.ts
+//#region src/engine/takumi-types-shim.ts
 /**
 * Type-only shim for `@takumi-rs/core` (as re-exported by `takumi-js/node`).
 *
@@ -821,7 +826,7 @@ var RenderCache = class {
 */
 const Renderer$1 = Renderer;
 //#endregion
-//#region src/node/renderer.ts
+//#region src/engine/renderer.ts
 /**
 * Renderer lifecycle -- v2.
 *
@@ -911,175 +916,108 @@ const renderAutoSized = async (template, options, signal) => {
 	}, options, signal);
 };
 //#endregion
-//#region src/batch/matrix.ts
-const mergeLocale = (props, localeData) => {
-	if (!localeData) return props;
-	const merged = { ...props };
-	for (const [key, value] of Object.entries(localeData)) if (Array.isArray(value) && Array.isArray(merged[key])) merged[key] = value;
-	else if (typeof value === "string" && typeof merged[key] === "string") merged[key] = value;
-	return merged;
-};
-/**
-* Expands rows × locales × presets into a flat array of matrix cells.
-* Locale data is merged into props during expansion so each cell carries
-* fully resolved props.
-*/
-const expandMatrix = (input) => {
-	const { rows, locales, presets, baseProps = {} } = input;
-	if (rows.length === 0) return [];
-	const cells = [];
-	for (const [rowIndex, row] of rows.entries()) {
-		const rowKey = String(row.key ?? row.id ?? row.slug ?? String(rowIndex));
-		const rowProps = {
-			...baseProps,
-			...row
-		};
-		delete rowProps.key;
-		delete rowProps.id;
-		delete rowProps.slug;
-		for (const locale of locales) {
-			const localeProps = mergeLocale(rowProps, locale.data);
-			for (const preset of presets) cells.push({
-				locale: locale.id,
-				preset: {
-					height: preset.height,
-					id: preset.id,
-					width: preset.width
-				},
-				props: {
-					...localeProps,
-					locale: locale.id
-				},
-				rowIndex,
-				rowKey
-			});
-		}
-	}
-	return cells;
-};
+//#region src/project/project-paths.ts
+const resolveProjectPaths = (rootDir) => ({
+	configPath: path.resolve(rootDir, "studio.config.ts"),
+	defaultCacheDir: path.resolve(rootDir, ".studio-cache"),
+	localesDir: path.resolve(rootDir, "locales"),
+	templatesDir: path.resolve(rootDir, "templates")
+});
 //#endregion
-//#region src/batch/utils.ts
-const ensureDir = async (dir) => {
-	if (!existsSync(dir)) await mkdir(dir, { recursive: true });
+//#region src/cache/open-cache.ts
+const openCache = async (rootDir, options) => {
+	const cache = new RenderCache({
+		cacheDir: options?.cacheDir ?? resolveProjectPaths(rootDir).defaultCacheDir,
+		maxSizeMB: options?.maxSizeMB
+	});
+	await cache.init();
+	return cache;
 };
-const tryWriteFile = async (filePath, data) => {
+//#endregion
+//#region src/assets/assets-resolver.ts
+const isFontDescriptor = (f) => typeof f === "object" && !(f instanceof Uint8Array);
+const defaultFetchFonts = async (localeId) => {
 	try {
-		await writeFile(filePath, data);
+		const fonts = await googleFonts([{
+			name: "Noto Sans Arabic",
+			weight: [400, 700]
+		}]);
+		const fontFamilies = fonts.filter(isFontDescriptor).map((f) => String(f.name ?? "")).filter(Boolean);
+		logDebug("googleFonts resolved per locale", {
+			count: fonts.length,
+			localeId,
+			names: fonts.filter(isFontDescriptor).map((f) => f.name)
+		});
+		return {
+			fontFamilies,
+			fonts
+		};
 	} catch (error) {
-		logWarn("Failed to write output file", {
+		logDebug("googleFonts failed for locale", {
 			error: String(error),
-			filePath
+			localeId
 		});
+		return null;
 	}
 };
-//#endregion
-//#region src/batch/render-one.ts
-const renderOne = async (input) => {
-	const start = performance.now();
-	const { compiledTemplate, contentHash, props, width, height, format = "png", locale, cache, outDir, filename, signal, renderOptions } = input;
-	const propsJSON = JSON.stringify(props);
-	const pixelKey = RenderCache.createPixelCacheKey({
-		format,
-		height,
-		propsJSON,
-		templateContentHash: contentHash,
-		width
-	});
-	const cached = await cache.getPixels(pixelKey);
-	if (cached) {
-		const outputPath = `${outDir}/${filename}`;
-		await ensureDir(outDir);
-		await tryWriteFile(outputPath, cached);
-		return {
-			cacheHit: true,
-			durationMs: performance.now() - start,
-			outputPath
-		};
-	}
-	const lang = locale?.startsWith("ar") ? "ar" : void 0;
-	logDebug("renderOne -> renderToPixels", {
-		fontFamilies: renderOptions?.fontFamilies,
-		fontNames: renderOptions?.fonts?.map((f) => typeof f === "object" && "name" in f ? f.name : "raw"),
-		fontsCount: renderOptions?.fonts?.length ?? 0,
-		lang,
-		locale
-	});
-	const output = await renderToPixels(compiledTemplate, {
-		height,
-		width
-	}, {
-		fontFamilies: renderOptions?.fontFamilies,
-		fonts: renderOptions?.fonts,
-		format,
-		lang
-	}, signal);
-	await cache.setPixels(pixelKey, output.bytes, width, height, format);
-	const outputPath = `${outDir}/${filename}`;
-	await ensureDir(outDir);
-	await tryWriteFile(outputPath, output.bytes);
+const mergeLocaleProps = (props, localeData) => {
+	if (!localeData) return { ...props };
+	const merged = { ...props };
+	for (const [key, value] of Object.entries(localeData)) if (Array.isArray(value) && Array.isArray(merged[key])) merged[key] = value;
+	else if (typeof value === "string" && typeof merged[key] === "string") merged[key] = value;
+	return merged;
+};
+const classifyLocale = (localeId) => {
+	const isArabic = localeId.startsWith("ar");
 	return {
-		cacheHit: false,
-		durationMs: performance.now() - start,
-		outputPath
+		lang: isArabic ? "ar" : void 0,
+		needsArabic: isArabic
 	};
 };
-//#endregion
-//#region src/batch/naming.ts
-const generateOutputFilename = (options) => {
-	const { templateId, locale, presetId, rowKey, format = "png" } = options;
-	return `${templateId}.${locale}.${presetId}.${rowKey}.${format}`;
-};
-//#endregion
-//#region src/batch/manifest.ts
-const writeManifest = async (filePath, manifest) => {
-	await mkdir(path.dirname(filePath), { recursive: true });
-	await writeFile(filePath, JSON.stringify(manifest, null, 2));
-};
-//#endregion
-//#region src/batch/single.ts
-const renderComponent = async (input) => {
-	const { component, format = "png", outDir = "./out", preset, props, propsSchema } = input;
-	const { bytes } = await renderToPixels(await compileTemplate(createElement(component, validateProps(propsSchema, props))), {
-		height: preset.height,
-		width: preset.width
-	}, { format });
-	const outputPath = `${outDir}/${generateOutputFilename({
-		locale: "default",
-		presetId: preset.id,
-		rowKey: "single",
-		templateId: "single"
-	})}`;
-	await ensureDir(outDir);
-	await Bun.write(outputPath, bytes);
-	return { outputPath };
-};
-//#endregion
-//#region src/batch/loaders.ts
-const loadConfig = async (rootDir) => {
-	const configPath = path.resolve(rootDir, "studio.config.ts");
-	try {
-		await readFile(configPath, "utf-8");
+const fontCache = /* @__PURE__ */ new Map();
+const resolveAssetsForLocale = async (localeId, props, options) => {
+	let localeData = options?.localeData;
+	if (options?.loadLocaleData) try {
+		localeData = await options.loadLocaleData(localeId);
 	} catch {
-		throw new AppError(ErrorCode.CONFIG_NOT_FOUND, `No studio.config.ts found in ${rootDir}.`);
+		localeData = {};
 	}
-	logDebug("Loading studio.config.ts", { path: configPath });
-	const mod = await import(pathToFileURL(configPath).href);
-	const raw = mod.default ?? mod;
-	const parsed = studioConfigSchema.safeParse(raw);
-	if (!parsed.success) {
-		const issues = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
-		throw new AppError(ErrorCode.CONFIG_INVALID, `studio.config.ts is invalid: ${issues}`);
+	const mergedProps = mergeLocaleProps(props, localeData);
+	const { lang, needsArabic } = classifyLocale(localeId);
+	let fonts = [];
+	let fontFamilies;
+	if (options?.preResolvedFonts) {
+		fonts = options.preResolvedFonts;
+		fontFamilies = options.preResolvedFontFamilies;
+	} else if (needsArabic) {
+		const fetch = options?.fetchFonts ?? defaultFetchFonts;
+		const cached = fontCache.get(localeId);
+		let resolution;
+		if (cached) resolution = await cached;
+		else {
+			const promise = fetch(localeId);
+			fontCache.set(localeId, promise);
+			resolution = await promise;
+		}
+		if (resolution) ({fontFamilies, fonts} = resolution);
 	}
-	return parsed.data;
+	return {
+		fontFamilies,
+		fonts,
+		lang,
+		props: mergedProps
+	};
 };
-const importTemplateForBatch = async (rootDir, componentPath, templateId) => {
-	const fullPath = path.resolve(rootDir, `${componentPath}.tsx`);
+//#endregion
+//#region src/batch/loaders.ts
+const templateCache = /* @__PURE__ */ new Map();
+const loadTemplateForBatch = async (fullPath, templateId) => {
 	let content;
 	try {
 		content = await readFile(fullPath, "utf-8");
 	} catch {
 		throw new AppError(ErrorCode.TEMPLATE_LOAD_FAILED, `Template file not found: ${fullPath}`, {
-			componentPath,
+			componentPath: fullPath,
 			templateId
 		});
 	}
@@ -1097,6 +1035,32 @@ const importTemplateForBatch = async (rootDir, componentPath, templateId) => {
 		module: mod
 	};
 };
+const importTemplateForBatch = async (rootDir, componentPath, templateId) => {
+	const fullPath = path.resolve(rootDir, `${componentPath}.tsx`);
+	const cached = templateCache.get(fullPath);
+	if (cached) return cached;
+	const promise = loadTemplateForBatch(fullPath, templateId);
+	templateCache.set(fullPath, promise);
+	try {
+		return await promise;
+	} catch {
+		templateCache.delete(fullPath);
+		throw await promise.catch((error) => error);
+	}
+};
+const loadConfig = async (rootDir) => {
+	const { configPath } = resolveProjectPaths(rootDir);
+	try {
+		await readFile(configPath, "utf-8");
+	} catch {
+		throw new AppError(ErrorCode.CONFIG_NOT_FOUND, `No studio.config.ts found in ${rootDir}.`);
+	}
+	logDebug("Loading studio.config.ts", { path: configPath });
+	const mod = await import(pathToFileURL(configPath).href);
+	const result = parseStudioConfig(mod.default ?? mod);
+	if ("issues" in result) throw new AppError(ErrorCode.CONFIG_INVALID, `studio.config.ts is invalid: ${result.issues}`);
+	return result.config;
+};
 const parseDataFile = async (filePath) => {
 	const content = await readFile(filePath, "utf-8");
 	if (filePath.endsWith(".json")) {
@@ -1116,8 +1080,9 @@ const parseDataFile = async (filePath) => {
 };
 const resolveLocales = async (rootDir, localeCodes, templateId) => {
 	if (localeCodes.length === 0) return [{ id: "default" }];
+	const { localesDir } = resolveProjectPaths(rootDir);
 	return await Promise.all(localeCodes.map(async (code) => {
-		const localePath = path.resolve(rootDir, `locales/${code}.json`);
+		const localePath = path.resolve(localesDir, `${code}.json`);
 		try {
 			const content = await readFile(localePath, "utf-8");
 			return {
@@ -1130,36 +1095,211 @@ const resolveLocales = async (rootDir, localeCodes, templateId) => {
 	}));
 };
 //#endregion
-//#region src/batch/batch.ts
-const isFontDescriptor = (f) => typeof f === "object" && !(f instanceof Uint8Array);
-const resolveArabicFonts = async (_locales) => {
-	let fonts = [];
-	let fontFamilies = [];
-	try {
-		fonts = await googleFonts([{
-			name: "Noto Sans Arabic",
-			weight: [400, 700]
-		}]);
-		fontFamilies = fonts.filter(isFontDescriptor).map((f) => String(f.name ?? "")).filter(Boolean);
-		logDebug("googleFonts resolved", {
-			count: fonts.length,
-			hasData: fonts.filter(isFontDescriptor).map((f) => typeof f.data),
-			names: fonts.filter(isFontDescriptor).map((f) => f.name)
-		});
-	} catch (error) {
-		logDebug("googleFonts failed, using direct URL fallback", { error: String(error) });
-		fonts = [{
-			data: /* @__PURE__ */ new Uint8Array(0),
-			name: "Noto Sans Arabic",
-			weight: 400
-		}];
-		fontFamilies = ["Noto Sans Arabic"];
+//#region src/batch/naming.ts
+const generateOutputFilename = (options) => {
+	const { templateId, locale, presetId, rowKey, format = "png" } = options;
+	return `${templateId}.${locale}.${presetId}.${rowKey}.${format}`;
+};
+//#endregion
+//#region src/orchestrate/orchestrate.ts
+const prepPipeline = async (input) => {
+	const { compiledTemplate: preCompiled, component, templateContentHash, templateId, props, propsSchema, locale, loadLocaleData, preResolvedFonts, preResolvedFontFamilies, cache } = input;
+	const { fonts: resolvedFonts, fontFamilies: resolvedFontFamilies, lang: resolvedLang, props: merged } = await resolveAssetsForLocale(locale, propsSchema ? validateProps(propsSchema, props) : { ...props }, {
+		loadLocaleData,
+		preResolvedFontFamilies,
+		preResolvedFonts
+	});
+	const propsJSON = JSON.stringify(merged);
+	const compileKey = RenderCache.createCompileCacheKey({
+		propsJSON,
+		templateContentHash,
+		templateId
+	});
+	let compiled = preCompiled;
+	if (!compiled) {
+		if (!component) throw new Error("Must provide either compiledTemplate or component");
+		const cachedCompile = cache.getCompiled(compileKey);
+		if (cachedCompile) compiled = cachedCompile;
+		else {
+			compiled = await compileTemplate(createElement(component, merged));
+			cache.setCompiledWithContentHash(compileKey, templateContentHash, compiled);
+		}
 	}
 	return {
-		fontFamilies,
-		fonts
+		compileKey,
+		compiled,
+		mergedProps: merged,
+		propsJSON,
+		resolvedFontFamilies,
+		resolvedFonts,
+		resolvedLang
+	};
+};
+const orchestrateRender = async (input) => {
+	const start = performance.now();
+	const { compiledTemplate, component, templateContentHash, templateId, props, propsSchema, locale: localeId, loadLocaleData, fonts: preResolvedFonts, fontFamilies: preResolvedFontFamilies, width, height, cache, format = "png", signal } = input;
+	const prep = await prepPipeline({
+		cache,
+		compiledTemplate,
+		component,
+		loadLocaleData,
+		locale: localeId ?? "default",
+		preResolvedFontFamilies,
+		preResolvedFonts,
+		props,
+		propsSchema,
+		templateContentHash,
+		templateId
+	});
+	const pixelKey = RenderCache.createPixelCacheKey({
+		format,
+		height,
+		propsJSON: prep.propsJSON,
+		templateContentHash,
+		width
+	});
+	const cached = await cache.getPixels(pixelKey);
+	if (cached) return {
+		bytes: cached,
+		cacheHit: true,
+		durationMs: performance.now() - start,
+		format,
+		height,
+		width
+	};
+	const output = await renderToPixels(prep.compiled, {
+		height,
+		width
+	}, {
+		fontFamilies: (prep.resolvedFontFamilies ?? []).length > 0 ? prep.resolvedFontFamilies : void 0,
+		fonts: prep.resolvedFonts.length > 0 ? prep.resolvedFonts : void 0,
+		format,
+		lang: prep.resolvedLang
+	}, signal);
+	await cache.setPixels(pixelKey, output.bytes, width, height, format);
+	return {
+		bytes: output.bytes,
+		cacheHit: false,
+		durationMs: performance.now() - start,
+		format,
+		height: output.height,
+		width: output.width
 	};
 };
+const orchestrateMeasure = async (input) => {
+	const start = performance.now();
+	const { compiledTemplate, component, templateContentHash, templateId, props, propsSchema, locale: localeId, loadLocaleData, cache, signal } = input;
+	const prep = await prepPipeline({
+		cache,
+		compiledTemplate,
+		component,
+		loadLocaleData,
+		locale: localeId ?? "default",
+		preResolvedFontFamilies: void 0,
+		preResolvedFonts: void 0,
+		props,
+		propsSchema,
+		templateContentHash,
+		templateId
+	});
+	const measured = await measureTemplate(prep.compiled, {
+		fontFamilies: (prep.resolvedFontFamilies ?? []).length > 0 ? prep.resolvedFontFamilies : void 0,
+		fonts: prep.resolvedFonts.length > 0 ? prep.resolvedFonts : void 0,
+		lang: prep.resolvedLang
+	}, signal);
+	return {
+		durationMs: performance.now() - start,
+		height: measured.height,
+		width: measured.width
+	};
+};
+//#endregion
+//#region src/orchestrate/utils.ts
+const ensureDir = async (dir) => {
+	if (!existsSync(dir)) await mkdir(dir, { recursive: true });
+};
+const tryWriteFile = async (filePath, data) => {
+	try {
+		await writeFile(filePath, data);
+	} catch (error) {
+		logWarn("Failed to write output file", {
+			error: String(error),
+			filePath
+		});
+	}
+};
+//#endregion
+//#region src/orchestrate/single.ts
+const noop = () => {};
+const noopCache = {
+	getCompiled: () => null,
+	getPixels: () => null,
+	setCompiledWithContentHash: noop,
+	setPixels: noop
+};
+const renderComponent = async (input) => {
+	const { component, format = "png", outDir = "./out", preset, props, propsSchema } = input;
+	const result = await orchestrateRender({
+		cache: noopCache,
+		component,
+		format,
+		height: preset.height,
+		props,
+		propsSchema,
+		templateContentHash: "single",
+		templateId: "single",
+		width: preset.width
+	});
+	const outputPath = `${outDir}/${generateOutputFilename({
+		locale: "default",
+		presetId: preset.id,
+		rowKey: "single",
+		templateId: "single"
+	})}`;
+	await ensureDir(outDir);
+	await Bun.write(outputPath, result.bytes);
+	return { outputPath };
+};
+//#endregion
+//#region src/batch/manifest.ts
+const writeManifest = async (filePath, manifest) => {
+	await mkdir(path.dirname(filePath), { recursive: true });
+	await writeFile(filePath, JSON.stringify(manifest, null, 2));
+};
+//#endregion
+//#region src/batch/matrix.ts
+const expandMatrix = (input) => {
+	const { rows, locales, presets, baseProps = {} } = input;
+	if (rows.length === 0) return [];
+	const cells = [];
+	for (const [rowIndex, row] of rows.entries()) {
+		const rowKey = String(row.key ?? row.id ?? row.slug ?? String(rowIndex));
+		const rowProps = {
+			...baseProps,
+			...row
+		};
+		delete rowProps.key;
+		delete rowProps.id;
+		delete rowProps.slug;
+		for (const localeId of locales) for (const preset of presets) cells.push({
+			locale: localeId,
+			preset: {
+				height: preset.height,
+				id: preset.id,
+				width: preset.width
+			},
+			props: {
+				...rowProps,
+				locale: localeId
+			},
+			rowIndex,
+			rowKey
+		});
+	}
+	return cells;
+};
+//#endregion
+//#region src/batch/batch.ts
 const runBatch = async (input) => {
 	const start = performance.now();
 	const { baseProps = {}, dataFile, failFast = false, cacheDir: cacheDirOverride, locales: filterLocales, outDir: outDirOverride, presets: filterPresets, rootDir, rows: inlineRows, templateId } = input;
@@ -1177,63 +1317,48 @@ const runBatch = async (input) => {
 			width: p.width
 		};
 	});
-	const locales = await resolveLocales(rootDir, filterLocales ?? config.locales ?? [], templateId);
+	const resolvedLocales = await resolveLocales(rootDir, filterLocales ?? config.locales ?? [], templateId);
+	const localeDataMap = new Map(resolvedLocales.map((l) => [l.id, l.data ?? {}]));
+	const loadLocaleData = (code) => Promise.resolve(localeDataMap.get(code) ?? {});
+	const rows = dataFile ? await parseDataFile(path.resolve(rootDir, dataFile)) : inlineRows ?? [];
 	const cells = expandMatrix({
 		baseProps,
-		locales,
+		locales: resolvedLocales.map((l) => l.id),
 		presets,
-		rows: dataFile ? await parseDataFile(path.resolve(rootDir, dataFile)) : inlineRows ?? []
+		rows
 	});
 	const outDir = path.resolve(rootDir, outDirOverride ?? config.outDir ?? "./out");
-	const cache = new RenderCache({ cacheDir: cacheDirOverride ?? path.resolve(rootDir, ".studio-cache") });
-	await cache.init();
-	const arabicLocales = locales.filter((l) => l.id.startsWith("ar"));
-	logDebug("Arabic locale detection", {
-		arabicCount: arabicLocales.length,
-		localeIds: locales.map((l) => l.id)
-	});
-	let fonts = [];
-	let fontFamilies;
-	if (arabicLocales.length > 0) {
-		const { fonts: resolvedFonts, fontFamilies: resolvedFamilies } = await resolveArabicFonts(locales);
-		fonts = resolvedFonts;
-		fontFamilies = resolvedFamilies;
-	}
+	const cache = await openCache(rootDir, { cacheDir: cacheDirOverride });
 	const succeeded = [];
 	const failed = [];
-	const renderOptions = fonts.length > 0 ? {
-		fontFamilies,
-		fonts
-	} : void 0;
-	logDebug("renderOptions before loop", {
-		fontFamilies,
-		fontsCount: fonts.length,
-		hasOptions: renderOptions !== void 0
-	});
 	try {
 		for (const cell of cells) try {
-			const result = await renderOne({
+			const filename = generateOutputFilename({
+				locale: cell.locale,
+				presetId: cell.preset.id,
+				rowKey: cell.rowKey,
+				templateId
+			});
+			const result = await orchestrateRender({
 				cache,
-				compiledTemplate: await compileTemplate(createElement(Component, cell.props)),
-				contentHash,
-				filename: generateOutputFilename({
-					locale: cell.locale,
-					presetId: cell.preset.id,
-					rowKey: cell.rowKey,
-					templateId
-				}),
+				component: Component,
+				format: "png",
 				height: cell.preset.height,
+				loadLocaleData,
 				locale: cell.locale,
-				outDir,
 				props: cell.props,
-				renderOptions,
+				propsSchema: module.propsSchema,
+				templateContentHash: contentHash,
 				templateId,
 				width: cell.preset.width
 			});
+			const outputPath = `${outDir}/${filename}`;
+			await ensureDir(outDir);
+			await tryWriteFile(outputPath, result.bytes);
 			succeeded.push({
 				cacheHit: result.cacheHit,
 				locale: cell.locale,
-				outputPath: result.outputPath,
+				outputPath,
 				preset: cell.preset.id,
 				rowIndex: cell.rowIndex
 			});
@@ -1263,4 +1388,4 @@ const runBatch = async (input) => {
 	};
 };
 //#endregion
-export { AppError, ErrorCode, PropValidationError, RenderCache, compileTemplate, expandMatrix, generateOutputFilename, importTemplateForBatch, isZodObject, loadConfig, logDebug, logError, logInfo, logWarn, measureTemplate, parseDataFile, registerFont, renderAutoSized, renderComponent, renderOne, renderToPixels, resolveLocales, runBatch, studioConfigSchema, validateProps, writeManifest, zodToJsonSchemaShape };
+export { AppError, ErrorCode, PropValidationError, RenderCache, compileTemplate, importTemplateForBatch, isZodObject, loadConfig, logDebug, logError, logInfo, logWarn, measureTemplate, openCache, orchestrateMeasure, orchestrateRender, parseStudioConfig, registerFont, renderAutoSized, renderComponent, renderToPixels, resolveAssetsForLocale, resolveProjectPaths, runBatch, studioConfigSchema, validateProps, zodToJsonSchemaShape };

package/dist/schema.d.mts

@@ -1,2 +1,2 @@
-import { i as defineSchema, t as PropSchema } from "./validation-BUNZnc-5.mjs";
+import { r as defineSchema, t as PropSchema } from "./validation-MigzRuji.mjs";
 export { type PropSchema, defineSchema };

package/dist/{validation-BUNZnc-5.d.mts → validation-MigzRuji.d.mts}

@@ -36,4 +36,4 @@ declare const validateProps: <T extends PropSchema>(schema: T, props: unknown) =
 declare const isZodObject: (schema: unknown) => schema is z.ZodObject<Record<string, z.ZodTypeAny>>;
 declare const zodToJsonSchemaShape: (schema: z.ZodTypeAny) => Record<string, unknown>;
 //#endregion
-export { isZodObject as a, defineSchema as i, PropValidationError as n, validateProps as o, PropValidationIssue as r, zodToJsonSchemaShape as s, PropSchema as t };
+export { validateProps as a, isZodObject as i, PropValidationError as n, zodToJsonSchemaShape as o, defineSchema as r, PropSchema as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stdout-design/core",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Core rendering engine for stdout-design — compile TSX templates to pixel-perfect images via Takumi",
   "keywords": [
     "design",
@@ -49,32 +49,33 @@
     "build": "tsdown",
     "dev": "tsdown --watch",
     "test": "bun test",
+    "test:integration": "bun test ./src/__tests__/full-pipeline.integration.ts",
     "check-types": "tsc --noEmit",
     "check-types:tsgo": "tsgo --noEmit",
     "lint": "ultracite check"
   },
   "dependencies": {
-    "@takumi-rs/core": "^2.0.0",
-    "@takumi-rs/helpers": "^2.0.0",
+    "@takumi-rs/core": "^2.1.1",
+    "@takumi-rs/helpers": "^2.1.1",
     "csv-parse": "^7.0.1",
     "kysely": "^0.29.3",
     "kysely-bun-sqlite": "^0.4.0",
-    "p-limit": "^7.0.0",
+    "p-limit": "^7.3.0",
     "proper-lockfile": "^4.1.2",
     "react": "^19.2.7",
-    "takumi-js": "^2.0.0",
+    "takumi-js": "^2.1.1",
     "write-file-atomic": "^8.0.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@sinonjs/fake-timers": "^15.4.0",
     "@stdout-design/config": "workspace:*",
-    "@takumi-rs/wasm": "^2.0.0",
+    "@takumi-rs/wasm": "^2.1.1",
     "@types/proper-lockfile": "^4.1.4",
     "@types/react": "^19.2.17",
     "@types/sinonjs__fake-timers": "^15.0.1",
     "@types/write-file-atomic": "^4.0.3",
-    "tsdown": "^0.22.4",
-    "typescript": "^7"
+    "tsdown": "^0.22.5",
+    "typescript": "^7.0.2"
   }
 }