@happyvertical/smrt-svelte 0.55.7 → 0.55.8

package/dist/components/overview/registry.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The widget registry (#3727): `registerWidget({ type, component, options,
+ * load, allowedIn, version, migrate })`. Registration is code, done once at
+ * module scope by the app or a package; what a user stores is only data that
+ * names a registered type, validated against it on save and on load.
+ *
+ * Svelte-free apart from type imports, so a server load can use it.
+ */
+import type { Component } from 'svelte';
+import { type RegisteredWidget, type WidgetComponentProps, type WidgetDefinition } from './types.js';
+/** Holds widget definitions by type. */
+export declare class WidgetRegistry {
+    #private;
+    /**
+     * Register a widget. Registering the same type again throws unless
+     * `replace` is set; returns a disposer that removes this registration.
+     */
+    register<Data>(def: WidgetDefinition<Data>, options?: {
+        replace?: boolean;
+    }): () => void;
+    get(type: string): RegisteredWidget | undefined;
+    has(type: string): boolean;
+    /** Registered types in registration order. */
+    types(): string[];
+    list(): RegisteredWidget[];
+}
+/** Create an isolated registry (tests, or an app with several surfaces). */
+export declare function createWidgetRegistry(): WidgetRegistry;
+/** The registry overview components and loaders use unless given another. */
+export declare const defaultWidgetRegistry: WidgetRegistry;
+/** Register a widget type on the default registry. */
+export declare function registerWidget<Data>(def: WidgetDefinition<Data>, options?: {
+    replace?: boolean;
+}): () => void;
+/** A resolved component for each widget type that has one. */
+export type WidgetComponents = Map<string, Component<WidgetComponentProps>>;
+/**
+ * Resolve the components for `types`: eager components as is, lazy ones by
+ * awaiting `loadComponent`. Call it in a universal page load (or before
+ * mount) so the grid can render every widget synchronously on the server and
+ * hydrate without a mismatch; a type that fails to resolve is left out and
+ * renders as unavailable.
+ */
+export declare function resolveWidgetComponents(types: Iterable<string>, registry?: WidgetRegistry): Promise<WidgetComponents>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/components/overview/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/components/overview/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAExC,OAAO,EAIL,KAAK,gBAAgB,EAGrB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAC;AAyCpB,wCAAwC;AACxC,qBAAa,cAAc;;IAGzB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EACX,GAAG,EAAE,gBAAgB,CAAC,IAAI,CAAC,EAC3B,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO,GAClC,MAAM,IAAI;IAab,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAI/C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,8CAA8C;IAC9C,KAAK,IAAI,MAAM,EAAE;IAIjB,IAAI,IAAI,gBAAgB,EAAE;CAG3B;AAED,4EAA4E;AAC5E,wBAAgB,oBAAoB,IAAI,cAAc,CAErD;AAED,6EAA6E;AAC7E,eAAO,MAAM,qBAAqB,EAAE,cAAuC,CAAC;AAE5E,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,IAAI,EACjC,GAAG,EAAE,gBAAgB,CAAC,IAAI,CAAC,EAC3B,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9B,MAAM,IAAI,CAEZ;AAED,8DAA8D;AAC9D,MAAM,MAAM,gBAAgB,GAAG,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAC,CAAC;AAQ5E;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvB,QAAQ,GAAE,cAAsC,GAC/C,OAAO,CAAC,gBAAgB,CAAC,CAyB3B"}

package/dist/components/overview/registry.js

@@ -0,0 +1,112 @@
+import { assertWidgetOptionFields } from './schema.js';
+import { OVERVIEW_MAX_SPAN, OVERVIEW_MIN_SPAN, OVERVIEW_PAGE_ID_PATTERN, WIDGET_TYPE_PATTERN, } from './types.js';
+function toRegistered(def) {
+    if (!WIDGET_TYPE_PATTERN.test(def.type)) {
+        throw new Error(`registerWidget: invalid widget type "${def.type}"`);
+    }
+    const version = def.version ?? 1;
+    if (!Number.isSafeInteger(version) || version < 1) {
+        throw new Error(`widget "${def.type}": version must be a positive integer`);
+    }
+    const minSpan = def.minSpan ?? OVERVIEW_MIN_SPAN;
+    const maxSpan = def.maxSpan ?? OVERVIEW_MAX_SPAN;
+    if (!Number.isInteger(minSpan) ||
+        !Number.isInteger(maxSpan) ||
+        minSpan < OVERVIEW_MIN_SPAN ||
+        maxSpan > OVERVIEW_MAX_SPAN ||
+        minSpan > maxSpan) {
+        throw new Error(`widget "${def.type}": invalid span range`);
+    }
+    const defaultSpan = Math.min(maxSpan, Math.max(minSpan, def.defaultSpan ?? minSpan));
+    for (const id of def.allowedIn ?? []) {
+        if (!OVERVIEW_PAGE_ID_PATTERN.test(id)) {
+            throw new Error(`widget "${def.type}": invalid allowedIn id "${id}"`);
+        }
+    }
+    assertWidgetOptionFields(def.type, def.options);
+    return Object.freeze({
+        ...def,
+        options: Object.freeze([...def.options]),
+        version,
+        defaultSpan,
+        minSpan,
+        maxSpan,
+    });
+}
+/** Holds widget definitions by type. */
+export class WidgetRegistry {
+    #widgets = new Map();
+    /**
+     * Register a widget. Registering the same type again throws unless
+     * `replace` is set; returns a disposer that removes this registration.
+     */
+    register(def, options = {}) {
+        const registered = toRegistered(def);
+        if (this.#widgets.has(def.type) && !options.replace) {
+            throw new Error(`registerWidget: "${def.type}" is already registered`);
+        }
+        this.#widgets.set(def.type, registered);
+        return () => {
+            if (this.#widgets.get(def.type) === registered) {
+                this.#widgets.delete(def.type);
+            }
+        };
+    }
+    get(type) {
+        return this.#widgets.get(type);
+    }
+    has(type) {
+        return this.#widgets.has(type);
+    }
+    /** Registered types in registration order. */
+    types() {
+        return [...this.#widgets.keys()];
+    }
+    list() {
+        return [...this.#widgets.values()];
+    }
+}
+/** Create an isolated registry (tests, or an app with several surfaces). */
+export function createWidgetRegistry() {
+    return new WidgetRegistry();
+}
+/** The registry overview components and loaders use unless given another. */
+export const defaultWidgetRegistry = createWidgetRegistry();
+/** Register a widget type on the default registry. */
+export function registerWidget(def, options) {
+    return defaultWidgetRegistry.register(def, options);
+}
+function isModule(value) {
+    return typeof value === 'object' && value !== null && 'default' in value;
+}
+/**
+ * Resolve the components for `types`: eager components as is, lazy ones by
+ * awaiting `loadComponent`. Call it in a universal page load (or before
+ * mount) so the grid can render every widget synchronously on the server and
+ * hydrate without a mismatch; a type that fails to resolve is left out and
+ * renders as unavailable.
+ */
+export async function resolveWidgetComponents(types, registry = defaultWidgetRegistry) {
+    const out = new Map();
+    await Promise.all([...new Set(types)].map(async (type) => {
+        const def = registry.get(type);
+        if (!def)
+            return;
+        if (def.component) {
+            out.set(type, def.component);
+            return;
+        }
+        if (!def.loadComponent)
+            return;
+        try {
+            const loaded = await def.loadComponent();
+            out.set(type, (isModule(loaded)
+                ? loaded.default
+                : loaded));
+        }
+        catch {
+            // Left out: the grid shows the widget as unavailable.
+        }
+    }));
+    return out;
+}

package/dist/components/overview/resize.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pure span math for resizing a widget by dragging its inline-end edge
+ * (#3727). The grid is a flow of equal columns; a span is a whole number of
+ * them, so a drag snaps to the nearest column boundary.
+ */
+export interface SpanFromPointerInput {
+    /** Pointer position along the inline axis (client coordinates). */
+    pointer: number;
+    /** The tile's inline-start edge (left in LTR, right in RTL). */
+    start: number;
+    rtl: boolean;
+    /** Width of the whole grid. */
+    gridWidth: number;
+    /** Columns currently drawn (1, 2 or 4 depending on the container). */
+    columns: number;
+    /** Gap between columns, in the same unit. */
+    gap: number;
+    min: number;
+    max: number;
+}
+/** The span a tile would have if its end edge were at `pointer`. */
+export declare function spanFromPointer(input: SpanFromPointerInput): number;
+/** The next span for an arrow key, or `null` for a key that does nothing. */
+export declare function spanFromKey(key: string, span: number, min: number, max: number, rtl: boolean): number | null;
+//# sourceMappingURL=resize.d.ts.map

package/dist/components/overview/resize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize.d.ts","sourceRoot":"","sources":["../../../src/components/overview/resize.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,oBAAoB;IACnC,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,OAAO,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAED,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,MAAM,CAQnE;AAED,6EAA6E;AAC7E,wBAAgB,WAAW,CACzB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,OAAO,GACX,MAAM,GAAG,IAAI,CAyBf"}

package/dist/components/overview/resize.js

@@ -0,0 +1,41 @@
+/**
+ * Pure span math for resizing a widget by dragging its inline-end edge
+ * (#3727). The grid is a flow of equal columns; a span is a whole number of
+ * them, so a drag snaps to the nearest column boundary.
+ */
+/** The span a tile would have if its end edge were at `pointer`. */
+export function spanFromPointer(input) {
+    const { pointer, start, rtl, gridWidth, gap, min, max } = input;
+    const columns = Math.max(1, Math.floor(input.columns));
+    const width = rtl ? start - pointer : pointer - start;
+    const column = (gridWidth - gap * (columns - 1)) / columns;
+    const raw = column + gap > 0 ? Math.round((width + gap) / (column + gap)) : min;
+    return Math.max(min, Math.min(max, columns, raw));
+}
+/** The next span for an arrow key, or `null` for a key that does nothing. */
+export function spanFromKey(key, span, min, max, rtl) {
+    let next;
+    switch (key) {
+        case 'ArrowRight':
+            next = span + (rtl ? -1 : 1);
+            break;
+        case 'ArrowLeft':
+            next = span + (rtl ? 1 : -1);
+            break;
+        case 'ArrowUp':
+            next = span + 1;
+            break;
+        case 'ArrowDown':
+            next = span - 1;
+            break;
+        case 'Home':
+            next = min;
+            break;
+        case 'End':
+            next = max;
+            break;
+        default:
+            return null;
+    }
+    return Math.max(min, Math.min(max, next));
+}

package/dist/components/overview/schema.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Versioned widget option schemas (#3727). A widget's options are a flat list
+ * of typed fields; this module validates untrusted option values against it.
+ *
+ * The rule that keeps a stored overview from running arbitrary queries: an
+ * option value can only be a JSON primitive that passes its field's type, so
+ * there is no free-form filter, SQL, expression or URL field. A `model` option
+ * is a bare identifier (optionally confined to a page-declared list) and every
+ * other "which data" option is an `identifier` or a closed `enum`; the loader
+ * maps those to queries it owns and authorizes.
+ *
+ * Pure and Svelte-free: it runs on the server on save and on load, and in the
+ * browser for the option editor.
+ */
+import type { OverviewOptions, WidgetOptionField, WidgetOptionsContext, WidgetOptionsResult } from './types.js';
+/** A field, preset or period id: short, no separators that form paths. */
+export declare const IDENTIFIER_PATTERN: RegExp;
+/** `Class`, `pkg:Class` or `@scope/pkg:Class`. */
+export declare const MODEL_PATTERN: RegExp;
+/** Throws when a schema is malformed: unsafe or duplicate keys, empty enums, invalid defaults. */
+export declare function assertWidgetOptionFields(type: string, fields: readonly WidgetOptionField[]): void;
+/** The options a new widget starts with: every field that has a default. */
+export declare function defaultWidgetOptions(fields: readonly WidgetOptionField[]): OverviewOptions;
+/**
+ * Validate untrusted options against a schema. Strict: an unknown key, a
+ * wrong type, an out-of-range number, a value outside a closed set, or a
+ * missing required field fails the whole object (all issues are reported).
+ * Missing optional fields take their default, or stay absent. A `null` value
+ * counts as missing. The result contains only schema keys, in schema order.
+ */
+export declare function validateWidgetOptions(fields: readonly WidgetOptionField[], raw: unknown, context?: WidgetOptionsContext): WidgetOptionsResult;
+/** Structural equality of two option objects (primitives only). */
+export declare function optionsEqual(a: OverviewOptions | undefined, b: OverviewOptions | undefined): boolean;
+//# sourceMappingURL=schema.d.ts.map

package/dist/components/overview/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/components/overview/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EACV,eAAe,EAEf,iBAAiB,EAEjB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAGpB,0EAA0E;AAC1E,eAAO,MAAM,kBAAkB,QAAoC,CAAC;AACpE,kDAAkD;AAClD,eAAO,MAAM,aAAa,QAC4D,CAAC;AAavF,kGAAkG;AAClG,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,iBAAiB,EAAE,GACnC,IAAI,CAwBN;AAwED,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,iBAAiB,EAAE,GACnC,eAAe,CAQjB;AAuBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,SAAS,iBAAiB,EAAE,EACpC,GAAG,EAAE,OAAO,EACZ,OAAO,CAAC,EAAE,oBAAoB,GAC7B,mBAAmB,CA+BrB;AAED,mEAAmE;AACnE,wBAAgB,YAAY,CAC1B,CAAC,EAAE,eAAe,GAAG,SAAS,EAC9B,CAAC,EAAE,eAAe,GAAG,SAAS,GAC7B,OAAO,CAQT"}

package/dist/components/overview/schema.js

@@ -0,0 +1,180 @@
+const KEY_PATTERN = /^[A-Za-z][A-Za-z0-9]{0,31}$/;
+/** A field, preset or period id: short, no separators that form paths. */
+export const IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_.-]{0,63}$/;
+/** `Class`, `pkg:Class` or `@scope/pkg:Class`. */
+export const MODEL_PATTERN = /^(?:(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*:)?[A-Za-z][A-Za-z0-9_]{0,63}$/;
+const MODEL_MAX_LENGTH = 160;
+const DEFAULT_TEXT_MAX = 200;
+const DEFAULT_MARKDOWN_MAX = 10_000;
+function isPlainRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/** Throws when a schema is malformed: unsafe or duplicate keys, empty enums, invalid defaults. */
+export function assertWidgetOptionFields(type, fields) {
+    const seen = new Set();
+    for (const field of fields) {
+        if (!KEY_PATTERN.test(field.key)) {
+            throw new Error(`widget "${type}": invalid option key "${field.key}"`);
+        }
+        if (seen.has(field.key)) {
+            throw new Error(`widget "${type}": duplicate option key "${field.key}"`);
+        }
+        seen.add(field.key);
+        if (field.type === 'enum' && !field.choices?.length) {
+            throw new Error(`widget "${type}": enum option "${field.key}" needs choices`);
+        }
+        if (field.default !== undefined && field.default !== null) {
+            const check = validateField(field, field.default, undefined);
+            if (check.issue) {
+                throw new Error(`widget "${type}": default of option "${field.key}" is invalid`);
+            }
+        }
+    }
+}
+function fail(key, code) {
+    return { issue: { key, code } };
+}
+function validateField(field, raw, context) {
+    const { key } = field;
+    switch (field.type) {
+        case 'text':
+        case 'markdown': {
+            if (typeof raw !== 'string')
+                return fail(key, 'invalid_type');
+            const max = field.maxLength ??
+                (field.type === 'markdown' ? DEFAULT_MARKDOWN_MAX : DEFAULT_TEXT_MAX);
+            if (raw.length > max)
+                return fail(key, 'too_long');
+            return { value: raw };
+        }
+        case 'identifier': {
+            if (typeof raw !== 'string')
+                return fail(key, 'invalid_type');
+            if (!IDENTIFIER_PATTERN.test(raw))
+                return fail(key, 'invalid_format');
+            return { value: raw };
+        }
+        case 'model': {
+            if (typeof raw !== 'string')
+                return fail(key, 'invalid_type');
+            if (raw.length > MODEL_MAX_LENGTH || !MODEL_PATTERN.test(raw)) {
+                return fail(key, 'invalid_format');
+            }
+            if (context?.models && !context.models.includes(raw)) {
+                return fail(key, 'not_allowed');
+            }
+            return { value: raw };
+        }
+        case 'enum': {
+            if (typeof raw !== 'string')
+                return fail(key, 'invalid_type');
+            if (!field.choices?.some((choice) => choice.value === raw)) {
+                return fail(key, 'not_in_choices');
+            }
+            return { value: raw };
+        }
+        case 'boolean': {
+            if (typeof raw !== 'boolean')
+                return fail(key, 'invalid_type');
+            return { value: raw };
+        }
+        case 'integer':
+        case 'number': {
+            if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+                return fail(key, 'invalid_type');
+            }
+            if (field.type === 'integer' && !Number.isSafeInteger(raw)) {
+                return fail(key, 'invalid_type');
+            }
+            if ((field.min !== undefined && raw < field.min) ||
+                (field.max !== undefined && raw > field.max)) {
+                return fail(key, 'out_of_range');
+            }
+            return { value: raw };
+        }
+    }
+}
+/** The options a new widget starts with: every field that has a default. */
+export function defaultWidgetOptions(fields) {
+    const options = {};
+    for (const field of fields) {
+        if (field.default !== undefined && field.default !== null) {
+            options[field.key] = field.default;
+        }
+    }
+    return options;
+}
+/**
+ * Fill a missing or cleared field from its default, or report it required.
+ * A substituted default goes through the same check as a supplied value
+ * (including the page-confined `models` list): a default the page does not
+ * allow fails like any other disallowed value, so a loader never runs for it.
+ */
+function substituteDefault(field, context, options, issues) {
+    if (field.default !== undefined && field.default !== null) {
+        const check = validateField(field, field.default, context);
+        if (check.issue)
+            issues.push(check.issue);
+        else if (check.value !== undefined)
+            options[field.key] = check.value;
+    }
+    else if (field.required) {
+        issues.push({ key: field.key, code: 'required' });
+    }
+}
+/**
+ * Validate untrusted options against a schema. Strict: an unknown key, a
+ * wrong type, an out-of-range number, a value outside a closed set, or a
+ * missing required field fails the whole object (all issues are reported).
+ * Missing optional fields take their default, or stay absent. A `null` value
+ * counts as missing. The result contains only schema keys, in schema order.
+ */
+export function validateWidgetOptions(fields, raw, context) {
+    const issues = [];
+    const input = raw === undefined || raw === null ? {} : isPlainRecord(raw) ? raw : {};
+    if (raw !== undefined && raw !== null && !isPlainRecord(raw)) {
+        issues.push({ key: '', code: 'invalid_type' });
+        return { ok: false, issues };
+    }
+    const known = new Set(fields.map((field) => field.key));
+    for (const key of Object.keys(input)) {
+        if (!known.has(key))
+            issues.push({ key, code: 'unknown_option' });
+    }
+    const options = {};
+    for (const field of fields) {
+        const value = Object.hasOwn(input, field.key)
+            ? input[field.key]
+            : undefined;
+        if (value === undefined || value === null) {
+            substituteDefault(field, context, options, issues);
+            continue;
+        }
+        // A cleared select or identifier box behaves as unset.
+        if (value === '' && field.type !== 'text' && field.type !== 'markdown') {
+            substituteDefault(field, context, options, issues);
+            continue;
+        }
+        const check = validateField(field, value, context);
+        if (check.issue)
+            issues.push(check.issue);
+        else if (check.value !== undefined)
+            options[field.key] = check.value;
+    }
+    return issues.length > 0 ? { ok: false, issues } : { ok: true, options };
+}
+/** Structural equality of two option objects (primitives only). */
+export function optionsEqual(a, b) {
+    const left = a ?? {};
+    const right = b ?? {};
+    const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+    for (const key of keys) {
+        if ((left[key] ?? null) !== (right[key] ?? null))
+            return false;
+    }
+    return true;
+}

package/dist/components/overview/server.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @happyvertical/smrt-svelte/overview/server
+ *
+ * The Svelte-free half of the overview surface (#3727): the data model, option
+ * schemas, widget registry, and the server load contract. Safe to import from
+ * a `+page.server.ts` or a save endpoint.
+ */
+export { type LoadOverviewOptions, loadOverview, type WidgetLoadInput, } from './load.js';
+export { applyOverviewOverride, checkOverviewOverride, defineOverview, diffOverview, isEmptyOverride, nextWidgetId, type OverviewOverrideCheck, parseOverviewDocument, parseOverviewOverride, type ResolvedOverview, resolveOverview, type SanitizeOptions, sanitizeOverview, } from './model.js';
+export { parseRecipeExportRef, type RecipeExportResolver, type RecipeWidgetRegistration, type RecipeWidgetSkip, type RecipeWidgetSkipReason, type RecipeWidgetSource, type RegisterRecipeWidgetsOptions, registerRecipeWidgets, } from './recipe-widgets.js';
+export { createWidgetRegistry, defaultWidgetRegistry, registerWidget, resolveWidgetComponents, type WidgetComponents, WidgetRegistry, } from './registry.js';
+export { assertWidgetOptionFields, defaultWidgetOptions, IDENTIFIER_PATTERN, MODEL_PATTERN, optionsEqual, validateWidgetOptions, } from './schema.js';
+export * from './types.js';
+//# sourceMappingURL=server.d.ts.map

package/dist/components/overview/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/components/overview/server.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,KAAK,mBAAmB,EACxB,YAAY,EACZ,KAAK,eAAe,GACrB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,cAAc,EACd,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,KAAK,qBAAqB,EAC1B,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,gBAAgB,EACrB,eAAe,EACf,KAAK,eAAe,EACpB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,oBAAoB,EACpB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACvB,KAAK,4BAA4B,EACjC,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,cAAc,EACd,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,cAAc,GACf,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EACb,YAAY,EACZ,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,cAAc,YAAY,CAAC"}

package/dist/components/overview/server.js

@@ -0,0 +1,13 @@
+/**
+ * @happyvertical/smrt-svelte/overview/server
+ *
+ * The Svelte-free half of the overview surface (#3727): the data model, option
+ * schemas, widget registry, and the server load contract. Safe to import from
+ * a `+page.server.ts` or a save endpoint.
+ */
+export { loadOverview, } from './load.js';
+export { applyOverviewOverride, checkOverviewOverride, defineOverview, diffOverview, isEmptyOverride, nextWidgetId, parseOverviewDocument, parseOverviewOverride, resolveOverview, sanitizeOverview, } from './model.js';
+export { parseRecipeExportRef, registerRecipeWidgets, } from './recipe-widgets.js';
+export { createWidgetRegistry, defaultWidgetRegistry, registerWidget, resolveWidgetComponents, WidgetRegistry, } from './registry.js';
+export { assertWidgetOptionFields, defaultWidgetOptions, IDENTIFIER_PATTERN, MODEL_PATTERN, optionsEqual, validateWidgetOptions, } from './schema.js';
+export * from './types.js';