@ekrist1/vulse 0.1.6-alpha.3

package/dist/core/globals/compile.js

@@ -0,0 +1,17 @@
+import { compileBlueprintSchema } from '../blueprints/compile.js';
+import { hashGlobalSetDefinition } from './definition.js';
+export function compileGlobalSet(def, sets) {
+    const options = sets ? { sets } : {};
+    return {
+        handle: def.handle,
+        label: def.label,
+        fields: def.fields,
+        schema: compileBlueprintSchema({
+            handle: def.handle,
+            label: def.label,
+            singleton: true,
+            fields: def.fields,
+        }, options),
+        hash: hashGlobalSetDefinition(def),
+    };
+}

package/dist/core/globals/definition.d.ts

@@ -0,0 +1,161 @@
+import { z } from 'astro/zod';
+export declare const GlobalSetDefinitionSchema: z.ZodObject<{
+    handle: z.ZodString;
+    label: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        ui: z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"textarea">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"blocks">;
+            sets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"date">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"boolean">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"select">;
+            options: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>]>>;
+            multiple: z.ZodOptional<z.ZodBoolean>;
+            placeholder: z.ZodOptional<z.ZodString>;
+            clearable: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"relationship">;
+            to: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"entry">;
+            collections: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"entries">;
+            collections: z.ZodArray<z.ZodString>;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"link">;
+            collections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"asset">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"replicator">;
+            sets: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                fields: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    label: z.ZodOptional<z.ZodString>;
+                    ui: z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
+                        kind: z.ZodLiteral<"text">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"textarea">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"blocks">;
+                        sets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"date">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"boolean">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"select">;
+                        options: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            key: z.ZodString;
+                            label: z.ZodString;
+                        }, z.core.$strip>]>>;
+                        multiple: z.ZodOptional<z.ZodBoolean>;
+                        placeholder: z.ZodOptional<z.ZodString>;
+                        clearable: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"relationship">;
+                        to: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"entry">;
+                        collections: z.ZodArray<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"entries">;
+                        collections: z.ZodArray<z.ZodString>;
+                        max: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"link">;
+                        collections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"asset">;
+                    }, z.core.$strip>], "kind">;
+                    optional: z.ZodBoolean;
+                    default: z.ZodOptional<z.ZodUnknown>;
+                    validation: z.ZodOptional<z.ZodObject<{
+                        min: z.ZodOptional<z.ZodNumber>;
+                        max: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"grid">;
+            fields: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                ui: z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"text">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"textarea">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"blocks">;
+                    sets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"date">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"boolean">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"select">;
+                    options: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        key: z.ZodString;
+                        label: z.ZodString;
+                    }, z.core.$strip>]>>;
+                    multiple: z.ZodOptional<z.ZodBoolean>;
+                    placeholder: z.ZodOptional<z.ZodString>;
+                    clearable: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"relationship">;
+                    to: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"entry">;
+                    collections: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"entries">;
+                    collections: z.ZodArray<z.ZodString>;
+                    max: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"link">;
+                    collections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"asset">;
+                }, z.core.$strip>], "kind">;
+                optional: z.ZodBoolean;
+                default: z.ZodOptional<z.ZodUnknown>;
+                validation: z.ZodOptional<z.ZodObject<{
+                    min: z.ZodOptional<z.ZodNumber>;
+                    max: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            minRows: z.ZodOptional<z.ZodNumber>;
+            maxRows: z.ZodOptional<z.ZodNumber>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                table: "table";
+                stacked: "stacked";
+            }>>;
+            addLabel: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "kind">;
+        optional: z.ZodBoolean;
+        default: z.ZodOptional<z.ZodUnknown>;
+        validation: z.ZodOptional<z.ZodObject<{
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type GlobalSetDefinition = z.infer<typeof GlobalSetDefinitionSchema>;
+export declare function hashGlobalSetDefinition(def: GlobalSetDefinition): string;
+//# sourceMappingURL=definition.d.ts.map

package/dist/core/globals/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/core/globals/definition.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAA;AAG7B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,mBAAmB,GAAG,MAAM,CAcxE"}

package/dist/core/globals/definition.js

@@ -0,0 +1,23 @@
+import { createHash } from 'node:crypto';
+import { z } from 'astro/zod';
+import { FieldDefinitionSchema } from '../blueprints/definition.js';
+export const GlobalSetDefinitionSchema = z.object({
+    handle: z.string().regex(/^[a-z][a-z0-9_-]*$/),
+    label: z.string().min(1),
+    fields: z.array(FieldDefinitionSchema).default([]),
+});
+export function hashGlobalSetDefinition(def) {
+    const canonical = JSON.stringify({
+        handle: def.handle,
+        label: def.label,
+        fields: def.fields.map((f) => ({
+            name: f.name,
+            label: f.label ?? null,
+            ui: f.ui,
+            optional: f.optional,
+            default: f.default ?? null,
+            validation: f.validation ?? null,
+        })),
+    });
+    return createHash('sha256').update(canonical).digest('hex');
+}

package/dist/core/locales.d.ts

@@ -0,0 +1,14 @@
+import type { VulseDb } from './db.js';
+export declare const LOCALES_KEY = "locales";
+export declare const DEFAULT_LOCALE_KEY = "defaultLocale";
+export interface LocalesConfig {
+    /** Ordered list of locales supported by the site. Always contains defaultLocale. */
+    locales: string[];
+    /** The locale used when none is specified. */
+    defaultLocale: string;
+}
+export declare function isValidLocaleCode(code: string): boolean;
+export declare function readLocalesConfig(db: VulseDb): Promise<LocalesConfig>;
+/** Validate a locale param against site configuration; throws if unknown. */
+export declare function resolveLocale(db: VulseDb, candidate: string | null | undefined): Promise<string>;
+//# sourceMappingURL=locales.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../src/core/locales.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAItC,eAAO,MAAM,WAAW,YAAY,CAAA;AACpC,eAAO,MAAM,kBAAkB,kBAAkB,CAAA;AAKjD,MAAM,WAAW,aAAa;IAC5B,oFAAoF;IACpF,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,8CAA8C;IAC9C,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAa3E;AAED,6EAA6E;AAC7E,wBAAsB,aAAa,CAAC,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAOtG"}

package/dist/core/locales.js

@@ -0,0 +1,35 @@
+import { SettingsRepo } from './repos/settings.js';
+import { DEFAULT_LOCALE } from './repos/entries.js';
+export const LOCALES_KEY = 'locales';
+export const DEFAULT_LOCALE_KEY = 'defaultLocale';
+// BCP-47-ish: 2-3 letter base + optional region. Conservative, easy to extend later.
+const LOCALE_CODE_RE = /^[a-z]{2,3}(-[A-Z]{2})?$/;
+export function isValidLocaleCode(code) {
+    return code === DEFAULT_LOCALE || LOCALE_CODE_RE.test(code);
+}
+export async function readLocalesConfig(db) {
+    const repo = new SettingsRepo(db);
+    const [raw, def] = await Promise.all([
+        repo.get(LOCALES_KEY),
+        repo.get(DEFAULT_LOCALE_KEY),
+    ]);
+    const locales = Array.isArray(raw)
+        ? raw.filter((v) => typeof v === 'string' && isValidLocaleCode(v))
+        : [];
+    const defaultLocale = typeof def === 'string' && isValidLocaleCode(def) ? def : DEFAULT_LOCALE;
+    if (locales.length === 0)
+        locales.push(defaultLocale);
+    if (!locales.includes(defaultLocale))
+        locales.unshift(defaultLocale);
+    return { locales, defaultLocale };
+}
+/** Validate a locale param against site configuration; throws if unknown. */
+export async function resolveLocale(db, candidate) {
+    const cfg = await readLocalesConfig(db);
+    if (!candidate || candidate === DEFAULT_LOCALE)
+        return cfg.defaultLocale;
+    if (!cfg.locales.includes(candidate)) {
+        throw new Error(`Unknown locale '${candidate}'. Supported: ${cfg.locales.join(', ')}`);
+    }
+    return candidate;
+}

package/dist/core/migrations.d.ts

@@ -0,0 +1,3 @@
+/** Applies bundled SQL migrations directly to a D1 binding (used in tests and Workers). */
+export declare function applyMigrations(db: D1Database): Promise<void>;
+//# sourceMappingURL=migrations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../src/core/migrations.ts"],"names":[],"mappings":"AAyBA,2FAA2F;AAC3F,wBAAsB,eAAe,CAAC,EAAE,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBnE"}

package/dist/core/migrations.js

@@ -0,0 +1,41 @@
+import initSql from '../../migrations/0000_init.sql?raw';
+import collectionsSetsSql from '../../migrations/0001_collections_sets.sql?raw';
+import ftsSql from '../../migrations/0003_fts.sql?raw';
+import formsSql from '../../migrations/0004_forms.sql?raw';
+import globalsSql from '../../migrations/0005_globals.sql?raw';
+import previewSessionsSql from '../../migrations/0006_preview_sessions.sql?raw';
+const MIGRATIONS = [
+    { id: '0000_init', sql: initSql },
+    { id: '0001_collections_sets', sql: collectionsSetsSql },
+    // 0002_tree_drafts was folded into 0000_init when the schema was reshaped for
+    // i18n. The ID is intentionally skipped so the ledger remains forward-only.
+    { id: '0003_fts', sql: ftsSql },
+    { id: '0004_forms', sql: formsSql },
+    { id: '0005_globals', sql: globalsSql },
+    { id: '0006_preview_sessions', sql: previewSessionsSql },
+];
+function splitStatements(sql) {
+    return sql
+        .split('--> statement-breakpoint')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+/** Applies bundled SQL migrations directly to a D1 binding (used in tests and Workers). */
+export async function applyMigrations(db) {
+    await db.exec('CREATE TABLE IF NOT EXISTS _vulse_migrations (id TEXT PRIMARY KEY, applied_at INTEGER NOT NULL)');
+    for (const migration of MIGRATIONS) {
+        const applied = await db
+            .prepare('SELECT id FROM _vulse_migrations WHERE id = ?')
+            .bind(migration.id)
+            .first();
+        if (applied)
+            continue;
+        for (const stmt of splitStatements(migration.sql)) {
+            await db.exec(stmt.replace(/\s+/g, ' '));
+        }
+        await db
+            .prepare('INSERT INTO _vulse_migrations (id, applied_at) VALUES (?, ?)')
+            .bind(migration.id, Date.now())
+            .run();
+    }
+}

package/dist/core/parse-content.d.ts

@@ -0,0 +1,14 @@
+import type { z } from 'astro/zod';
+export interface ContentValidationIssue {
+    path: (string | number)[];
+    message: string;
+    code?: string;
+}
+/**
+ * Parses arbitrary content against a Zod schema. On failure, throws a
+ * ValidationError whose message names the first offending field (so the
+ * top-level error banner reads sensibly) and whose `details.issues` carries
+ * the full list with humanized messages for inline field display.
+ */
+export declare function parseContent<S extends z.ZodTypeAny>(schema: S, content: unknown): z.infer<S>;
+//# sourceMappingURL=parse-content.d.ts.map

package/dist/core/parse-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-content.d.ts","sourceRoot":"","sources":["../../src/core/parse-content.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,WAAW,CAAA;AAGlC,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAW5F"}

package/dist/core/parse-content.js

@@ -0,0 +1,68 @@
+import { ValidationError } from './errors.js';
+/**
+ * Parses arbitrary content against a Zod schema. On failure, throws a
+ * ValidationError whose message names the first offending field (so the
+ * top-level error banner reads sensibly) and whose `details.issues` carries
+ * the full list with humanized messages for inline field display.
+ */
+export function parseContent(schema, content) {
+    const parsed = schema.safeParse(content);
+    if (parsed.success)
+        return parsed.data;
+    const issues = parsed.error.issues.map((issue) => ({
+        path: issue.path.filter((p) => typeof p === 'string' || typeof p === 'number'),
+        message: humanizeIssue(issue),
+        code: issue.code,
+    }));
+    throw new ValidationError(summarize(issues), { issues });
+}
+function summarize(issues) {
+    if (issues.length === 0)
+        return 'Validation failed';
+    const first = issues[0];
+    const fieldLabel = first.path.length ? first.path.join('.') : 'Content';
+    if (issues.length === 1)
+        return `${fieldLabel}: ${first.message}`;
+    return `${fieldLabel}: ${first.message} (and ${issues.length - 1} more issue${issues.length - 1 === 1 ? '' : 's'})`;
+}
+function humanizeIssue(issue) {
+    const i = issue;
+    // Missing required value.
+    if (i.code === 'invalid_type') {
+        if (i.received === 'undefined' || i.received === 'null')
+            return 'This field is required.';
+        if (/received (undefined|null)/.test(i.message))
+            return 'This field is required.';
+        if (i.expected)
+            return `Expected ${i.expected}.`;
+    }
+    // Length / numeric bounds.
+    const origin = i.origin ?? i.type;
+    if (i.code === 'too_small') {
+        if (origin === 'string' && Number(i.minimum) === 1)
+            return 'This field is required.';
+        if (origin === 'string')
+            return `Must be at least ${i.minimum} characters.`;
+        if (origin === 'number')
+            return `Must be ${i.inclusive ? 'at least' : 'greater than'} ${i.minimum}.`;
+        if (origin === 'array')
+            return `Add at least ${i.minimum} item${i.minimum === 1 ? '' : 's'}.`;
+    }
+    if (i.code === 'too_big') {
+        if (origin === 'string')
+            return `Must be at most ${i.maximum} characters.`;
+        if (origin === 'number')
+            return `Must be ${i.inclusive ? 'at most' : 'less than'} ${i.maximum}.`;
+        if (origin === 'array')
+            return `No more than ${i.maximum} item${i.maximum === 1 ? '' : 's'}.`;
+    }
+    // String formats (Zod 4: invalid_format with format; Zod 3: invalid_string with validation).
+    const fmt = i.format ?? i.validation;
+    if (fmt === 'email')
+        return 'Enter a valid email address.';
+    if (fmt === 'url')
+        return 'Enter a valid URL.';
+    if (i.message === 'Required')
+        return 'This field is required.';
+    return i.message;
+}

package/dist/core/plugins/definition.d.ts

@@ -0,0 +1,99 @@
+import type { FormDefinition } from '../forms/definition.js';
+import type { SubmissionRow } from '../repos/forms.js';
+import type { Role } from '../blueprints/types.js';
+export type MaybePromise<T> = T | Promise<T>;
+export interface VulsePluginLogger {
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+}
+export interface VulsePluginEmail {
+    send(input: {
+        to: string;
+        subject: string;
+        text?: string;
+        body?: string;
+        html?: string;
+    }): Promise<void>;
+}
+export interface VulsePluginContext {
+    env: Record<string, unknown>;
+    logger: VulsePluginLogger;
+    email: VulsePluginEmail;
+}
+export interface FormBeforeSubmitEvent {
+    request: Request;
+    form: FormDefinition;
+    payload: Record<string, unknown>;
+    ip: string;
+    headers: Headers;
+}
+export type FormBeforeSubmitResult = void | {
+    action?: 'continue';
+    payload?: Record<string, unknown>;
+} | {
+    action: 'drop';
+    reason?: string;
+    response?: 'fake-success';
+} | {
+    action: 'reject';
+    message?: string;
+};
+export interface FormAfterSubmitEvent {
+    request: Request;
+    form: FormDefinition;
+    payload: Record<string, unknown>;
+    submission: SubmissionRow;
+    ip: string;
+    headers: Headers;
+}
+export interface FormProcessEvent {
+    form: FormDefinition;
+    payload: Record<string, unknown>;
+    submission: SubmissionRow;
+}
+export interface AuthUserCreateInput {
+    id?: string;
+    email?: string;
+    name?: string;
+    role?: Role;
+    displayName?: string | null;
+    [key: string]: unknown;
+}
+export interface AuthUserCreateEvent {
+    user: AuthUserCreateInput;
+}
+export type AuthUserBeforeCreateResult = void | false | {
+    action?: 'continue';
+    data?: AuthUserCreateInput;
+} | {
+    action: 'reject';
+    message?: string;
+};
+export interface AuthUserCreatedEvent {
+    user: AuthUserCreateInput;
+}
+export interface VulsePluginHooks {
+    'form:beforeSubmit'?: (event: FormBeforeSubmitEvent, ctx: VulsePluginContext) => MaybePromise<FormBeforeSubmitResult>;
+    'form:afterSubmit'?: (event: FormAfterSubmitEvent, ctx: VulsePluginContext) => MaybePromise<void>;
+    'form:beforeProcess'?: (event: FormProcessEvent, ctx: VulsePluginContext) => MaybePromise<void>;
+    'form:afterProcess'?: (event: FormProcessEvent, ctx: VulsePluginContext) => MaybePromise<void>;
+    'auth:userBeforeCreate'?: (event: AuthUserCreateEvent, ctx: VulsePluginContext) => MaybePromise<AuthUserBeforeCreateResult>;
+    'auth:userAfterCreate'?: (event: AuthUserCreatedEvent, ctx: VulsePluginContext) => MaybePromise<void>;
+}
+export type VulseHookName = keyof VulsePluginHooks;
+export interface VulsePlugin {
+    id: string;
+    version?: string;
+    /**
+     * Higher priority plugins run earlier. Plugins with the same priority run
+     * in registration order.
+     */
+    priority?: number;
+    capabilities?: string[];
+    hooks?: VulsePluginHooks;
+}
+export declare function assertValidPluginId(id: string): void;
+export declare function definePlugin<const T extends VulsePlugin>(plugin: T): T;
+//# sourceMappingURL=definition.d.ts.map

package/dist/core/plugins/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/core/plugins/definition.ts"],"names":[],"mappings":"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"}

package/dist/core/plugins/definition.js

@@ -0,0 +1,10 @@
+const PLUGIN_ID_RE = /^[a-z0-9][a-z0-9._-]*$/;
+export function assertValidPluginId(id) {
+    if (!PLUGIN_ID_RE.test(id)) {
+        throw new Error(`Vulse plugin "${id}": id must be lowercase letters, numbers, dots, underscores, or dashes`);
+    }
+}
+export function definePlugin(plugin) {
+    assertValidPluginId(plugin.id);
+    return plugin;
+}

package/dist/core/preview-content.d.ts

@@ -0,0 +1,16 @@
+export interface VulseLivePreviewLocals {
+    entryId: string | null;
+    collection: string;
+    slug: string;
+    content: unknown;
+}
+export interface PreviewLocals {
+    vulseLivePreview?: VulseLivePreviewLocals | null;
+    vulsePreview?: boolean;
+}
+export declare function resolvePreviewContent(entry: {
+    id: string;
+    content: unknown;
+    draftContent?: unknown | null;
+} | null, locals: PreviewLocals): unknown | null;
+//# sourceMappingURL=preview-content.d.ts.map

package/dist/core/preview-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-content.d.ts","sourceRoot":"","sources":["../../src/core/preview-content.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,gBAAgB,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAA;IAChD,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,EAC7E,MAAM,EAAE,aAAa,GACpB,OAAO,GAAG,IAAI,CAKhB"}

package/dist/core/preview-content.js

@@ -0,0 +1,8 @@
+export function resolvePreviewContent(entry, locals) {
+    const live = locals.vulseLivePreview;
+    if (live && entry && live.entryId === entry.id)
+        return live.content;
+    if (locals.vulsePreview && entry?.draftContent != null)
+        return entry.draftContent;
+    return entry?.content ?? null;
+}

package/dist/core/repos/entries.d.ts

@@ -0,0 +1,102 @@
+import type { VulseDb } from '../db.js';
+import { entries } from '../schema.js';
+export declare const DEFAULT_LOCALE = "default";
+export interface EntryRow {
+    id: string;
+    collection: string;
+    parentId: string | null;
+    sortOrder: number;
+    slug: string;
+    status: 'draft' | 'published';
+    locale: string;
+    version: number;
+    content: unknown;
+    draftContent: unknown | null;
+    hasUnpublishedChanges: boolean;
+    publishedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy: string | null;
+    updatedBy: string | null;
+}
+export interface EntryNode extends EntryRow {
+    children: EntryNode[];
+}
+export interface EntryLocaleSummary {
+    locale: string;
+    slug: string;
+    status: 'draft' | 'published';
+    hasUnpublishedChanges: boolean;
+    publishedAt: Date | null;
+    updatedAt: Date;
+}
+export type EntryOrderBy = 'sortOrder' | 'publishedAt' | 'updatedAt' | 'createdAt';
+export interface ListOptions {
+    collection: string;
+    locale?: string;
+    status?: 'draft' | 'published';
+    parentId?: string | null;
+    limit?: number;
+    offset?: number;
+    createdBy?: string;
+    publishedAfter?: Date;
+    publishedBefore?: Date;
+    orderBy?: EntryOrderBy;
+    order?: 'asc' | 'desc';
+}
+type EntryShell = typeof entries.$inferSelect;
+export declare class EntriesRepo {
+    private db;
+    constructor(db: VulseDb);
+    private resolveUniqueSlug;
+    private isSlugUniqueViolation;
+    maxSortOrder(collection: string, parentId: string | null): Promise<number>;
+    /** True if the proposed parent would create a cycle (parent is a descendant of id). */
+    private wouldCreateCycle;
+    create(input: {
+        collection: string;
+        slug: string;
+        content: unknown;
+        createdBy: string;
+        status?: 'draft' | 'published';
+        locale?: string;
+        parentId?: string | null;
+        draftsEnabled?: boolean;
+    }): Promise<EntryRow>;
+    /** Add a new locale translation to an existing entry. */
+    createLocale(entryId: string, input: {
+        locale: string;
+        slug: string;
+        content: unknown;
+        updatedBy: string;
+        status?: 'draft' | 'published';
+        draftsEnabled?: boolean;
+    }): Promise<EntryRow>;
+    findShellById(id: string): Promise<EntryShell | null>;
+    findById(id: string, locale?: string): Promise<EntryRow | null>;
+    /** Returns every locale row for an entry — used by the admin to render the locale picker. */
+    listLocales(id: string): Promise<EntryLocaleSummary[]>;
+    findBySlug(collection: string, slug: string, locale?: string): Promise<EntryRow | null>;
+    list(opts: ListOptions): Promise<EntryRow[]>;
+    tree(collection: string, locale?: string): Promise<EntryNode[]>;
+    move(collection: string, id: string, input: {
+        parentId: string | null;
+        sortOrder?: number;
+    }): Promise<EntryShell>;
+    updateWithRevision(id: string, patch: {
+        locale?: string;
+        content?: unknown;
+        status?: 'draft' | 'published';
+        slug?: string;
+        updatedBy: string;
+        changeSummary?: string;
+        publish?: boolean;
+        draftsEnabled?: boolean;
+    }): Promise<EntryRow>;
+    publish(id: string, updatedBy: string, locale?: string): Promise<EntryRow>;
+    delete(id: string): Promise<void>;
+    /** Delete only one locale of an entry; the entry shell remains if other locales exist. */
+    deleteLocale(id: string, locale: string): Promise<void>;
+}
+export {};
+//# sourceMappingURL=entries.d.ts.map