@iodes/releasekit 0.1.0

package/dist/images.js

@@ -0,0 +1,123 @@
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import sharp from 'sharp';
+import { themes, theme } from './model.js';
+import { Project, editable } from './project.js';
+import { readVisual, checkReferenceFiles } from './content.js';
+import { digest, identifier, exists, write, writeYaml } from './files.js';
+import { imagePrompt, sceneHash } from './prompts.js';
+export async function inspectImage(bytes) {
+    const image = sharp(bytes, { limitInputPixels: 16_777_216, failOn: 'warning' });
+    const metadata = await image.metadata();
+    if (!metadata.format || !['png', 'jpeg', 'webp'].includes(metadata.format) || !metadata.width || !metadata.height || (metadata.pages ?? 1) > 1) {
+        throw new Error('Use a still PNG, JPEG, or WebP image.');
+    }
+    await image.stats(); // Decode the file so a plausible but truncated header cannot pass import.
+    const rotated = (metadata.orientation ?? 1) >= 5;
+    return {
+        width: rotated ? metadata.height : metadata.width,
+        height: rotated ? metadata.width : metadata.height,
+        extension: metadata.format === 'jpeg' ? 'jpg' : metadata.format,
+        sha256: digest(bytes),
+    };
+}
+export async function planImages(project, version) {
+    const release = await project.release(version);
+    const requests = [];
+    let ready = 0;
+    for (const note of release.notes.filter(n => n.image)) {
+        const visual = await readVisual(project, version, note.id);
+        const pair = visual.variants;
+        const invalidPair = release.visuals.themes === 'both' && pair.dark && pair.light &&
+            (pair.dark.sha256 === pair.light.sha256 || pair.dark.width !== pair.light.width || pair.dark.height !== pair.light.height);
+        for (const variant of themes(release.visuals)) {
+            const expected = sceneHash(visual.scene, release.visuals, variant);
+            const asset = visual.variants[variant];
+            const file = asset && await project.releaseFile(version, asset.file);
+            const present = !!file && await exists(file);
+            const current = !!asset && present && asset.sceneHash === expected && digest(await fs.readFile(file)) === asset.sha256 && !(invalidPair && variant === 'light');
+            if (current) {
+                ready++;
+                continue;
+            }
+            editable(release);
+            await checkReferenceFiles(project, visual.scene.references);
+            const promptFile = await project.releaseFile(version, `prompts/${note.id}.${variant}.md`);
+            await write(promptFile, imagePrompt(visual.scene, release.visuals, variant));
+            const otherTheme = variant === 'dark' ? 'light' : 'dark';
+            const other = visual.variants[otherTheme];
+            let compositionReference = null;
+            if (other && other.sceneHash === sceneHash(visual.scene, release.visuals, otherTheme)) {
+                const reference = await project.releaseFile(version, other.file);
+                if (await exists(reference) && digest(await fs.readFile(reference)) === other.sha256)
+                    compositionReference = reference;
+            }
+            requests.push({ note: note.id, theme: variant, reason: present ? 'stale' : 'missing', promptFile, compositionReference });
+        }
+    }
+    return {
+        version, configuredThemes: themes(release.visuals), requestedAssets: ready + requests.length,
+        readyAssets: ready, pendingAssets: requests.length, requests,
+        costNote: 'Counts describe required output assets, not provider prices or a guarantee of one tool call per asset. No image service was called.',
+    };
+}
+export async function importImage(project, version, noteId, variant, source) {
+    const release = await project.release(version);
+    editable(release);
+    identifier(noteId);
+    theme.parse(variant);
+    if (!release.notes.some(n => n.id === noteId && n.image))
+        throw new Error(`No image-enabled note named ${noteId}.`);
+    if (!themes(release.visuals).includes(variant))
+        throw new Error(`Theme ${variant} is not enabled for this release. Update the project setting and sync the draft first.`);
+    const visual = await readVisual(project, version, noteId);
+    const bytes = await fs.readFile(path.resolve(project.root, source));
+    const inspected = await inspectImage(bytes);
+    const file = `assets/${noteId}.${variant}.${inspected.sha256.slice(0, 12)}.${inspected.extension}`;
+    const destination = await project.releaseFile(version, file);
+    if (await exists(destination)) {
+        if (digest(await fs.readFile(destination)) !== inspected.sha256)
+            throw new Error('The asset destination has conflicting content.');
+    }
+    else
+        await write(destination, bytes);
+    visual.variants[variant] = {
+        file, sha256: inspected.sha256, sceneHash: sceneHash(visual.scene, release.visuals, variant),
+        width: inspected.width, height: inspected.height,
+    };
+    await writeYaml(await project.releaseFile(version, `visuals/${noteId}.yaml`), visual);
+    return visual.variants[variant];
+}
+export async function validateImages(project, version, noteId, visual, errors, warnings) {
+    const release = await project.release(version);
+    for (const variant of themes(release.visuals)) {
+        const expected = sceneHash(visual.scene, release.visuals, variant);
+        const asset = visual.variants[variant];
+        if (!asset) {
+            errors.push(`${noteId}: ${variant} image is pending.`);
+            continue;
+        }
+        try {
+            if (asset.sceneHash !== expected)
+                errors.push(`${noteId}: ${variant} image was created for an older scene or palette.`);
+            const actual = await inspectImage(await fs.readFile(await project.releaseFile(version, asset.file)));
+            if (actual.sha256 !== asset.sha256 || actual.width !== asset.width || actual.height !== asset.height) {
+                errors.push(`${noteId}: ${variant} asset changed after import; import the selected file again.`);
+            }
+            const requestedRatio = release.visuals.width / release.visuals.height;
+            if (Math.abs(actual.width / actual.height / requestedRatio - 1) > 0.05) {
+                warnings.push(`${noteId}: ${variant} aspect ratio differs from the project target; review its framing.`);
+            }
+        }
+        catch (error) {
+            errors.push(`${noteId}/${variant}: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    if (release.visuals.themes === 'both' && visual.variants.dark && visual.variants.light) {
+        const { dark, light } = visual.variants;
+        if (dark.sha256 === light.sha256)
+            errors.push(`${noteId}: the two theme variants are identical; provide a real pair or select a single theme.`);
+        if (dark.width !== light.width || dark.height !== light.height)
+            errors.push(`${noteId}: paired variants must have identical dimensions.`);
+    }
+}

package/dist/install.d.ts

@@ -0,0 +1,27 @@
+import { Project } from './project.js';
+import { type ProjectConfig } from './model.js';
+export declare function installSkills(project: Project): Promise<{
+    tools: ("claude" | "codex" | "cursor")[];
+    written: string[];
+    conflicts: string[];
+    hints: {
+        codex: string;
+        claude: string;
+        cursor: string;
+    };
+}>;
+export declare function initProject(project: Project, options: {
+    product?: string;
+    tools?: ProjectConfig['tools'];
+    themes?: ProjectConfig['visuals']['themes'];
+}): Promise<{
+    tools: ("claude" | "codex" | "cursor")[];
+    written: string[];
+    conflicts: string[];
+    hints: {
+        codex: string;
+        claude: string;
+        cursor: string;
+    };
+    config: string;
+}>;

package/dist/install.js

@@ -0,0 +1,63 @@
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { z } from 'zod';
+import { Project } from './project.js';
+import { configSchema, defaultConfig } from './model.js';
+import { exists, within, write, writeYaml, digest } from './files.js';
+const resources = fileURLToPath(new URL('../kit/', import.meta.url));
+const names = ['releasekit-draft', 'releasekit-image', 'releasekit-translate', 'releasekit-review'];
+const managedSchema = z.record(z.string(), z.string().regex(/^[a-f0-9]{64}$/));
+export async function installSkills(project) {
+    const config = await project.config();
+    const marker = await project.content('managed-skills.json');
+    const managed = await exists(marker) ? managedSchema.parse(JSON.parse(await fs.readFile(marker, 'utf8'))) : {};
+    const roots = new Set(config.tools.map(tool => tool === 'claude' ? '.claude/skills' : '.agents/skills'));
+    const references = (await fs.readdir(path.join(resources, 'references'))).filter(file => file.endsWith('.md')).sort();
+    const written = [], conflicts = [];
+    for (const root of roots) {
+        for (const name of names) {
+            const sourceFiles = [
+                { source: path.join(resources, 'skills', name, 'SKILL.md'), destination: `${root}/${name}/SKILL.md` },
+                ...references.map(file => ({ source: path.join(resources, 'references', file), destination: `${root}/${name}/references/${file}` })),
+            ];
+            for (const item of sourceFiles) {
+                const content = await fs.readFile(item.source);
+                const expected = digest(content);
+                const destination = await within(project.root, item.destination);
+                if (await exists(destination)) {
+                    const actual = digest(await fs.readFile(destination));
+                    if (actual === expected) {
+                        managed[item.destination] = expected;
+                        continue;
+                    }
+                    if (actual !== managed[item.destination]) {
+                        conflicts.push(item.destination);
+                        continue;
+                    }
+                }
+                await write(destination, content);
+                managed[item.destination] = expected;
+                written.push(item.destination);
+            }
+        }
+    }
+    await write(marker, JSON.stringify(managed, null, 2) + '\n');
+    return { tools: config.tools, written, conflicts, hints: {
+            codex: 'Use $releasekit-draft, $releasekit-image, $releasekit-translate, or $releasekit-review.',
+            claude: 'Use /releasekit-draft, /releasekit-image, /releasekit-translate, or /releasekit-review.',
+            cursor: 'Use the installed releasekit-* skills from the agent skill picker or name them in your request.',
+        } };
+}
+export async function initProject(project, options) {
+    const file = await project.content('config.yaml');
+    if (await exists(file))
+        throw new Error('ReleaseKit is already initialized. Edit config.yaml for project settings or run update for skills.');
+    const config = defaultConfig(options.product ?? path.basename(project.root));
+    if (options.tools)
+        config.tools = [...new Set(options.tools)];
+    if (options.themes)
+        config.visuals.themes = options.themes;
+    await writeYaml(file, configSchema.parse(config));
+    return { config: file, ...await installSkills(project) };
+}

package/dist/model.d.ts

@@ -0,0 +1,318 @@
+import { z } from 'zod';
+export declare const segment: z.ZodString;
+export declare const sha: z.ZodString;
+export declare const locale: z.ZodString;
+export declare const theme: z.ZodEnum<{
+    dark: "dark";
+    light: "light";
+}>;
+export type Theme = z.infer<typeof theme>;
+export declare const paletteSchema: z.ZodObject<{
+    canvas: z.ZodString;
+    surface: z.ZodString;
+    raised: z.ZodString;
+    primary: z.ZodString;
+    secondary: z.ZodString;
+    divider: z.ZodString;
+}, z.core.$strict>;
+export declare const visualPolicySchema: z.ZodObject<{
+    themes: z.ZodEnum<{
+        both: "both";
+        dark: "dark";
+        light: "light";
+    }>;
+    preset: z.ZodLiteral<"quiet-product">;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    accent: z.ZodString;
+    dark: z.ZodObject<{
+        canvas: z.ZodString;
+        surface: z.ZodString;
+        raised: z.ZodString;
+        primary: z.ZodString;
+        secondary: z.ZodString;
+        divider: z.ZodString;
+    }, z.core.$strict>;
+    light: z.ZodObject<{
+        canvas: z.ZodString;
+        surface: z.ZodString;
+        raised: z.ZodString;
+        primary: z.ZodString;
+        secondary: z.ZodString;
+        divider: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type VisualPolicy = z.infer<typeof visualPolicySchema>;
+export declare const configSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    product: z.ZodString;
+    sourceLocale: z.ZodString;
+    locales: z.ZodArray<z.ZodString>;
+    history: z.ZodObject<{
+        limit: z.ZodNumber;
+    }, z.core.$strict>;
+    visuals: z.ZodObject<{
+        themes: z.ZodEnum<{
+            both: "both";
+            dark: "dark";
+            light: "light";
+        }>;
+        preset: z.ZodLiteral<"quiet-product">;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        accent: z.ZodString;
+        dark: z.ZodObject<{
+            canvas: z.ZodString;
+            surface: z.ZodString;
+            raised: z.ZodString;
+            primary: z.ZodString;
+            secondary: z.ZodString;
+            divider: z.ZodString;
+        }, z.core.$strict>;
+        light: z.ZodObject<{
+            canvas: z.ZodString;
+            surface: z.ZodString;
+            raised: z.ZodString;
+            primary: z.ZodString;
+            secondary: z.ZodString;
+            divider: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    tools: z.ZodArray<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        cursor: "cursor";
+    }>>;
+}, z.core.$strict>;
+export type ProjectConfig = z.infer<typeof configSchema>;
+export declare const sourceSchema: z.ZodObject<{
+    fromRef: z.ZodNullable<z.ZodString>;
+    fromSha: z.ZodNullable<z.ZodString>;
+    toRef: z.ZodString;
+    toSha: z.ZodString;
+}, z.core.$strict>;
+export declare const noteMetaSchema: z.ZodObject<{
+    id: z.ZodString;
+    category: z.ZodEnum<{
+        feature: "feature";
+        fix: "fix";
+        improvement: "improvement";
+        security: "security";
+    }>;
+    commits: z.ZodArray<z.ZodString>;
+    paths: z.ZodArray<z.ZodString>;
+    image: z.ZodBoolean;
+}, z.core.$strict>;
+export type NoteMeta = z.infer<typeof noteMetaSchema>;
+export declare const releaseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    version: z.ZodString;
+    releasedAt: z.ZodISODate;
+    previous: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        draft: "draft";
+        ready: "ready";
+    }>;
+    source: z.ZodObject<{
+        fromRef: z.ZodNullable<z.ZodString>;
+        fromSha: z.ZodNullable<z.ZodString>;
+        toRef: z.ZodString;
+        toSha: z.ZodString;
+    }, z.core.$strict>;
+    sourceLocale: z.ZodString;
+    locales: z.ZodArray<z.ZodString>;
+    visuals: z.ZodObject<{
+        themes: z.ZodEnum<{
+            both: "both";
+            dark: "dark";
+            light: "light";
+        }>;
+        preset: z.ZodLiteral<"quiet-product">;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        accent: z.ZodString;
+        dark: z.ZodObject<{
+            canvas: z.ZodString;
+            surface: z.ZodString;
+            raised: z.ZodString;
+            primary: z.ZodString;
+            secondary: z.ZodString;
+            divider: z.ZodString;
+        }, z.core.$strict>;
+        light: z.ZodObject<{
+            canvas: z.ZodString;
+            surface: z.ZodString;
+            raised: z.ZodString;
+            primary: z.ZodString;
+            secondary: z.ZodString;
+            divider: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    notes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodEnum<{
+            feature: "feature";
+            fix: "fix";
+            improvement: "improvement";
+            security: "security";
+        }>;
+        commits: z.ZodArray<z.ZodString>;
+        paths: z.ZodArray<z.ZodString>;
+        image: z.ZodBoolean;
+    }, z.core.$strict>>;
+    emptyReason: z.ZodNullable<z.ZodString>;
+    contentHash: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type Release = z.infer<typeof releaseSchema>;
+export declare const noteTextSchema: z.ZodObject<{
+    title: z.ZodString;
+    alt: z.ZodString;
+    sourceHash: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type NoteText = z.infer<typeof noteTextSchema> & {
+    body: string;
+};
+export declare const archetypeSchema: z.ZodEnum<{
+    "data-view": "data-view";
+    "device-view": "device-view";
+    "editorial-scene": "editorial-scene";
+    "icon-tile": "icon-tile";
+    "object-detail": "object-detail";
+    "spatial-view": "spatial-view";
+    "symbol-pair": "symbol-pair";
+    "ui-detail": "ui-detail";
+}>;
+export declare const sceneSchema: z.ZodObject<{
+    archetype: z.ZodEnum<{
+        "data-view": "data-view";
+        "device-view": "device-view";
+        "editorial-scene": "editorial-scene";
+        "icon-tile": "icon-tile";
+        "object-detail": "object-detail";
+        "spatial-view": "spatial-view";
+        "symbol-pair": "symbol-pair";
+        "ui-detail": "ui-detail";
+    }>;
+    subject: z.ZodString;
+    message: z.ZodString;
+    focus: z.ZodString;
+    composition: z.ZodString;
+    context: z.ZodString;
+    elements: z.ZodArray<z.ZodString>;
+    preserve: z.ZodArray<z.ZodString>;
+    avoid: z.ZodArray<z.ZodString>;
+    text: z.ZodArray<z.ZodString>;
+    references: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type Scene = z.infer<typeof sceneSchema>;
+export declare const assetSchema: z.ZodObject<{
+    file: z.ZodString;
+    sha256: z.ZodString;
+    sceneHash: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strict>;
+export declare const visualSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    scene: z.ZodObject<{
+        archetype: z.ZodEnum<{
+            "data-view": "data-view";
+            "device-view": "device-view";
+            "editorial-scene": "editorial-scene";
+            "icon-tile": "icon-tile";
+            "object-detail": "object-detail";
+            "spatial-view": "spatial-view";
+            "symbol-pair": "symbol-pair";
+            "ui-detail": "ui-detail";
+        }>;
+        subject: z.ZodString;
+        message: z.ZodString;
+        focus: z.ZodString;
+        composition: z.ZodString;
+        context: z.ZodString;
+        elements: z.ZodArray<z.ZodString>;
+        preserve: z.ZodArray<z.ZodString>;
+        avoid: z.ZodArray<z.ZodString>;
+        text: z.ZodArray<z.ZodString>;
+        references: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    variants: z.ZodObject<{
+        dark: z.ZodOptional<z.ZodObject<{
+            file: z.ZodString;
+            sha256: z.ZodString;
+            sceneHash: z.ZodString;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strict>>;
+        light: z.ZodOptional<z.ZodObject<{
+            file: z.ZodString;
+            sha256: z.ZodString;
+            sceneHash: z.ZodString;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type Visual = z.infer<typeof visualSchema>;
+export declare const evidenceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    source: z.ZodObject<{
+        fromRef: z.ZodNullable<z.ZodString>;
+        fromSha: z.ZodNullable<z.ZodString>;
+        toRef: z.ZodString;
+        toSha: z.ZodString;
+    }, z.core.$strict>;
+    commits: z.ZodArray<z.ZodObject<{
+        sha: z.ZodString;
+        subject: z.ZodString;
+    }, z.core.$strict>>;
+    files: z.ZodArray<z.ZodObject<{
+        status: z.ZodString;
+        path: z.ZodString;
+        oldPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Evidence = z.infer<typeof evidenceSchema>;
+export declare const bundleSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    currentVersion: z.ZodString;
+    locale: z.ZodString;
+    releases: z.ZodArray<z.ZodObject<{
+        version: z.ZodString;
+        releasedAt: z.ZodISODate;
+        previous: z.ZodNullable<z.ZodString>;
+        notes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            category: z.ZodEnum<{
+                feature: "feature";
+                fix: "fix";
+                improvement: "improvement";
+                security: "security";
+            }>;
+            title: z.ZodString;
+            bodyMarkdown: z.ZodString;
+            image: z.ZodNullable<z.ZodObject<{
+                alt: z.ZodString;
+                fallbackTheme: z.ZodEnum<{
+                    dark: "dark";
+                    light: "light";
+                }>;
+                variants: z.ZodObject<{
+                    dark: z.ZodOptional<z.ZodObject<{
+                        src: z.ZodString;
+                        width: z.ZodNumber;
+                        height: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    light: z.ZodOptional<z.ZodObject<{
+                        src: z.ZodString;
+                        width: z.ZodNumber;
+                        height: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Bundle = z.infer<typeof bundleSchema>;
+export declare function themes(policy: VisualPolicy): Theme[];
+export declare function defaultConfig(product: string): ProjectConfig;

package/dist/model.js

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+export const segment = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._+-]{0,95}$/);
+export const sha = z.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/);
+export const locale = z.string().regex(/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/);
+export const theme = z.enum(['dark', 'light']);
+const color = z.string().regex(/^#[a-fA-F0-9]{6}$/);
+export const paletteSchema = z.strictObject({
+    canvas: color, surface: color, raised: color, primary: color, secondary: color, divider: color,
+});
+export const visualPolicySchema = z.strictObject({
+    themes: z.enum(['both', 'dark', 'light']),
+    preset: z.literal('quiet-product'),
+    width: z.number().int().min(256).max(4096),
+    height: z.number().int().min(256).max(4096),
+    accent: color,
+    dark: paletteSchema,
+    light: paletteSchema,
+});
+export const configSchema = z.strictObject({
+    schemaVersion: z.literal(1), product: z.string().min(1),
+    sourceLocale: locale, locales: z.array(locale).min(1),
+    history: z.strictObject({ limit: z.number().int().min(1).max(100) }),
+    visuals: visualPolicySchema,
+    tools: z.array(z.enum(['codex', 'claude', 'cursor'])),
+});
+export const sourceSchema = z.strictObject({
+    fromRef: z.string().nullable(), fromSha: sha.nullable(), toRef: z.string(), toSha: sha,
+});
+export const noteMetaSchema = z.strictObject({
+    id: segment,
+    category: z.enum(['feature', 'improvement', 'fix', 'security']),
+    commits: z.array(sha), paths: z.array(z.string()), image: z.boolean(),
+});
+export const releaseSchema = z.strictObject({
+    schemaVersion: z.literal(1), version: segment, releasedAt: z.iso.date(),
+    previous: segment.nullable(), status: z.enum(['draft', 'ready']),
+    source: sourceSchema, sourceLocale: locale, locales: z.array(locale).min(1),
+    visuals: visualPolicySchema, notes: z.array(noteMetaSchema),
+    emptyReason: z.string().nullable(), contentHash: z.string().nullable(),
+});
+export const noteTextSchema = z.strictObject({
+    title: z.string().min(1), alt: z.string(), sourceHash: z.string().nullable(),
+});
+export const archetypeSchema = z.enum([
+    'icon-tile', 'symbol-pair', 'ui-detail', 'device-view', 'object-detail',
+    'spatial-view', 'data-view', 'editorial-scene',
+]);
+export const sceneSchema = z.strictObject({
+    archetype: archetypeSchema,
+    subject: z.string().min(1), message: z.string().min(1),
+    focus: z.string().min(1), composition: z.string().min(1),
+    context: z.string(), elements: z.array(z.string()),
+    preserve: z.array(z.string()), avoid: z.array(z.string()),
+    text: z.array(z.string()), references: z.array(z.string()),
+});
+export const assetSchema = z.strictObject({
+    file: z.string().min(1), sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    sceneHash: z.string().regex(/^[a-f0-9]{64}$/),
+    width: z.number().int().positive(), height: z.number().int().positive(),
+});
+export const visualSchema = z.strictObject({
+    schemaVersion: z.literal(1), scene: sceneSchema,
+    variants: z.strictObject({ dark: assetSchema.optional(), light: assetSchema.optional() }),
+});
+export const evidenceSchema = z.strictObject({
+    schemaVersion: z.literal(1), source: sourceSchema,
+    commits: z.array(z.strictObject({ sha, subject: z.string() })),
+    files: z.array(z.strictObject({ status: z.string(), path: z.string(), oldPath: z.string().optional() })),
+});
+const exportedImage = z.strictObject({
+    src: z.string(), width: z.number().int().positive(), height: z.number().int().positive(),
+});
+export const bundleSchema = z.strictObject({
+    schemaVersion: z.literal(1), currentVersion: segment, locale,
+    releases: z.array(z.strictObject({
+        version: segment, releasedAt: z.iso.date(), previous: segment.nullable(),
+        notes: z.array(z.strictObject({
+            id: segment, category: noteMetaSchema.shape.category, title: z.string(), bodyMarkdown: z.string(),
+            image: z.strictObject({
+                alt: z.string(), fallbackTheme: theme,
+                variants: z.strictObject({ dark: exportedImage.optional(), light: exportedImage.optional() }),
+            }).nullable(),
+        })),
+    })),
+});
+export function themes(policy) {
+    return policy.themes === 'both' ? ['dark', 'light'] : [policy.themes];
+}
+export function defaultConfig(product) {
+    return {
+        schemaVersion: 1, product, sourceLocale: 'ko-KR', locales: ['ko-KR', 'en-US'],
+        history: { limit: 3 }, tools: ['codex', 'claude', 'cursor'],
+        visuals: {
+            themes: 'both', preset: 'quiet-product', width: 1280, height: 800, accent: '#4678ED',
+            dark: { canvas: '#242527', surface: '#18191B', raised: '#343638', primary: '#B9BBBE', secondary: '#777B80', divider: '#46494D' },
+            light: { canvas: '#F7F8FA', surface: '#FFFFFF', raised: '#ECEEF1', primary: '#494D52', secondary: '#969BA2', divider: '#DDE0E5' },
+        },
+    };
+}

package/dist/project.d.ts

@@ -0,0 +1,25 @@
+import { type ProjectConfig, type Release, type Evidence } from './model.js';
+export declare class Project {
+    readonly root: string;
+    constructor(root: string);
+    static find(cwd: string): Project;
+    content(relative: string): Promise<string>;
+    config(): Promise<ProjectConfig>;
+    releaseDir(version: string): Promise<string>;
+    releaseFile(version: string, relative: string): Promise<string>;
+    release(version: string): Promise<Release>;
+    save(release: Release): Promise<void>;
+    versions(): Promise<string[]>;
+    evidence(version: string): Promise<Evidence>;
+    history(version: string, limit: number): Promise<Release[]>;
+}
+export declare function editable(release: Release): void;
+export interface PrepareOptions {
+    from?: string;
+    to?: string;
+    previous?: string;
+    fromRoot?: boolean;
+    firstRelease?: boolean;
+    date?: string;
+}
+export declare function prepare(project: Project, version: string, options: PrepareOptions): Promise<Release>;