@ekrist1/vulse 0.1.6-alpha.3

package/dist/cli/setup.js

@@ -0,0 +1,254 @@
+import { readFile, writeFile, access } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { execSync } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+import { patchWranglerToml } from '../integration/wrangler-patch.js';
+import { runMigrate } from './migrate.js';
+import { runSeedAdmin } from './seed-admin.js';
+const DEV_VARS_FILE = '.dev.vars';
+const WRANGLER_FILE = 'wrangler.toml';
+const GITIGNORE_FILE = '.gitignore';
+const PLACEHOLDER_DB_ID = 'TODO_PASTE_ID_FROM_WRANGLER_OUTPUT';
+const PLACEHOLDER_AUTH_SECRET = 'dev-secret-change-me-in-production-32chars';
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readIfExists(path) {
+    return (await fileExists(path)) ? readFile(path, 'utf8') : '';
+}
+/** 32 random bytes → 64-char hex string. Suitable for BETTER_AUTH_SECRET. */
+export function generateSecret() {
+    return randomBytes(32).toString('hex');
+}
+/**
+ * Set the D1 `database_id` in wrangler.toml. Replaces the placeholder if
+ * present; otherwise replaces the existing id under the `# vulse:d1` block.
+ * Idempotent: writing the same id twice yields the same output.
+ */
+export function setDatabaseId(toml, id) {
+    if (toml.includes(`database_id = "${id}"`))
+        return toml;
+    if (toml.includes(PLACEHOLDER_DB_ID)) {
+        return toml.replace(PLACEHOLDER_DB_ID, id);
+    }
+    return toml.replace(/database_id = "[^"]*"/, `database_id = "${id}"`);
+}
+/**
+ * Set/replace KEY=VALUE entries in a `.dev.vars`-style file. Existing entries
+ * for the same key are replaced in place; unknown keys are appended. Values
+ * are written as `KEY="value"` (double-quoted) to handle special chars safely.
+ * Pre-existing keys not in `vars` are left untouched.
+ */
+export function applyDevVars(existing, vars) {
+    let out = existing;
+    const trailingNewline = out.length === 0 || out.endsWith('\n');
+    if (!trailingNewline)
+        out += '\n';
+    for (const [key, value] of Object.entries(vars)) {
+        const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        const line = `${key}="${escaped}"`;
+        const re = new RegExp(`^${key}\\s*=.*$`, 'm');
+        if (re.test(out)) {
+            out = out.replace(re, line);
+        }
+        else {
+            out += `${line}\n`;
+        }
+    }
+    return out;
+}
+/** Ensure `.dev.vars` (and `.dev.vars.*`) appear in .gitignore. */
+export function ensureGitignored(existing, entry = '.dev.vars') {
+    const lines = existing.split('\n').map((l) => l.trim());
+    if (lines.includes(entry))
+        return existing;
+    const sep = existing.length === 0 || existing.endsWith('\n') ? '' : '\n';
+    return `${existing}${sep}${entry}\n`;
+}
+function createPrompter(autoYes) {
+    const rl = autoYes ? null : createInterface({ input: stdin, output: stdout });
+    return {
+        async ask(question, defaultValue) {
+            if (autoYes)
+                return defaultValue ?? '';
+            const suffix = defaultValue ? ` [${defaultValue}]` : '';
+            const answer = (await rl.question(`${question}${suffix}: `)).trim();
+            return answer || (defaultValue ?? '');
+        },
+        async confirm(question, defaultYes) {
+            if (autoYes)
+                return true;
+            const suffix = defaultYes ? ' [Y/n]' : ' [y/N]';
+            const answer = (await rl.question(`${question}${suffix} `)).trim().toLowerCase();
+            if (!answer)
+                return defaultYes;
+            return answer === 'y' || answer === 'yes';
+        },
+        close() { rl?.close(); },
+    };
+}
+function tryRun(cmd) {
+    try {
+        const output = execSync(cmd, { encoding: 'utf8', stdio: ['inherit', 'pipe', 'pipe'] });
+        return { ok: true, output };
+    }
+    catch (err) {
+        const e = err;
+        const stderr = typeof e.stderr === 'string' ? e.stderr : e.stderr?.toString() ?? '';
+        return { ok: false, error: stderr || e.message };
+    }
+}
+/** Pull a database_id out of `wrangler d1 create` JSON-ish output. */
+export function parseDatabaseId(output) {
+    const m = output.match(/database_id\s*=?\s*"?([0-9a-f-]{20,})"?/i);
+    return m ? m[1] : null;
+}
+export async function runSetup(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const prompter = createPrompter(!!opts.yes);
+    try {
+        stdout.write(`\nVulse setup — local development\n\n`);
+        stdout.write(`This wizard will update:\n`);
+        stdout.write(`  • ${WRANGLER_FILE}   (D1 + R2 bindings)\n`);
+        stdout.write(`  • ${DEV_VARS_FILE}    (local secrets — gitignored)\n`);
+        stdout.write(`  • ${GITIGNORE_FILE}    (adds ${DEV_VARS_FILE})\n\n`);
+        if (!(await prompter.confirm('Continue?', true))) {
+            stdout.write('Aborted.\n');
+            return;
+        }
+        // --- Step 1: D1 ---
+        stdout.write(`\nStep 1/3 — Cloudflare D1 (database)\n`);
+        const wranglerPath = join(cwd, WRANGLER_FILE);
+        let wranglerToml = await readIfExists(wranglerPath);
+        const d1Name = await prompter.ask('  D1 database name', 'vulse-db');
+        wranglerToml = patchWranglerToml(wranglerToml, { d1Name, r2Bucket: 'vulse-media' });
+        let databaseId = await prompter.ask('  D1 database_id (leave blank to create one now)', '');
+        if (!databaseId) {
+            if (await prompter.confirm(`  Run \`wrangler d1 create ${d1Name}\`?`, true)) {
+                const result = tryRun(`wrangler d1 create ${d1Name}`);
+                if (result.ok) {
+                    databaseId = parseDatabaseId(result.output) ?? '';
+                    if (databaseId) {
+                        stdout.write(`  ✓ database_id: ${databaseId}\n`);
+                    }
+                    else {
+                        stdout.write(`  ! Could not parse database_id from wrangler output.\n`);
+                        stdout.write(result.output);
+                        databaseId = await prompter.ask('  Paste the database_id', '');
+                    }
+                }
+                else {
+                    stdout.write(`  ! \`wrangler d1 create\` failed: ${result.error.trim()}\n`);
+                    databaseId = await prompter.ask('  Paste an existing database_id, or press Enter to leave the placeholder', '');
+                }
+            }
+        }
+        if (databaseId)
+            wranglerToml = setDatabaseId(wranglerToml, databaseId);
+        // --- Step 2: R2 ---
+        stdout.write(`\nStep 2/3 — Cloudflare R2 (media storage)\n`);
+        const r2Bucket = await prompter.ask('  R2 bucket name', 'vulse-media');
+        wranglerToml = patchWranglerToml(wranglerToml, { d1Name, r2Bucket });
+        if (await prompter.confirm(`  Run \`wrangler r2 bucket create ${r2Bucket}\`?`, true)) {
+            const result = tryRun(`wrangler r2 bucket create ${r2Bucket}`);
+            if (result.ok) {
+                stdout.write(`  ✓ bucket created\n`);
+            }
+            else if (/already exists/i.test(result.error)) {
+                stdout.write(`  ✓ bucket already exists — using it\n`);
+            }
+            else {
+                stdout.write(`  ! \`wrangler r2 bucket create\` failed: ${result.error.trim()}\n`);
+                stdout.write(`    Continuing — you can create it later.\n`);
+            }
+        }
+        await writeFile(wranglerPath, wranglerToml, 'utf8');
+        stdout.write(`  ✓ wrote ${WRANGLER_FILE}\n`);
+        // --- Step 3: Secrets + .dev.vars ---
+        stdout.write(`\nStep 3/3 — Secrets\n`);
+        const devVarsPath = join(cwd, DEV_VARS_FILE);
+        const existingDevVars = await readIfExists(devVarsPath);
+        const newVars = {};
+        if (!/^BETTER_AUTH_SECRET\s*=/m.test(existingDevVars)) {
+            newVars.BETTER_AUTH_SECRET = generateSecret();
+            stdout.write(`  ✓ generated BETTER_AUTH_SECRET\n`);
+        }
+        else {
+            stdout.write(`  ✓ BETTER_AUTH_SECRET already set — keeping it\n`);
+        }
+        if (!/^VULSE_PREVIEW_SECRET\s*=/m.test(existingDevVars)) {
+            newVars.VULSE_PREVIEW_SECRET = generateSecret();
+            stdout.write(`  ✓ generated VULSE_PREVIEW_SECRET\n`);
+        }
+        else {
+            stdout.write(`  ✓ VULSE_PREVIEW_SECRET already set — keeping it\n`);
+        }
+        if (Object.keys(newVars).length > 0) {
+            const updated = applyDevVars(existingDevVars, newVars);
+            await writeFile(devVarsPath, updated, 'utf8');
+            stdout.write(`  ✓ wrote ${DEV_VARS_FILE}\n`);
+        }
+        // Warn if wrangler.toml still has the placeholder BETTER_AUTH_SECRET — .dev.vars
+        // overrides it in dev, but the placeholder is misleading.
+        if (wranglerToml.includes(PLACEHOLDER_AUTH_SECRET)) {
+            stdout.write(`  ℹ ${WRANGLER_FILE} still contains the placeholder BETTER_AUTH_SECRET in [vars].\n` +
+                `    ${DEV_VARS_FILE} takes precedence in dev — you can remove the [vars] line.\n`);
+        }
+        // .gitignore
+        const gitignorePath = join(cwd, GITIGNORE_FILE);
+        const existingGitignore = await readIfExists(gitignorePath);
+        const updatedGitignore = ensureGitignored(existingGitignore);
+        if (updatedGitignore !== existingGitignore) {
+            await writeFile(gitignorePath, updatedGitignore, 'utf8');
+            stdout.write(`  ✓ added ${DEV_VARS_FILE} to ${GITIGNORE_FILE}\n`);
+        }
+        // --- Migrate ---
+        if (!opts.skipMigrate && databaseId) {
+            stdout.write(`\nApplying migrations…\n`);
+            try {
+                await runMigrate({ remote: false });
+            }
+            catch (err) {
+                stdout.write(`  ! migrate failed: ${err.message}\n`);
+                stdout.write(`    Run \`npx vulse migrate\` manually once D1 is reachable.\n`);
+            }
+        }
+        else if (!databaseId) {
+            stdout.write(`\nSkipping migrations — no database_id set yet.\n`);
+            stdout.write(`Paste the id into ${WRANGLER_FILE}, then run: npx vulse migrate\n`);
+        }
+        // --- Seed admin ---
+        if (!opts.skipSeed && databaseId) {
+            stdout.write(`\nFirst admin user\n`);
+            const email = opts.email ?? (await prompter.ask('  Admin email (blank to skip)', ''));
+            if (email) {
+                try {
+                    await runSeedAdmin({
+                        email,
+                        remote: false,
+                        ...(opts.password !== undefined ? { password: opts.password } : {}),
+                    });
+                }
+                catch (err) {
+                    stdout.write(`  ! seed:admin failed: ${err.message}\n`);
+                    stdout.write(`    Run \`npx vulse seed:admin --email ${email}\` manually.\n`);
+                }
+            }
+            else {
+                stdout.write(`  Skipped — create one later with: npx vulse seed:admin --email you@example.com\n`);
+            }
+        }
+        stdout.write(`\nDone. Start your dev server and open /admin/login.\n\n`);
+    }
+    finally {
+        prompter.close();
+    }
+}

