@svadmin/surface 0.1.0

package/dist/components/ResourceTableWidget.svelte

@@ -0,0 +1,100 @@
+<script lang="ts">
+  import CardContent from '@svadmin/ui/components/ui/card/card-content.svelte';
+  import CardHeader from '@svadmin/ui/components/ui/card/card-header.svelte';
+  import CardTitle from '@svadmin/ui/components/ui/card/card-title.svelte';
+  import Card from '@svadmin/ui/components/ui/card/card.svelte';
+  import TableBody from '@svadmin/ui/components/ui/table/table-body.svelte';
+  import TableCell from '@svadmin/ui/components/ui/table/table-cell.svelte';
+  import TableHead from '@svadmin/ui/components/ui/table/table-head.svelte';
+  import TableHeader from '@svadmin/ui/components/ui/table/table-header.svelte';
+  import TableRow from '@svadmin/ui/components/ui/table/table-row.svelte';
+  import Table from '@svadmin/ui/components/ui/table/table.svelte';
+  import { resourceTablePropsSchema } from '../builtin-schemas.js';
+  import type { SurfaceWidgetRendererProps } from '../catalog.js';
+  import { asRecordArray, displayTableValue } from '../widget-data.js';
+
+  let { props, data }: SurfaceWidgetRendererProps = $props();
+
+  const tableProps = $derived(resourceTablePropsSchema.parse(props));
+  const records = $derived(data.status === 'ready' ? asRecordArray(data.value) : null);
+</script>
+
+<Card>
+  <CardHeader>
+    <CardTitle>{tableProps.title}</CardTitle>
+  </CardHeader>
+  <CardContent>
+    {#if data.status === 'loading'}
+      <div class="table-state table-loading" role="status">Loading table</div>
+    {:else if data.status === 'empty'}
+      <p class="table-state" role="status">{tableProps.emptyLabel ?? 'No records'}</p>
+    {:else if data.status === 'error'}
+      <p class="table-state" role="alert">{data.error.message}</p>
+    {:else if data.status === 'ready' && records?.ok}
+      <div class="surface-table">
+        <Table aria-label={tableProps.title}>
+          <TableHeader>
+            <TableRow>
+              {#each tableProps.columns as column (column.field)}
+                <TableHead scope="col">{column.label}</TableHead>
+              {/each}
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {#each records.value as record, index (index)}
+              <TableRow>
+                {#each tableProps.columns as column (column.field)}
+                  <TableCell>{displayTableValue(record[column.field], column.format)}</TableCell>
+                {/each}
+              </TableRow>
+            {/each}
+          </TableBody>
+        </Table>
+      </div>
+    {:else}
+      <p class="table-state" role="alert">{records && !records.ok ? records.message : 'Table data is unavailable'}</p>
+    {/if}
+  </CardContent>
+</Card>
+
+<style>
+  .table-state {
+    display: grid;
+    min-height: 8rem;
+    margin: 0;
+    place-items: center;
+    color: var(--muted-foreground);
+  }
+
+  .table-loading {
+    border-radius: 0.5rem;
+    background: linear-gradient(90deg, var(--muted), var(--card), var(--muted));
+    background-size: 200% 100%;
+    animation: surface-pulse 1.5s ease-in-out infinite;
+  }
+
+  @keyframes surface-pulse {
+    to { background-position: -200% 0; }
+  }
+
+  @media (prefers-reduced-motion: reduce) {
+    .table-loading { animation: none; }
+  }
+
+  @media (max-width: 47.999rem) {
+    .surface-table :global([data-slot='table-container']) {
+      overflow-x: visible;
+    }
+
+    .surface-table :global([data-slot='table']) {
+      table-layout: fixed;
+    }
+
+    .surface-table :global([data-slot='table-head']),
+    .surface-table :global([data-slot='table-cell']) {
+      padding-inline: 0.375rem;
+      overflow-wrap: anywhere;
+      white-space: normal;
+    }
+  }
+</style>

package/dist/components/ResourceTableWidget.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { SurfaceWidgetRendererProps } from '../catalog.js';
+declare const ResourceTableWidget: import("svelte").Component<SurfaceWidgetRendererProps, {}, "">;
+type ResourceTableWidget = ReturnType<typeof ResourceTableWidget>;
+export default ResourceTableWidget;

package/dist/components/SurfaceRenderer.svelte

@@ -0,0 +1,231 @@
+<script lang="ts">
+  import { canAccessAsync, captureAdminContext } from '@svadmin/core';
+  import { untrack } from 'svelte';
+  import { resolveSurfaceWidgetData } from '../binding.js';
+  import { defaultSurfaceCatalog } from '../catalog.js';
+  import type { SurfaceRenderCatalog } from '../catalog.js';
+  import { loadSurfaceSource } from '../runtime.js';
+  import type {
+    SurfaceDataError,
+    SurfaceDataProvider,
+    SurfaceDataSource,
+    SurfacePolicy,
+    SurfaceSourceDataState,
+    SurfaceValidationIssue,
+  } from '../types.js';
+  import { validateSurfaceSpec } from '../validation.js';
+
+  export type SurfaceRendererError =
+    | { readonly type: 'validation'; readonly issues: readonly SurfaceValidationIssue[] }
+    | { readonly type: 'data'; readonly error: SurfaceDataError };
+
+  export interface SurfaceRendererProps {
+    readonly spec: unknown;
+    readonly policy: SurfacePolicy;
+    readonly catalog?: SurfaceRenderCatalog;
+    readonly dataProvider?: SurfaceDataProvider;
+    readonly class?: string;
+    readonly onError?: (error: SurfaceRendererError) => void;
+  }
+
+  let {
+    spec,
+    policy,
+    catalog = defaultSurfaceCatalog,
+    dataProvider,
+    class: className = '',
+    onError,
+  }: SurfaceRendererProps = $props();
+
+  const adminContext = captureAdminContext();
+  const validation = $derived(validateSurfaceSpec(spec, catalog, policy));
+  const widgetRegistrations = $derived(new Map(catalog.widgets.map((widget) => [widget.type, widget])));
+  const currentSpec = $derived(validation.ok ? validation.value : null);
+  const sourceGenerations: Record<string, number> = Object.create(null) as Record<string, number>;
+  let sourceStates = $state.raw<Record<string, SurfaceSourceDataState>>({});
+
+  function nextGeneration(sourceId: string): number {
+    const generation = (sourceGenerations[sourceId] ?? 0) + 1;
+    sourceGenerations[sourceId] = generation;
+    return generation;
+  }
+
+  function setSourceState(sourceId: string, state: SurfaceSourceDataState): void {
+    sourceStates = { ...sourceStates, [sourceId]: state };
+  }
+
+  function providerFor(resource: string): SurfaceDataProvider {
+    return dataProvider ?? adminContext.getDataProviderForResource(resource);
+  }
+
+  async function authorize(resource: string, action: 'list' | 'show') {
+    return canAccessAsync(resource, action);
+  }
+
+  function providerError(sourceId: string, failure: unknown): SurfaceSourceDataState {
+    const message = failure instanceof Error ? failure.message : 'Data provider is unavailable';
+    return {
+      status: 'error',
+      sourceId,
+      error: { code: 'provider_failed', sourceId, message },
+    };
+  }
+
+  async function loadSource(source: SurfaceDataSource): Promise<void> {
+    const generation = nextGeneration(source.id);
+    setSourceState(source.id, { status: 'loading', sourceId: source.id });
+
+    let result: SurfaceSourceDataState;
+    try {
+      const resourcePolicy = Object.hasOwn(policy.resources, source.resource)
+        ? policy.resources[source.resource]
+        : undefined;
+      if (!resourcePolicy) throw new Error(`Resource "${source.resource}" is not allowed`);
+      result = await loadSurfaceSource({
+        source,
+        resourcePolicy,
+        provider: providerFor(source.resource),
+        authorize,
+      });
+    } catch (failure) {
+      result = providerError(source.id, failure);
+    }
+
+    if (sourceGenerations[source.id] !== generation) return;
+    setSourceState(source.id, result);
+    if (result.status === 'error') onError?.({ type: 'data', error: result.error });
+  }
+
+  async function loadSources(sources: readonly SurfaceDataSource[]): Promise<void> {
+    await Promise.all(sources.map(loadSource));
+  }
+
+  function invalidateCurrentSources(): void {
+    for (const sourceId of Object.keys(sourceGenerations)) nextGeneration(sourceId);
+    sourceStates = {};
+  }
+
+  export async function refresh(sourceId?: string): Promise<void> {
+    const activeSpec = currentSpec;
+    if (!activeSpec) return;
+    const sources = sourceId === undefined
+      ? activeSpec.dataSources
+      : activeSpec.dataSources.filter((source) => source.id === sourceId);
+    await loadSources(sources);
+  }
+
+  $effect(() => {
+    const validatedSpec = validation;
+    void dataProvider;
+    invalidateCurrentSources();
+    if (!validatedSpec.ok) {
+      onError?.({ type: 'validation', issues: validatedSpec.issues });
+      return;
+    }
+
+    untrack(() => {
+      void loadSources(validatedSpec.value.dataSources);
+    });
+  });
+</script>
+
+{#if validation.ok}
+  <section
+    class="surface {className}"
+    aria-labelledby="surface-{validation.value.surfaceId}-title"
+    data-surface-id={validation.value.surfaceId}
+  >
+    <header class="surface-header">
+      <h2 id="surface-{validation.value.surfaceId}-title">{validation.value.title}</h2>
+    </header>
+    <div class="surface-grid surface-gap-{validation.value.layout.gap ?? 'md'}">
+      {#each validation.value.widgets as widget (widget.id)}
+        {@const registration = widgetRegistrations.get(widget.type)}
+        {@const WidgetComponent = registration?.component}
+        <div
+          class="surface-widget surface-span-{widget.placement?.columnSpan ?? 12}"
+          data-testid="surface-widget-{widget.id}"
+        >
+          {#if WidgetComponent}
+            <WidgetComponent
+              widgetId={widget.id}
+              props={widget.props}
+              data={resolveSurfaceWidgetData(widget, sourceStates)}
+            />
+          {/if}
+        </div>
+      {/each}
+    </div>
+  </section>
+{:else}
+  <section class="surface-error {className}" role="alert" data-surface-error>
+    <h2>Surface could not be rendered</h2>
+    <ul>
+      {#each validation.issues as issue, issueIndex (`${issue.code}:${issue.path}:${issueIndex}`)}
+        <li><code>{issue.code}</code>: {issue.message}</li>
+      {/each}
+    </ul>
+  </section>
+{/if}
+
+<style>
+  .surface,
+  .surface-error {
+    width: 100%;
+    min-width: 0;
+  }
+
+  .surface-header {
+    margin-bottom: 1rem;
+  }
+
+  .surface-header h2,
+  .surface-error h2 {
+    margin: 0;
+    color: var(--foreground);
+    font-size: clamp(1.25rem, 2vw, 1.75rem);
+    line-height: 1.2;
+  }
+
+  .surface-grid {
+    display: grid;
+    grid-template-columns: repeat(12, minmax(0, 1fr));
+  }
+
+  .surface-gap-sm { gap: 0.5rem; }
+  .surface-gap-md { gap: 1rem; }
+  .surface-gap-lg { gap: 1.5rem; }
+
+  .surface-widget {
+    grid-column: 1 / -1;
+    min-width: 0;
+  }
+
+  .surface-error {
+    padding: 1rem;
+    border: 1px solid var(--destructive);
+    border-radius: 0.75rem;
+    background: var(--card);
+    color: var(--destructive);
+  }
+
+  .surface-error ul {
+    margin: 0.75rem 0 0;
+    padding-left: 1.25rem;
+  }
+
+  @media (min-width: 48rem) {
+    .surface-span-1 { grid-column: span 1; }
+    .surface-span-2 { grid-column: span 2; }
+    .surface-span-3 { grid-column: span 3; }
+    .surface-span-4 { grid-column: span 4; }
+    .surface-span-5 { grid-column: span 5; }
+    .surface-span-6 { grid-column: span 6; }
+    .surface-span-7 { grid-column: span 7; }
+    .surface-span-8 { grid-column: span 8; }
+    .surface-span-9 { grid-column: span 9; }
+    .surface-span-10 { grid-column: span 10; }
+    .surface-span-11 { grid-column: span 11; }
+    .surface-span-12 { grid-column: span 12; }
+  }
+</style>

package/dist/components/SurfaceRenderer.svelte.d.ts

@@ -0,0 +1,22 @@
+import type { SurfaceRenderCatalog } from '../catalog.js';
+import type { SurfaceDataError, SurfaceDataProvider, SurfacePolicy, SurfaceValidationIssue } from '../types.js';
+export type SurfaceRendererError = {
+    readonly type: 'validation';
+    readonly issues: readonly SurfaceValidationIssue[];
+} | {
+    readonly type: 'data';
+    readonly error: SurfaceDataError;
+};
+export interface SurfaceRendererProps {
+    readonly spec: unknown;
+    readonly policy: SurfacePolicy;
+    readonly catalog?: SurfaceRenderCatalog;
+    readonly dataProvider?: SurfaceDataProvider;
+    readonly class?: string;
+    readonly onError?: (error: SurfaceRendererError) => void;
+}
+declare const SurfaceRenderer: import("svelte").Component<SurfaceRendererProps, {
+    refresh: (sourceId?: string) => Promise<void>;
+}, "">;
+type SurfaceRenderer = ReturnType<typeof SurfaceRenderer>;
+export default SurfaceRenderer;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { SURFACE_LIMITS, SURFACE_SCHEMA_VERSION } from './types.js';
+export type { JsonObject, JsonPrimitive, JsonValue, ResourceListDataSource, ResourceListSource, ResourceOneDataSource, ResourceOneSource, SurfaceBinding, SurfaceCatalog, SurfaceCatalogDataKind, SurfaceDataError, SurfaceDataProvider, SurfaceDataSource, SurfaceFilter, SurfaceGridLayout, SurfaceGridSpan, SurfacePolicy, SurfaceResourcePolicy, SurfaceSort, SurfaceSpec, SurfaceValidationCode, SurfaceValidationIssue, SurfaceValidationResult, SurfaceWidget, SurfaceWidgetDataState, SurfaceWidgetDefinition, } from './types.js';
+export { validateSurfaceSpec } from './validation.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { SURFACE_LIMITS, SURFACE_SCHEMA_VERSION } from './types.js';
+export { validateSurfaceSpec } from './validation.js';

package/dist/json.d.ts

@@ -0,0 +1,10 @@
+import type { JsonValue } from './types.js';
+export interface JsonValueIssue {
+    readonly path: readonly (string | number)[];
+    readonly message: string;
+}
+export declare function escapedJsonPointerToken(token: string): string;
+export declare function jsonPointer(pathSegments: readonly (string | number)[]): string;
+export declare function decodedJsonPointerToken(token: string): string | null;
+export declare function jsonValueIssue(input: unknown): JsonValueIssue | null;
+export declare function isJsonValue(input: unknown): input is JsonValue;

package/dist/json.js

@@ -0,0 +1,115 @@
+import { SURFACE_LIMITS } from './types.js';
+const dangerousObjectKeys = new Set(['__proto__', 'constructor', 'prototype']);
+export function escapedJsonPointerToken(token) {
+    return token.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+export function jsonPointer(pathSegments) {
+    return pathSegments.length === 0
+        ? ''
+        : `/${pathSegments.map((segment) => escapedJsonPointerToken(String(segment))).join('/')}`;
+}
+export function decodedJsonPointerToken(token) {
+    if (/~(?:[^01]|$)/u.test(token))
+        return null;
+    const decoded = token.replaceAll('~1', '/').replaceAll('~0', '~');
+    return dangerousObjectKeys.has(decoded) ? null : decoded;
+}
+function primitiveIssue(candidate, path) {
+    if (candidate === null || typeof candidate === 'string' || typeof candidate === 'boolean')
+        return null;
+    if (typeof candidate === 'number')
+        return Number.isFinite(candidate) ? null : { path, message: 'Numbers must be finite' };
+    return { path, message: 'Value must be JSON serializable' };
+}
+export function jsonValueIssue(input) {
+    const ancestors = new WeakSet();
+    const pending = [{ kind: 'visit', candidate: input, path: [], depth: 0 }];
+    let visitedNodes = 0;
+    try {
+        while (pending.length > 0) {
+            const frame = pending.pop();
+            if (!frame)
+                break;
+            if (frame.kind === 'leave') {
+                ancestors.delete(frame.candidate);
+                continue;
+            }
+            const { candidate, path, depth } = frame;
+            visitedNodes += 1;
+            if (visitedNodes > SURFACE_LIMITS.maxJsonNodes) {
+                return { path, message: 'JSON value exceeds the supported node count' };
+            }
+            if (depth > SURFACE_LIMITS.maxJsonDepth) {
+                return { path, message: 'JSON nesting exceeds the supported depth' };
+            }
+            if (typeof candidate !== 'object' || candidate === null) {
+                const issue = primitiveIssue(candidate, path);
+                if (issue)
+                    return issue;
+                continue;
+            }
+            if (ancestors.has(candidate))
+                return { path, message: 'Cyclic values are not allowed' };
+            const prototype = Object.getPrototypeOf(candidate);
+            if (!Array.isArray(candidate) && prototype !== Object.prototype && prototype !== null) {
+                return { path, message: 'Only plain JSON objects are allowed' };
+            }
+            ancestors.add(candidate);
+            pending.push({ kind: 'leave', candidate });
+            if (Array.isArray(candidate)) {
+                if (candidate.length + visitedNodes > SURFACE_LIMITS.maxJsonNodes) {
+                    return { path, message: 'JSON value exceeds the supported node count' };
+                }
+                for (const key of Reflect.ownKeys(candidate)) {
+                    if (key === 'length')
+                        continue;
+                    if (typeof key !== 'string')
+                        return { path, message: 'Symbol properties are not allowed' };
+                    if (!/^(?:0|[1-9][0-9]*)$/u.test(key) || Number(key) >= candidate.length) {
+                        return { path: [...path, key], message: 'Only JSON array indexes are allowed' };
+                    }
+                }
+                for (let index = candidate.length - 1; index >= 0; index -= 1) {
+                    const descriptor = Object.getOwnPropertyDescriptor(candidate, String(index));
+                    if (!descriptor)
+                        return { path: [...path, index], message: 'Sparse arrays are not allowed' };
+                    if (!descriptor.enumerable) {
+                        return { path: [...path, index], message: 'Non-enumerable properties are not allowed' };
+                    }
+                    if (!('value' in descriptor)) {
+                        return { path: [...path, index], message: 'Accessor properties are not allowed' };
+                    }
+                    pending.push({ kind: 'visit', candidate: descriptor.value, path: [...path, index], depth: depth + 1 });
+                }
+                continue;
+            }
+            const entries = [];
+            for (const key of Reflect.ownKeys(candidate)) {
+                if (typeof key !== 'string')
+                    return { path, message: 'Symbol properties are not allowed' };
+                if (dangerousObjectKeys.has(key)) {
+                    return { path: [...path, key], message: `Property "${key}" is not allowed` };
+                }
+                const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+                if (!descriptor || !descriptor.enumerable) {
+                    return { path: [...path, key], message: 'Non-enumerable properties are not allowed' };
+                }
+                if (!('value' in descriptor)) {
+                    return { path: [...path, key], message: 'Accessor properties are not allowed' };
+                }
+                entries.push([key, descriptor.value]);
+            }
+            for (let index = entries.length - 1; index >= 0; index -= 1) {
+                const [key, entry] = entries[index];
+                pending.push({ kind: 'visit', candidate: entry, path: [...path, key], depth: depth + 1 });
+            }
+        }
+    }
+    catch {
+        return { path: [], message: 'Value could not be inspected safely' };
+    }
+    return null;
+}
+export function isJsonValue(input) {
+    return jsonValueIssue(input) === null;
+}

package/dist/runtime.d.ts

@@ -0,0 +1,17 @@
+import type { SurfaceDataProvider, SurfaceDataSource, SurfaceResourcePolicy, SurfaceWidgetDataState } from './types.js';
+export type SurfaceReadAction = 'list' | 'show';
+export interface SurfaceAccessDecision {
+    readonly can: boolean;
+    readonly reason?: string;
+}
+export type SurfaceAuthorizer = (resource: string, action: SurfaceReadAction) => Promise<SurfaceAccessDecision>;
+export interface LoadSurfaceSourceRequest {
+    readonly source: SurfaceDataSource;
+    readonly resourcePolicy: SurfaceResourcePolicy;
+    readonly provider: SurfaceDataProvider;
+    readonly authorize: SurfaceAuthorizer;
+}
+export type SurfaceLoadedSourceState = Extract<SurfaceWidgetDataState, {
+    status: 'ready' | 'error';
+}>;
+export declare function loadSurfaceSource(request: LoadSurfaceSourceRequest): Promise<SurfaceLoadedSourceState>;

package/dist/runtime.js

@@ -0,0 +1,128 @@
+import { isJsonValue, jsonValueIssue } from './json.js';
+function isPlainRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function ownDataProperty(record, property) {
+    const descriptor = Object.getOwnPropertyDescriptor(record, property);
+    if (!descriptor)
+        return { ok: false, message: `Provider result must define "${property}"` };
+    return 'value' in descriptor
+        ? { ok: true, value: descriptor.value }
+        : { ok: false, message: `Provider result field "${property}" must be a data property` };
+}
+function projectRecord(record, readableFields) {
+    if (!isPlainRecord(record))
+        return { ok: false, message: 'Provider records must be plain objects' };
+    const projectedRecord = Object.create(null);
+    for (const field of readableFields) {
+        const descriptor = Object.getOwnPropertyDescriptor(record, field);
+        if (!descriptor)
+            continue;
+        if (!('value' in descriptor)) {
+            return { ok: false, message: `Field "${field}" must be a data property` };
+        }
+        const fieldValue = descriptor.value;
+        if (!isJsonValue(fieldValue)) {
+            const issue = jsonValueIssue(fieldValue);
+            return { ok: false, message: `Field "${field}" is not JSON serializable: ${issue?.message ?? 'invalid value'}` };
+        }
+        projectedRecord[field] = fieldValue;
+    }
+    return { ok: true, value: projectedRecord };
+}
+function projectRecords(records, readableFields) {
+    const projectedRecords = [];
+    for (const record of records) {
+        const projection = projectRecord(record, readableFields);
+        if (!projection.ok)
+            return projection;
+        projectedRecords.push(projection.value);
+    }
+    return { ok: true, value: projectedRecords };
+}
+function sourceError(sourceId, code, message) {
+    return { status: 'error', sourceId, error: { code, sourceId, message } };
+}
+function listParams(source) {
+    const sorters = source.sorters?.map((sorter) => ({ ...sorter })) ?? [];
+    const filters = source.filters?.map((filter) => {
+        if (!('value' in filter))
+            return { ...filter, value: null };
+        return Array.isArray(filter.value)
+            ? { ...filter, value: [...filter.value] }
+            : { ...filter };
+    }) ?? [];
+    return {
+        resource: source.resource,
+        pagination: { current: 1, pageSize: source.pageSize ?? 10 },
+        sorters,
+        filters,
+    };
+}
+async function loadListSource(source, resourcePolicy, provider) {
+    const providerResponse = await provider.getList(listParams(source));
+    if (!isPlainRecord(providerResponse)) {
+        return sourceError(source.id, 'provider_result_not_json', 'List result must be a plain object');
+    }
+    const recordsProperty = ownDataProperty(providerResponse, 'data');
+    if (!recordsProperty.ok)
+        return sourceError(source.id, 'provider_result_not_json', recordsProperty.message);
+    const totalProperty = ownDataProperty(providerResponse, 'total');
+    if (!totalProperty.ok)
+        return sourceError(source.id, 'provider_result_not_json', totalProperty.message);
+    const records = recordsProperty.value;
+    const total = totalProperty.value;
+    if (!Array.isArray(records)) {
+        return sourceError(source.id, 'provider_result_not_json', 'List data must be an array');
+    }
+    if (typeof total !== 'number' || !Number.isFinite(total) || total < 0) {
+        return sourceError(source.id, 'provider_result_not_json', 'List total must be a non-negative finite number');
+    }
+    const projection = projectRecords(records, resourcePolicy.readFields);
+    if (!projection.ok)
+        return sourceError(source.id, 'provider_result_not_json', projection.message);
+    return {
+        status: 'ready',
+        sourceId: source.id,
+        value: { items: projection.value, total },
+    };
+}
+async function loadOneSource(source, resourcePolicy, provider) {
+    const providerResponse = await provider.getOne({ resource: source.resource, id: source.recordId });
+    if (!isPlainRecord(providerResponse)) {
+        return sourceError(source.id, 'provider_result_not_json', 'Get-one result must be a plain object');
+    }
+    const dataProperty = ownDataProperty(providerResponse, 'data');
+    if (!dataProperty.ok)
+        return sourceError(source.id, 'provider_result_not_json', dataProperty.message);
+    const projection = projectRecord(dataProperty.value, resourcePolicy.readFields);
+    return projection.ok
+        ? { status: 'ready', sourceId: source.id, value: projection.value }
+        : sourceError(source.id, 'provider_result_not_json', projection.message);
+}
+export async function loadSurfaceSource(request) {
+    const { source, resourcePolicy, provider, authorize } = request;
+    const action = source.type === 'resource-list' ? 'list' : 'show';
+    let accessDecision;
+    try {
+        accessDecision = await authorize(source.resource, action);
+    }
+    catch (accessFailure) {
+        const message = accessFailure instanceof Error ? accessFailure.message : 'Access check failed';
+        return sourceError(source.id, 'access_check_failed', message);
+    }
+    if (!accessDecision.can)
+        return sourceError(source.id, 'access_denied', accessDecision.reason ?? 'Access denied');
+    try {
+        return source.type === 'resource-list'
+            ? await loadListSource(source, resourcePolicy, provider)
+            : await loadOneSource(source, resourcePolicy, provider);
+    }
+    catch (providerFailure) {
+        const message = providerFailure instanceof Error ? providerFailure.message : 'Data provider request failed';
+        return sourceError(source.id, 'provider_failed', message);
+    }
+}

package/dist/svelte.d.ts

@@ -0,0 +1,4 @@
+export { default as SurfaceRenderer } from './components/SurfaceRenderer.svelte';
+export type { SurfaceRendererError, SurfaceRendererProps, } from './components/SurfaceRenderer.svelte';
+export { DEFAULT_SURFACE_CATALOG_VERSION, defaultSurfaceCatalog, defineSurfaceCatalog, } from './catalog.js';
+export type { SurfaceRenderCatalog, SurfaceWidgetRegistration, SurfaceWidgetRendererProps, } from './catalog.js';

package/dist/svelte.js

@@ -0,0 +1,2 @@
+export { default as SurfaceRenderer } from './components/SurfaceRenderer.svelte';
+export { DEFAULT_SURFACE_CATALOG_VERSION, defaultSurfaceCatalog, defineSurfaceCatalog, } from './catalog.js';