@ekrist1/vulse 0.1.6-alpha.3

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

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

package/dist/core/schema.js

@@ -0,0 +1,220 @@
+import { sqliteTable, text, integer, index, uniqueIndex, primaryKey } from 'drizzle-orm/sqlite-core';
+import { sql } from 'drizzle-orm';
+// --- Vulse content (i18n model) ---
+//
+// `vulse_entries` is the single-identity shell: one row per logical entry, holding
+// only locale-independent data (tree position, ownership). Per-locale data
+// (slug, status, content, drafts) lives in `vulse_entry_locales`, keyed by
+// (entry_id, locale). Slug uniqueness is per (collection, locale).
+export const entries = sqliteTable('vulse_entries', {
+    id: text('id').primaryKey(),
+    collection: text('collection').notNull(),
+    parentId: text('parent_id').references(() => entries.id, { onDelete: 'cascade' }),
+    sortOrder: integer('sort_order').notNull().default(0),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+    createdBy: text('created_by'),
+}, (t) => ({
+    byCollection: index('vulse_entries_collection').on(t.collection),
+    byTree: index('vulse_entries_tree').on(t.collection, t.parentId, t.sortOrder),
+}));
+export const entryLocales = sqliteTable('vulse_entry_locales', {
+    entryId: text('entry_id').notNull().references(() => entries.id, { onDelete: 'cascade' }),
+    collection: text('collection').notNull(),
+    locale: text('locale').notNull(),
+    slug: text('slug').notNull(),
+    status: text('status', { enum: ['draft', 'published'] }).notNull().default('draft'),
+    version: integer('version').notNull().default(1),
+    content: text('content', { mode: 'json' }).notNull(),
+    draftContent: text('draft_content', { mode: 'json' }),
+    publishedAt: integer('published_at', { mode: 'timestamp_ms' }),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedBy: text('updated_by'),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.entryId, t.locale] }),
+    uniqSlug: uniqueIndex('vulse_entry_locales_collection_locale_slug').on(t.collection, t.locale, t.slug),
+    byStatus: index('vulse_entry_locales_status_published').on(t.collection, t.locale, t.status, t.publishedAt),
+}));
+export const entryRevisions = sqliteTable('vulse_entry_revisions', {
+    id: text('id').primaryKey(),
+    entryId: text('entry_id').notNull().references(() => entries.id, { onDelete: 'cascade' }),
+    locale: text('locale').notNull(),
+    version: integer('version').notNull(),
+    content: text('content', { mode: 'json' }).notNull(),
+    authorId: text('author_id'),
+    changeSummary: text('change_summary'),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+}, (t) => ({
+    byEntry: index('vulse_entry_revisions_entry_locale_version').on(t.entryId, t.locale, t.version),
+}));
+export const media = sqliteTable('vulse_media', {
+    id: text('id').primaryKey(),
+    r2Key: text('r2_key').notNull(),
+    mime: text('mime').notNull(),
+    size: integer('size').notNull(),
+    width: integer('width'),
+    height: integer('height'),
+    alt: text('alt'),
+    blurhash: text('blurhash'),
+    uploadedBy: text('uploaded_by'),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    deletedAt: integer('deleted_at', { mode: 'timestamp_ms' }),
+}, (t) => ({
+    // Partial index on active rows: every list query reads `WHERE deleted_at IS NULL`.
+    active: index('vulse_media_active').on(t.createdAt).where(sql `${t.deletedAt} IS NULL`),
+}));
+export const vulseCollections = sqliteTable('vulse_collections', {
+    handle: text('handle').primaryKey(),
+    label: text('label').notNull(),
+    definition: text('definition', { mode: 'json' }).notNull(),
+    blueprintHash: text('blueprint_hash').notNull(),
+    // `schema_version` lets future definition-shape changes migrate row-by-row
+    // without a destructive table rewrite.
+    schemaVersion: integer('schema_version').notNull().default(1),
+    singleton: integer('singleton', { mode: 'boolean' }).notNull().default(false),
+    tree: integer('tree', { mode: 'boolean' }).notNull().default(false),
+    drafts: integer('drafts', { mode: 'boolean' }).notNull().default(false),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+});
+export const vulseSets = sqliteTable('vulse_sets', {
+    handle: text('handle').primaryKey(),
+    label: text('label').notNull(),
+    definition: text('definition', { mode: 'json' }).notNull(),
+    schemaVersion: integer('schema_version').notNull().default(1),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+});
+export const settings = sqliteTable('vulse_settings', {
+    key: text('key').primaryKey(),
+    value: text('value', { mode: 'json' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+});
+// --- Forms ---
+export const vulseForms = sqliteTable('vulse_forms', {
+    handle: text('handle').primaryKey(),
+    label: text('label').notNull(),
+    definition: text('definition', { mode: 'json' }).notNull(),
+    schemaVersion: integer('schema_version').notNull().default(1),
+    enabled: integer('enabled', { mode: 'boolean' }).notNull().default(true),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+});
+export const vulseFormSubmissions = sqliteTable('vulse_form_submissions', {
+    id: text('id').primaryKey(),
+    formHandle: text('form_handle').notNull().references(() => vulseForms.handle, { onDelete: 'cascade' }),
+    payload: text('payload', { mode: 'json' }).notNull(),
+    fileRefs: text('file_refs', { mode: 'json' }).notNull().default([]),
+    meta: text('meta', { mode: 'json' }).notNull(),
+    status: text('status', { enum: ['received', 'processed', 'failed'] }).notNull().default('received'),
+    error: text('error'),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+}, (t) => ({
+    byFormCreated: index('vulse_form_submissions_form_created').on(t.formHandle, t.createdAt),
+    byFormStatus: index('vulse_form_submissions_form_status').on(t.formHandle, t.status),
+}));
+export const vulseFormUploadDrafts = sqliteTable('vulse_form_upload_drafts', {
+    id: text('id').primaryKey(),
+    formHandle: text('form_handle').notNull().references(() => vulseForms.handle, { onDelete: 'cascade' }),
+    fieldName: text('field_name').notNull(),
+    mediaId: text('media_id').notNull().references(() => media.id, { onDelete: 'cascade' }),
+    expiresAt: integer('expires_at', { mode: 'timestamp_ms' }).notNull(),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+}, (t) => ({
+    byExpires: index('vulse_form_upload_drafts_expires').on(t.expiresAt),
+}));
+export const vulseFormUniqueValues = sqliteTable('vulse_form_unique_values', {
+    formHandle: text('form_handle').notNull().references(() => vulseForms.handle, { onDelete: 'cascade' }),
+    fieldName: text('field_name').notNull(),
+    valueHash: text('value_hash').notNull(),
+    submissionId: text('submission_id').notNull().references(() => vulseFormSubmissions.id, { onDelete: 'cascade' }),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+}, (t) => ({
+    pk: uniqueIndex('vulse_form_unique_values_pk').on(t.formHandle, t.fieldName, t.valueHash),
+    bySubmission: index('vulse_form_unique_values_submission').on(t.submissionId),
+}));
+export const vulseFormRateLimits = sqliteTable('vulse_form_rate_limits', {
+    formHandle: text('form_handle').notNull(),
+    ipHash: text('ip_hash').notNull(),
+    windowStart: integer('window_start', { mode: 'timestamp_ms' }).notNull(),
+    count: integer('count').notNull().default(1),
+}, (t) => ({
+    pk: uniqueIndex('vulse_form_rate_limits_pk').on(t.formHandle, t.ipHash, t.windowStart),
+}));
+// --- Globals ---
+export const vulseGlobalSets = sqliteTable('vulse_global_sets', {
+    handle: text('handle').primaryKey(),
+    label: text('label').notNull(),
+    definition: text('definition', { mode: 'json' }).notNull(),
+    blueprintHash: text('blueprint_hash').notNull().default(''),
+    schemaVersion: integer('schema_version').notNull().default(1),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+});
+export const vulseGlobalValues = sqliteTable('vulse_global_values', {
+    handle: text('handle').primaryKey().references(() => vulseGlobalSets.handle, { onDelete: 'cascade' }),
+    content: text('content', { mode: 'json' }).notNull().default({}),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+});
+// --- Live preview ---
+export const vulsePreviewSessions = sqliteTable('vulse_preview_sessions', {
+    id: text('id').primaryKey(),
+    userId: text('user_id').notNull(),
+    entryId: text('entry_id'),
+    collection: text('collection').notNull(),
+    locale: text('locale').notNull().default('default'),
+    slug: text('slug').notNull(),
+    content: text('content', { mode: 'json' }).notNull(),
+    expiresAt: integer('expires_at', { mode: 'timestamp_ms' }).notNull(),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+}, (t) => ({
+    byExpires: index('vulse_preview_sessions_expires').on(t.expiresAt),
+    byUser: index('vulse_preview_sessions_user').on(t.userId),
+}));
+// --- Better Auth (canonical column names per better-auth Drizzle adapter) ---
+export const user = sqliteTable('user', {
+    id: text('id').primaryKey(),
+    name: text('name').notNull(),
+    email: text('email').notNull().unique(),
+    emailVerified: integer('email_verified', { mode: 'boolean' }).notNull().default(false),
+    image: text('image'),
+    role: text('role', { enum: ['admin', 'editor', 'member'] }).notNull().default('member'),
+    displayName: text('display_name'),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+});
+export const session = sqliteTable('session', {
+    id: text('id').primaryKey(),
+    userId: text('user_id').notNull().references(() => user.id, { onDelete: 'cascade' }),
+    token: text('token').notNull().unique(),
+    expiresAt: integer('expires_at', { mode: 'timestamp_ms' }).notNull(),
+    ipAddress: text('ip_address'),
+    userAgent: text('user_agent'),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+});
+export const account = sqliteTable('account', {
+    id: text('id').primaryKey(),
+    userId: text('user_id').notNull().references(() => user.id, { onDelete: 'cascade' }),
+    accountId: text('account_id').notNull(),
+    providerId: text('provider_id').notNull(),
+    accessToken: text('access_token'),
+    refreshToken: text('refresh_token'),
+    idToken: text('id_token'),
+    accessTokenExpiresAt: integer('access_token_expires_at', { mode: 'timestamp_ms' }),
+    refreshTokenExpiresAt: integer('refresh_token_expires_at', { mode: 'timestamp_ms' }),
+    scope: text('scope'),
+    password: text('password'),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+});
+export const verification = sqliteTable('verification', {
+    id: text('id').primaryKey(),
+    identifier: text('identifier').notNull(),
+    value: text('value').notNull(),
+    expiresAt: integer('expires_at', { mode: 'timestamp_ms' }).notNull(),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+});

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

@@ -0,0 +1,8 @@
+import type { z } from 'astro/zod';
+import type { SetDefinition } from './definition.js';
+export interface CompiledSet {
+    definition: SetDefinition;
+    schema: z.ZodObject<z.ZodRawShape>;
+}
+export declare function compileSet(def: SetDefinition): CompiledSet;
+//# sourceMappingURL=compile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/core/sets/compile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,WAAW,CAAA;AAElC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,aAAa,CAAA;IACzB,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAA;CACnC;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,aAAa,GAAG,WAAW,CAE1D"}

package/dist/core/sets/compile.js

@@ -0,0 +1,4 @@
+import { compileFieldObject } from '../blueprints/compile.js';
+export function compileSet(def) {
+    return { definition: def, schema: compileFieldObject(def.fields) };
+}

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

@@ -0,0 +1,53 @@
+import { z } from 'astro/zod';
+export declare const SetDefinitionSchema: z.ZodObject<{
+    handle: z.ZodString;
+    label: 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>;
+export type SetDefinition = z.infer<typeof SetDefinitionSchema>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/core/sets/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAA;AAG7B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/core/sets/definition.js

@@ -0,0 +1,7 @@
+import { z } from 'astro/zod';
+import { NestedFieldDefinitionSchema } from '../blueprints/definition.js';
+export const SetDefinitionSchema = z.object({
+    handle: z.string().regex(/^[a-z][a-z0-9_-]*$/),
+    label: z.string().min(1),
+    fields: z.array(NestedFieldDefinitionSchema).min(1),
+});

package/dist/core/sets/service.d.ts

@@ -0,0 +1,13 @@
+import type { VulseDb } from '../db.js';
+import { type SetDefinition } from './definition.js';
+export interface SetDTO extends SetDefinition {
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function createSet(db: VulseDb, input: SetDefinition): Promise<SetDTO>;
+export declare function listSets(db: VulseDb): Promise<SetDTO[]>;
+export declare function getSet(db: VulseDb, handle: string): Promise<SetDTO | null>;
+export declare function updateSet(db: VulseDb, handle: string, input: SetDefinition): Promise<SetDTO>;
+export declare function deleteSet(db: VulseDb, handle: string): Promise<void>;
+export declare function loadCompiledSets(db: VulseDb): Promise<Map<string, import('./compile.js').CompiledSet>>;
+//# sourceMappingURL=service.d.ts.map

package/dist/core/sets/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/core/sets/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAGvC,OAAO,EAAE,KAAK,aAAa,EAAuB,MAAM,iBAAiB,CAAA;AAEzE,MAAM,WAAW,MAAO,SAAQ,aAAa;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAgBD,wBAAsB,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAelF;AAED,wBAAsB,QAAQ,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAG7D;AAED,wBAAsB,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAGhF;AAED,wBAAsB,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAelG;AAED,wBAAsB,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE1E;AAED,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,cAAc,EAAE,WAAW,CAAC,CAAC,CAQ5G"}

package/dist/core/sets/service.js

@@ -0,0 +1,68 @@
+import { eq } from 'drizzle-orm';
+import { vulseSets } from '../schema.js';
+import { ValidationError } from '../errors.js';
+import { SetDefinitionSchema } from './definition.js';
+function parseRow(row) {
+    const def = SetDefinitionSchema.parse(row.definition);
+    return {
+        ...def,
+        createdAt: row.createdAt.toISOString(),
+        updatedAt: row.updatedAt.toISOString(),
+    };
+}
+export async function createSet(db, input) {
+    const parsed = SetDefinitionSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError('Invalid set', { issues: parsed.error.issues });
+    const def = parsed.data;
+    const now = new Date();
+    await db.insert(vulseSets).values({
+        handle: def.handle,
+        label: def.label,
+        definition: def,
+        createdAt: now,
+        updatedAt: now,
+    });
+    const created = await getSet(db, def.handle);
+    if (!created)
+        throw new Error(`set not found after create: ${def.handle}`);
+    return created;
+}
+export async function listSets(db) {
+    const rows = await db.select().from(vulseSets).orderBy(vulseSets.createdAt);
+    return rows.map(parseRow);
+}
+export async function getSet(db, handle) {
+    const row = await db.select().from(vulseSets).where(eq(vulseSets.handle, handle)).get();
+    return row ? parseRow(row) : null;
+}
+export async function updateSet(db, handle, input) {
+    if (input.handle !== handle) {
+        throw new Error(`set handle is immutable (got '${input.handle}', expected '${handle}')`);
+    }
+    const parsed = SetDefinitionSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError('Invalid set', { issues: parsed.error.issues });
+    const def = parsed.data;
+    await db.update(vulseSets).set({
+        label: def.label,
+        definition: def,
+        updatedAt: new Date(),
+    }).where(eq(vulseSets.handle, handle));
+    const out = await getSet(db, handle);
+    if (!out)
+        throw new Error(`set not found: ${handle}`);
+    return out;
+}
+export async function deleteSet(db, handle) {
+    await db.delete(vulseSets).where(eq(vulseSets.handle, handle));
+}
+export async function loadCompiledSets(db) {
+    const { compileSet } = await import('./compile.js');
+    const rows = await listSets(db);
+    const map = new Map();
+    for (const row of rows) {
+        map.set(row.handle, compileSet(row));
+    }
+    return map;
+}

package/dist/core/sets/validate-tree.d.ts

@@ -0,0 +1,4 @@
+import type { z } from 'astro/zod';
+import type { CompiledSet } from './compile.js';
+export declare function validateSetNodes(doc: unknown, basePath: (string | number)[], sets: Map<string, CompiledSet>, ctx: z.core.$RefinementCtx): void;
+//# sourceMappingURL=validate-tree.d.ts.map

package/dist/core/sets/validate-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-tree.d.ts","sourceRoot":"","sources":["../../../src/core/sets/validate-tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,WAAW,CAAA;AAClC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAY/C,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAC7B,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EAC9B,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,cAAc,GACzB,IAAI,CAsCN"}

package/dist/core/sets/validate-tree.js

@@ -0,0 +1,40 @@
+function isNode(v) {
+    return typeof v === 'object' && v !== null && 'type' in v;
+}
+export function validateSetNodes(doc, basePath, sets, ctx) {
+    if (!isNode(doc))
+        return;
+    walk(doc, basePath);
+    function walk(node, path) {
+        if (node.type === 'vulseSet') {
+            const attrs = (node.attrs ?? {});
+            const handle = typeof attrs.set === 'string' ? attrs.set : undefined;
+            const data = (attrs.data ?? {});
+            const compiled = handle ? sets.get(handle) : undefined;
+            if (!compiled) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: [...path, 'set'],
+                    message: `unknown set: ${handle ?? '(empty)'}`,
+                });
+                return;
+            }
+            const parsed = compiled.schema.safeParse(data);
+            if (!parsed.success) {
+                for (const issue of parsed.error.issues) {
+                    ctx.addIssue({
+                        ...issue,
+                        path: [...path, 'data', ...issue.path],
+                    });
+                }
+            }
+            return;
+        }
+        if (Array.isArray(node.content)) {
+            node.content.forEach((child, i) => {
+                if (isNode(child))
+                    walk(child, [...path, 'content', i]);
+            });
+        }
+    }
+}

package/dist/core/slug.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeSlug(input: string): string;
+export declare function isValidSlug(input: string): boolean;
+export declare function normalizeFieldHandle(input: string): string;
+export declare function isValidFieldHandle(input: string): boolean;
+//# sourceMappingURL=slug.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slug.d.ts","sourceRoot":"","sources":["../../src/core/slug.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOnD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD;AAID,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEzD"}

package/dist/core/slug.js

@@ -0,0 +1,25 @@
+const VALID_SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export function normalizeSlug(input) {
+    return input
+        .normalize('NFKD').replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-{2,}/g, '-');
+}
+export function isValidSlug(input) {
+    return VALID_SLUG.test(input);
+}
+const VALID_FIELD_HANDLE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+export function normalizeFieldHandle(input) {
+    return input
+        .normalize('NFKD').replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .replace(/_+/g, '_')
+        .replace(/^[^a-z_]+/, '');
+}
+export function isValidFieldHandle(input) {
+    return VALID_FIELD_HANDLE.test(input);
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import type { AstroIntegration } from 'astro';
+import type { VulseOptions } from './integration/index.js';
+export { VULSE_VERSION } from './version.js';
+export type { VulseOptions } from './integration/index.js';
+export { defineCollection, z } from './core/blueprints/define.js';
+export { blocks, media, ref, entry, entries, link, grid } from './core/blueprints/zod-helpers.js';
+export type { LinkValue, SelectOption } from './core/blueprints/definition.js';
+export { definePlugin } from './core/plugins/definition.js';
+export type { Blueprint, Role, AuthContext, AccessArgs, AccessFn } from './core/blueprints/types.js';
+export type { SeoContent, SeoFieldMapping, ResolvedSeo } from './core/blueprints/seo.js';
+export { resolveEffectiveSeo, resolvedSeoSummary } from './core/blueprints/seo.js';
+export type { Block, BlockType } from './core/blocks/schema.js';
+export type { AuthUserBeforeCreateResult, AuthUserCreateEvent, AuthUserCreateInput, AuthUserCreatedEvent, FormAfterSubmitEvent, FormBeforeSubmitEvent, FormBeforeSubmitResult, FormProcessEvent, VulsePlugin, VulsePluginContext, VulsePluginHooks, } from './core/plugins/definition.js';
+export { BUILT_IN_BLOCK_TYPES } from './core/blocks/schema.js';
+export default function vulse(opts?: VulseOptions): AstroIntegration;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAA;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAE1D,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,EAAE,gBAAgB,EAAE,CAAC,EAAE,MAAM,6BAA6B,CAAA;AACjE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,kCAAkC,CAAA;AACjG,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AAC9E,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAC3D,YAAY,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AACpG,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AACxF,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AAClF,YAAY,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAC/D,YAAY,EACV,0BAA0B,EAC1B,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,gBAAgB,EAChB,WAAW,EACX,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAE9D,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,IAAI,GAAE,YAAiB,GAAG,gBAAgB,CAYvE"}

package/dist/index.js

@@ -0,0 +1,19 @@
+export { VULSE_VERSION } from './version.js';
+export { defineCollection, z } from './core/blueprints/define.js';
+export { blocks, media, ref, entry, entries, link, grid } from './core/blueprints/zod-helpers.js';
+export { definePlugin } from './core/plugins/definition.js';
+export { resolveEffectiveSeo, resolvedSeoSummary } from './core/blueprints/seo.js';
+export { BUILT_IN_BLOCK_TYPES } from './core/blocks/schema.js';
+export default function vulse(opts = {}) {
+    return {
+        name: 'vulse',
+        hooks: {
+            'astro:config:setup': async (params) => {
+                // Keep runtime helper imports from eagerly evaluating Astro/Vite integration code.
+                const { default: createVulseIntegration } = await import('./integration/index.js');
+                const integration = createVulseIntegration(opts);
+                await integration.hooks?.['astro:config:setup']?.(params);
+            },
+        },
+    };
+}

package/dist/integration/cron.d.ts

@@ -0,0 +1,4 @@
+export { vulseScheduled, type CronEnv } from '../server/cron.js';
+export { vulseFormQueue } from '../server/forms/process-submission.js';
+export type { FormProcessMessage } from '../server/forms/queue.js';
+//# sourceMappingURL=cron.d.ts.map

package/dist/integration/cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.d.ts","sourceRoot":"","sources":["../../src/integration/cron.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAA;AACtE,YAAY,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/integration/cron.js

@@ -0,0 +1,2 @@
+export { vulseScheduled } from '../server/cron.js';
+export { vulseFormQueue } from '../server/forms/process-submission.js';

package/dist/integration/index.d.ts

@@ -0,0 +1,9 @@
+import type { AstroIntegration } from 'astro';
+import type { VulsePlugin } from '../core/plugins/definition.js';
+export interface VulseOptions {
+    /** Override the admin route prefix. Defaults to `/admin`. */
+    adminPath?: string;
+    plugins?: VulsePlugin[];
+}
+export default function vulse(opts?: VulseOptions): AstroIntegration;
+//# sourceMappingURL=index.d.ts.map

package/dist/integration/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/integration/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAA;AAU7C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAoBhE,MAAM,WAAW,YAAY;IAC3B,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAA;CACxB;AAED,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,IAAI,GAAE,YAAiB,GAAG,gBAAgB,CAoCvE"}

package/dist/integration/index.js

@@ -0,0 +1,63 @@
+import { fileURLToPath } from 'node:url';
+import vue from '@astrojs/vue';
+import tailwindcss from '@tailwindcss/vite';
+import { injectVulseRoutes } from './inject-routes.js';
+import { injectVulseAdminRoutes } from './inject-admin-routes.js';
+import { vulseBlueprintsPlugin } from './vite-plugin-blueprints.js';
+import { generateBlueprintTypes } from './type-gen.js';
+import { initLoaderBinding } from './loader-binding.js';
+import { setVulsePlugins } from '../server/plugins.js';
+/** Packages that break Vite dep pre-bundling (native bindings, dev-only tools). */
+const OPTIMIZE_DEPS_EXCLUDE = [
+    'better-auth',
+    'better-auth/adapters/drizzle',
+    'drizzle-orm',
+    'drizzle-orm/d1',
+    'drizzle-orm/sqlite-core',
+    'nanoid',
+    'astro/zod',
+    '@tailwindcss/vite',
+    '@tailwindcss/oxide',
+    '@tailwindcss/node',
+    'tailwindcss',
+    '@babel/core',
+    '@babel/preset-typescript',
+    'blake3-wasm',
+];
+export default function vulse(opts = {}) {
+    return {
+        name: 'vulse',
+        hooks: {
+            'astro:config:setup': async ({ injectRoute, addMiddleware, logger, config, updateConfig }) => {
+                setVulsePlugins(opts.plugins ?? []);
+                const root = typeof config.root === 'string' ? config.root : fileURLToPath(config.root);
+                await generateBlueprintTypes(root);
+                await initLoaderBinding(root);
+                injectVulseRoutes({ injectRoute, logger });
+                injectVulseAdminRoutes({
+                    injectRoute,
+                    logger,
+                    ...(opts.adminPath !== undefined ? { adminPath: opts.adminPath } : {}),
+                });
+                addMiddleware({ entrypoint: new URL('./middleware.js', import.meta.url), order: 'pre' });
+                updateConfig({
+                    integrations: [vue()],
+                    vite: {
+                        plugins: [tailwindcss(), vulseBlueprintsPlugin(root)],
+                        optimizeDeps: {
+                            exclude: [...OPTIMIZE_DEPS_EXCLUDE],
+                        },
+                        ssr: {
+                            // Bundle vulse in-process for Cloudflare's module runner; avoid
+                            // noExternal: true — it pulls native dev deps (tailwind oxide, babel) into SSR.
+                            noExternal: ['@ekrist1/vulse'],
+                            optimizeDeps: {
+                                exclude: [...OPTIMIZE_DEPS_EXCLUDE],
+                            },
+                        },
+                    },
+                });
+            },
+        },
+    };
+}

package/dist/integration/inject-admin-routes.d.ts

@@ -0,0 +1,12 @@
+import type { AstroIntegrationLogger } from 'astro';
+export interface InjectAdminArgs {
+    injectRoute: (r: {
+        pattern: string;
+        entrypoint: string;
+        prerender?: boolean;
+    }) => void;
+    logger: AstroIntegrationLogger;
+    adminPath?: string;
+}
+export declare function injectVulseAdminRoutes({ injectRoute, logger, adminPath }: InjectAdminArgs): void;
+//# sourceMappingURL=inject-admin-routes.d.ts.map