package/dist/core/access.d.ts

@@ -0,0 +1,5 @@
+import type { Blueprint, AccessArgs } from './blueprints/types.js';
+type Action = 'read' | 'create' | 'update' | 'delete';
+export declare function evaluate(bp: Blueprint, action: Action, args: AccessArgs): Promise<boolean>;
+export {};
+//# sourceMappingURL=access.d.ts.map

package/dist/core/access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../../src/core/access.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAElE,KAAK,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAErD,wBAAsB,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAIhG"}

package/dist/core/access.js

@@ -0,0 +1,6 @@
+export async function evaluate(bp, action, args) {
+    const fn = bp.access?.[action];
+    if (fn)
+        return Boolean(await fn(args));
+    return args.user?.role === 'admin';
+}

package/dist/core/blocks/schema.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'astro/zod';
+export declare const headingBlock: z.ZodObject<{
+    type: z.ZodLiteral<"heading">;
+    level: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>;
+    text: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const paragraphBlock: z.ZodObject<{
+    type: z.ZodLiteral<"paragraph">;
+    text: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const imageBlock: z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    mediaId: z.ZodString;
+    alt: z.ZodDefault<z.ZodString>;
+    caption: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const codeBlock: z.ZodObject<{
+    type: z.ZodLiteral<"code">;
+    language: z.ZodString;
+    code: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const embedBlock: z.ZodObject<{
+    type: z.ZodLiteral<"embed">;
+    url: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const quoteBlock: z.ZodObject<{
+    type: z.ZodLiteral<"quote">;
+    text: z.ZodString;
+    cite: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listBlock: z.ZodObject<{
+    type: z.ZodLiteral<"list">;
+    ordered: z.ZodDefault<z.ZodBoolean>;
+    items: z.ZodArray<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const blockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"heading">;
+    level: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>;
+    text: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"paragraph">;
+    text: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    mediaId: z.ZodString;
+    alt: z.ZodDefault<z.ZodString>;
+    caption: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"code">;
+    language: z.ZodString;
+    code: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"embed">;
+    url: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"quote">;
+    text: z.ZodString;
+    cite: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"list">;
+    ordered: z.ZodDefault<z.ZodBoolean>;
+    items: z.ZodArray<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type Block = z.infer<typeof blockSchema>;
+export type BlockType = Block['type'];
+export declare const BUILT_IN_BLOCK_TYPES: BlockType[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/core/blocks/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/core/blocks/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAA;AAE7B,eAAO,MAAM,YAAY;;;;;iBAKvB,CAAA;AAEF,eAAO,MAAM,cAAc;;;;iBAIzB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;;iBAMrB,CAAA;AAEF,eAAO,MAAM,SAAS;;;;;iBAKpB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;iBAIrB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;iBAKrB,CAAA;AAEF,eAAO,MAAM,SAAS;;;;;iBAKpB,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAQtB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAC/C,MAAM,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC,CAAA;AAErC,eAAO,MAAM,oBAAoB,EAAE,SAAS,EAE3C,CAAA"}

package/dist/core/blocks/schema.js

@@ -0,0 +1,54 @@
+import { z } from 'astro/zod';
+export const headingBlock = z.object({
+    type: z.literal('heading'),
+    level: z.union([z.literal(1), z.literal(2), z.literal(3), z.literal(4)]),
+    text: z.string(),
+    id: z.string().optional(),
+});
+export const paragraphBlock = z.object({
+    type: z.literal('paragraph'),
+    text: z.string(),
+    id: z.string().optional(),
+});
+export const imageBlock = z.object({
+    type: z.literal('image'),
+    mediaId: z.string(),
+    alt: z.string().default(''),
+    caption: z.string().optional(),
+    id: z.string().optional(),
+});
+export const codeBlock = z.object({
+    type: z.literal('code'),
+    language: z.string(),
+    code: z.string(),
+    id: z.string().optional(),
+});
+export const embedBlock = z.object({
+    type: z.literal('embed'),
+    url: z.string().url(),
+    id: z.string().optional(),
+});
+export const quoteBlock = z.object({
+    type: z.literal('quote'),
+    text: z.string(),
+    cite: z.string().optional(),
+    id: z.string().optional(),
+});
+export const listBlock = z.object({
+    type: z.literal('list'),
+    ordered: z.boolean().default(false),
+    items: z.array(z.string()),
+    id: z.string().optional(),
+});
+export const blockSchema = z.discriminatedUnion('type', [
+    headingBlock,
+    paragraphBlock,
+    imageBlock,
+    codeBlock,
+    embedBlock,
+    quoteBlock,
+    listBlock,
+]);
+export const BUILT_IN_BLOCK_TYPES = [
+    'heading', 'paragraph', 'image', 'code', 'embed', 'quote', 'list',
+];

package/dist/core/blueprints/code-to-definition.d.ts

@@ -0,0 +1,6 @@
+import type { FieldDescriptor } from './reflect-fields.js';
+import type { Blueprint } from './types.js';
+import type { BlueprintDefinition, NestedFieldDefinition } from './definition.js';
+export declare function blueprintToDefinition(bp: Blueprint): BlueprintDefinition;
+export declare function nestedFieldToDescriptor(f: NestedFieldDefinition): FieldDescriptor;
+//# sourceMappingURL=code-to-definition.d.ts.map

package/dist/core/blueprints/code-to-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-to-definition.d.ts","sourceRoot":"","sources":["../../../src/core/blueprints/code-to-definition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,KAAK,EAAE,mBAAmB,EAA4B,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAI3G,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,SAAS,GAAG,mBAAmB,CAmBxE;AA8ED,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,qBAAqB,GAAG,eAAe,CAmDjF"}

package/dist/core/blueprints/code-to-definition.js

@@ -0,0 +1,147 @@
+import { defaultPreviewPath } from './preview-path.js';
+import { reflectFields } from './reflect-fields.js';
+export function blueprintToDefinition(bp) {
+    const fields = reflectFields(bp.schema).map((fd) => descriptorToField(fd));
+    const previewPath = bp.preview?.path ?? defaultPreviewPath(bp.name);
+    return {
+        handle: bp.name,
+        label: bp.label,
+        singleton: bp.singleton ?? false,
+        ...(bp.seo ? { seo: true } : {}),
+        ...(bp.drafts ? { drafts: true } : {}),
+        ...(bp.tree ? { tree: true } : {}),
+        ...(bp.maxDepth !== undefined ? { maxDepth: bp.maxDepth } : {}),
+        ...(bp.admin.seoMapping ? { seoMapping: bp.admin.seoMapping } : {}),
+        preview: {
+            path: previewPath,
+            ...(bp.preview?.rootSelector ? { rootSelector: bp.preview.rootSelector } : {}),
+            ...(bp.preview?.live === false ? { live: false } : {}),
+        },
+        fields,
+    };
+}
+function descriptorToField(fd) {
+    const ui = widgetToUi(fd);
+    return {
+        name: fd.path,
+        label: fd.path,
+        ui,
+        optional: !fd.required,
+    };
+}
+function widgetToUi(fd) {
+    switch (fd.widget) {
+        case 'textarea':
+            return { kind: 'textarea' };
+        case 'bool':
+            return { kind: 'boolean' };
+        case 'date':
+            return { kind: 'date' };
+        case 'enum':
+            return {
+                kind: 'select',
+                options: fd.selectOptions ?? fd.options?.map((o) => o) ?? [''],
+                ...(fd.selectMultiple ? { multiple: true } : {}),
+                ...(fd.selectPlaceholder ? { placeholder: fd.selectPlaceholder } : {}),
+                ...(fd.selectClearable ? { clearable: true } : {}),
+            };
+        case 'ref':
+            return { kind: 'relationship', to: fd.refTarget ?? 'unknown' };
+        case 'entry':
+            return { kind: 'entry', collections: fd.entryCollections ?? ['unknown'] };
+        case 'entries':
+            return {
+                kind: 'entries',
+                collections: fd.entriesCollections ?? ['unknown'],
+                ...(fd.entriesMax !== undefined ? { max: fd.entriesMax } : {}),
+            };
+        case 'link':
+            return {
+                kind: 'link',
+                ...(fd.linkCollections?.length ? { collections: fd.linkCollections } : {}),
+            };
+        case 'media':
+            return { kind: 'asset' };
+        case 'blocks': {
+            const sets = parseBlocksSets(fd.description);
+            return sets.length ? { kind: 'blocks', sets } : { kind: 'blocks' };
+        }
+        case 'grid':
+            return {
+                kind: 'grid',
+                fields: (fd.itemFields ?? []).map(descriptorToNestedField),
+                ...(fd.gridMode !== undefined ? { mode: fd.gridMode } : {}),
+                ...(fd.gridMinRows !== undefined ? { minRows: fd.gridMinRows } : {}),
+                ...(fd.gridMaxRows !== undefined ? { maxRows: fd.gridMaxRows } : {}),
+                ...(fd.gridAddLabel !== undefined ? { addLabel: fd.gridAddLabel } : {}),
+            };
+        default:
+            return { kind: 'text' };
+    }
+}
+function descriptorToNestedField(fd) {
+    const ui = widgetToUi(fd);
+    return {
+        name: fd.path,
+        label: fd.label,
+        ui,
+        optional: !fd.required,
+    };
+}
+function parseBlocksSets(description) {
+    if (!description?.startsWith('vulse:blocks:'))
+        return [];
+    return description.slice('vulse:blocks:'.length).split(',').filter(Boolean);
+}
+export function nestedFieldToDescriptor(f) {
+    const ui = f.ui;
+    const base = { path: f.name, required: !f.optional, label: f.label ?? f.name };
+    switch (ui.kind) {
+        case 'textarea':
+            return { ...base, widget: 'textarea' };
+        case 'boolean':
+            return { ...base, widget: 'bool' };
+        case 'date':
+            return { ...base, widget: 'date' };
+        case 'select':
+            return {
+                ...base,
+                widget: 'enum',
+                options: ui.options.map((o) => (typeof o === 'string' ? o : o.key)),
+                selectOptions: ui.options.map((o) => (typeof o === 'string' ? { key: o, label: o } : o)),
+                ...(ui.multiple !== undefined ? { selectMultiple: ui.multiple } : {}),
+                ...(ui.placeholder !== undefined ? { selectPlaceholder: ui.placeholder } : {}),
+                ...(ui.clearable !== undefined ? { selectClearable: ui.clearable } : {}),
+            };
+        case 'relationship':
+            return { ...base, widget: 'ref', refTarget: ui.to };
+        case 'entry':
+            return { ...base, widget: 'entry', entryCollections: ui.collections };
+        case 'entries':
+            return {
+                ...base,
+                widget: 'entries',
+                entriesCollections: ui.collections,
+                ...(ui.max !== undefined ? { entriesMax: ui.max } : {}),
+            };
+        case 'link':
+            return {
+                ...base,
+                widget: 'link',
+                ...(ui.collections !== undefined ? { linkCollections: ui.collections } : {}),
+            };
+        case 'asset':
+            return { ...base, widget: 'media' };
+        case 'blocks': {
+            const tag = ui.sets?.length ? `vulse:blocks:${ui.sets.join(',')}` : 'vulse:blocks';
+            return {
+                ...base,
+                widget: 'blocks',
+                description: tag,
+                ...(ui.sets?.length ? { blocksSets: ui.sets } : {}),
+            };
+        }
+        default:
+            return { ...base, widget: 'text' };
+    }
+}

package/dist/core/blueprints/compile.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'astro/zod';
+import type { CompiledSet } from '../sets/compile.js';
+import type { BlueprintDefinition, NestedFieldDefinition } from './definition.js';
+export interface CompileBlueprintOptions {
+    sets?: Map<string, CompiledSet>;
+}
+export declare function compileBlueprintSchema(def: BlueprintDefinition, options?: CompileBlueprintOptions): z.ZodObject<z.ZodRawShape>;
+export declare function compileFieldObject(fields: NestedFieldDefinition[]): z.ZodObject<z.ZodRawShape>;
+export declare function hashDefinition(def: BlueprintDefinition): string;
+//# sourceMappingURL=compile.d.ts.map

package/dist/core/blueprints/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/core/blueprints/compile.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAA;AAC7B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAErD,OAAO,KAAK,EACV,mBAAmB,EAEnB,qBAAqB,EAEtB,MAAM,iBAAiB,CAAA;AAKxB,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;CAChC;AAED,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,mBAAmB,EACxB,OAAO,GAAE,uBAA4B,GACpC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAS5B;AAqHD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAM9F;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,mBAAmB,GAAG,MAAM,CAoB/D"}