@shwfed/config 2.0.0 → 2.0.1

package/dist/runtime/share/layout.d.ts

@@ -0,0 +1,123 @@
+import { Schema } from 'effect';
+import { Expression } from './expression.js';
+import type { Environment } from '../vendor/cel-js/lib/index.js';
+export declare const Corner: Schema.Tuple2<Schema.filter<Schema.filter<typeof Schema.Number>>, Schema.filter<Schema.filter<typeof Schema.Number>>>;
+export declare const Area: Schema.refine<readonly [readonly [number, number], readonly [number, number]], Schema.Tuple2<Schema.Tuple2<Schema.filter<Schema.filter<typeof Schema.Number>>, Schema.filter<Schema.filter<typeof Schema.Number>>>, Schema.Tuple2<Schema.filter<Schema.filter<typeof Schema.Number>>, Schema.filter<Schema.filter<typeof Schema.Number>>>>>;
+export declare const Align: Schema.Literal<["start", "center", "end", "stretch"]>;
+export declare const Placement: Schema.Struct<{
+    area: Schema.refine<readonly [readonly [number, number], readonly [number, number]], Schema.Tuple2<Schema.Tuple2<Schema.filter<Schema.filter<typeof Schema.Number>>, Schema.filter<Schema.filter<typeof Schema.Number>>>, Schema.Tuple2<Schema.filter<Schema.filter<typeof Schema.Number>>, Schema.filter<Schema.filter<typeof Schema.Number>>>>>;
+    h: Schema.optional<Schema.Literal<["start", "center", "end", "stretch"]>>;
+    v: Schema.optional<Schema.Literal<["start", "center", "end", "stretch"]>>;
+}>;
+export declare const DEFAULT_GAP = 4;
+export declare const Layout: Schema.Struct<{
+    columns: Schema.refine<number, Schema.filter<typeof Schema.Number>>;
+    rows: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
+    gap: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
+    style: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    placements: Schema.Record$<typeof Schema.String, Schema.Struct<{
+        area: Schema.refine<readonly [readonly [number, number], readonly [number, number]], Schema.Tuple2<Schema.Tuple2<Schema.filter<Schema.filter<typeof Schema.Number>>, Schema.filter<Schema.filter<typeof Schema.Number>>>, Schema.Tuple2<Schema.filter<Schema.filter<typeof Schema.Number>>, Schema.filter<Schema.filter<typeof Schema.Number>>>>>;
+        h: Schema.optional<Schema.Literal<["start", "center", "end", "stretch"]>>;
+        v: Schema.optional<Schema.Literal<["start", "center", "end", "stretch"]>>;
+    }>>;
+}>;
+export declare function LayoutSet(configure: (env: Environment) => void): Schema.Struct<{
+    name: Schema.SchemaClass<string, string, never>;
+    media: Schema.optional<Schema.Schema<string, string, never>>;
+    layout: Schema.Struct<{
+        columns: Schema.refine<number, Schema.filter<typeof Schema.Number>>;
+        rows: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
+        gap: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
+        style: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        placements: Schema.Record$<typeof Schema.String, Schema.Struct<{
+            area: Schema.refine<readonly [readonly [number, number], readonly [number, number]], Schema.Tuple2<Schema.Tuple2<Schema.filter<Schema.filter<typeof Schema.Number>>, Schema.filter<Schema.filter<typeof Schema.Number>>>, Schema.Tuple2<Schema.filter<Schema.filter<typeof Schema.Number>>, Schema.filter<Schema.filter<typeof Schema.Number>>>>>;
+            h: Schema.optional<Schema.Literal<["start", "center", "end", "stretch"]>>;
+            v: Schema.optional<Schema.Literal<["start", "center", "end", "stretch"]>>;
+        }>>;
+    }>;
+}>;
+export type AlignValue = Schema.Schema.Type<typeof Align>;
+export type PlacementValue = Schema.Schema.Type<typeof Placement>;
+export type LayoutValue = Schema.Schema.Type<typeof Layout>;
+export type LayoutSetValue = Readonly<{
+    name: string;
+    media?: string;
+    layout: LayoutValue;
+}>;
+export type IdentifiableItem = Readonly<{
+    id: string;
+}>;
+export declare function validatePlacements(items: ReadonlyArray<IdentifiableItem>, layouts: ReadonlyArray<LayoutSetValue>, label: string): string | true;
+export declare function normalizeLayoutSet(ls: LayoutSetValue): LayoutSetValue;
+export declare function findFreePlacement(placements: Readonly<Record<string, PlacementValue>>, w: number, h: number): PlacementValue;
+type AnySchema = Schema.Schema<any, any, never>;
+export declare function Slot(BlockSchemaUnion: AnySchema, configure: (env: Environment) => void): Schema.refine<{
+    readonly blocks: readonly any[];
+    readonly layouts: readonly {
+        readonly name: string;
+        readonly layout: {
+            readonly style?: string | undefined;
+            readonly columns: number;
+            readonly gap?: number | undefined;
+            readonly rows?: number | undefined;
+            readonly placements: {
+                readonly [x: string]: {
+                    readonly area: readonly [readonly [number, number], readonly [number, number]];
+                    readonly v?: "stretch" | "center" | "end" | "start" | undefined;
+                    readonly h?: "stretch" | "center" | "end" | "start" | undefined;
+                };
+            };
+        };
+        readonly media?: string | undefined;
+    }[];
+}, Schema.Struct<{
+    blocks: Schema.Array$<AnySchema>;
+    layouts: Schema.refine<readonly {
+        readonly name: string;
+        readonly layout: {
+            readonly style?: string | undefined;
+            readonly columns: number;
+            readonly gap?: number | undefined;
+            readonly rows?: number | undefined;
+            readonly placements: {
+                readonly [x: string]: {
+                    readonly area: readonly [readonly [number, number], readonly [number, number]];
+                    readonly v?: "stretch" | "center" | "end" | "start" | undefined;
+                    readonly h?: "stretch" | "center" | "end" | "start" | undefined;
+                };
+            };
+        };
+        readonly media?: string | undefined;
+    }[], Schema.Array$<Schema.Struct<{
+        name: Schema.SchemaClass<string, string, never>;
+        media: Schema.optional<Schema.Schema<string, string, never>>;
+        layout: Schema.Struct<{
+            columns: Schema.refine<number, Schema.filter<typeof Schema.Number>>;
+            rows: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
+            gap: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
+            style: Schema.optional<Schema.SchemaClass<string, string, never>>;
+            placements: Schema.Record$<typeof Schema.String, Schema.Struct<{
+                area: Schema.refine<readonly [readonly [number, number], readonly [number, number]], Schema.Tuple2<Schema.Tuple2<Schema.filter<Schema.filter<typeof Schema.Number>>, Schema.filter<Schema.filter<typeof Schema.Number>>>, Schema.Tuple2<Schema.filter<Schema.filter<typeof Schema.Number>>, Schema.filter<Schema.filter<typeof Schema.Number>>>>>;
+                h: Schema.optional<Schema.Literal<["start", "center", "end", "stretch"]>>;
+                v: Schema.optional<Schema.Literal<["start", "center", "end", "stretch"]>>;
+            }>>;
+        }>;
+    }>>>;
+}>>;
+export { Expression };
+export type SlotValue = Readonly<{
+    blocks: ReadonlyArray<Readonly<{
+        id: string;
+    } & Record<string, unknown>>>;
+    layouts: ReadonlyArray<LayoutSetValue>;
+}>;
+/**
+ * Returns a fresh empty slot with one `默认` layout — enough to satisfy the
+ * schema's `minItems(1)` invariant. `blocks: never[]` keeps the result
+ * assignable to slots whose block union is narrower than `SlotValue`.
+ */
+export declare function defaultSlot(): {
+    blocks: never[];
+    layouts: LayoutSetValue[];
+};
+export declare function regenSlotIds(slot: SlotValue): SlotValue;

package/dist/runtime/share/layout.js

@@ -0,0 +1,220 @@
+import { Schema } from "effect";
+import { Expression } from "./expression.js";
+const TrackCount = Schema.Number.pipe(Schema.int(), Schema.positive());
+const GridCoord = Schema.Number.pipe(Schema.int(), Schema.positive());
+export const Corner = Schema.Tuple(GridCoord, GridCoord).annotations({
+  title: "Corner",
+  description: "[x, y] \u7F51\u683C\u7EBF\u53F7\uFF081 \u57FA\uFF09"
+});
+export const Area = Schema.Tuple(Corner, Corner).pipe(Schema.filter((a) => {
+  if (a[1][0] <= a[0][0]) return "\u53F3\u4E0B\u5217\u7EBF\u5FC5\u987B\u5927\u4E8E\u5DE6\u4E0A\u5217\u7EBF";
+  if (a[1][1] <= a[0][1]) return "\u53F3\u4E0B\u884C\u7EBF\u5FC5\u987B\u5927\u4E8E\u5DE6\u4E0A\u884C\u7EBF";
+  return true;
+})).annotations({
+  title: "Area",
+  description: "\u77E9\u5F62\u533A\u57DF\uFF1A`[[x1, y1], [x2, y2]]`\uFF0C\u5DE6\u4E0A + \u53F3\u4E0B\u5BF9\u89D2\uFF08\u7EC8\u6B62\u7EBF\u4E0D\u542B\uFF09"
+});
+export const Align = Schema.Literal("start", "center", "end", "stretch").annotations({
+  title: "Align",
+  description: "\u7F51\u683C\u9879\u5728\u5355\u8F74\u4E0A\u7684\u5BF9\u9F50\u65B9\u5F0F\uFF1B\u7F3A\u7701\u7B49\u540C\u4E8E stretch"
+});
+export const Placement = Schema.Struct({
+  area: Area,
+  h: Schema.optional(Align.annotations({ title: "\u6C34\u5E73\u5BF9\u9F50", description: "\u6C34\u5E73\u8F74\u5BF9\u9F50\uFF08justify-self\uFF09" })),
+  v: Schema.optional(Align.annotations({ title: "\u5782\u76F4\u5BF9\u9F50", description: "\u5782\u76F4\u8F74\u5BF9\u9F50\uFF08align-self\uFF09" }))
+}).annotations({
+  title: "Placement",
+  description: "\u5757\u5728\u67D0\u4E00\u5E03\u5C40\u4E2D\u7684\u4F4D\u7F6E\u4E0E\u5BF9\u9F50"
+});
+export const DEFAULT_GAP = 4;
+export const Layout = Schema.Struct({
+  columns: TrackCount.annotations({
+    title: "\u5217\u6570",
+    description: "\u603B\u5217\u6570\u3002\u6BCF\u5217\u7B49\u5BBD\uFF0C\u6E32\u67D3\u65F6\u5C55\u5F00\u4E3A `repeat(N, minmax(0, 1fr))` \u2014 \u5217\u4F1A\u6536\u7F29\u4EE5\u9002\u914D\u5BB9\u5668\u5BBD\u5EA6"
+  }),
+  rows: Schema.optional(TrackCount.annotations({
+    title: "\u884C\u6570",
+    description: "\u603B\u884C\u6570\u3002\u6BCF\u884C\u7B49\u6743\uFF0C\u6E32\u67D3\u65F6\u5C55\u5F00\u4E3A `repeat(N, minmax(0, 1fr))` \u2014 \u5728\u81EA\u7136\u9AD8\u5EA6\u5BB9\u5668\u5185\u7B49\u540C\u4E8E `auto`"
+  })),
+  gap: Schema.optional(Schema.Number.pipe(Schema.int(), Schema.nonNegative()).annotations({
+    title: "\u7F51\u683C\u95F4\u8DDD",
+    description: "\u975E\u8D1F\u6574\u6570\uFF1B\u5B9E\u9645 CSS gap \u4E3A `calc(n * 0.25rem)`\u3002\u663E\u5F0F `0` \u8868\u793A\u65E0\u95F4\u8DDD\uFF0C\u672A\u8BBE\u7F6E\u5219\u53D6\u9ED8\u8BA4\u95F4\u8DDD 4\uFF08\u5373 `1rem`\uFF09"
+  })),
+  style: Schema.optional(Schema.String.annotations({
+    title: "\u5BB9\u5668\u6837\u5F0F",
+    description: "\u5BB9\u5668\u7684\u5185\u8054\u6837\u5F0F\u5B57\u7B26\u4E32"
+  })),
+  placements: Schema.Record({
+    key: Schema.String,
+    value: Placement
+  }).annotations({
+    title: "\u4F4D\u7F6E",
+    description: "\u4EE5\u5757 `id` \u4E3A\u952E\u7684\u4F4D\u7F6E\u6620\u5C04\uFF1B\u672A\u6620\u5C04\u7684\u5757\u5728\u8BE5\u5E03\u5C40\u4E2D\u4E0D\u6E32\u67D3"
+  })
+}).annotations({
+  title: "Layout",
+  description: "\u4E00\u5957\u5B8C\u6574\u7684\u7F51\u683C\u5E03\u5C40"
+});
+function configureMedia(configure) {
+  return (env) => {
+    env.registerFunction(
+      "media(string): bool",
+      (_self, q) => typeof window !== "undefined" && window.matchMedia(q).matches,
+      { description: "\u5339\u914D CSS \u5A92\u4F53\u67E5\u8BE2\uFF0C\u7B49\u4EF7\u4E8E `window.matchMedia(q).matches`\uFF1BSSR \u4E0A\u4E0B\u6587\u8FD4\u56DE `false`" }
+    );
+    configure(env);
+  };
+}
+export function LayoutSet(configure) {
+  return Schema.Struct({
+    name: Schema.String.annotations({
+      title: "\u540D\u79F0",
+      description: "\u7F16\u8F91\u5668\u4E2D\u533A\u5206\u4E0D\u540C\u5E03\u5C40\u7684\u5185\u90E8\u540D\u79F0"
+    }),
+    media: Schema.optional(Expression({
+      configure: configureMedia(configure),
+      resultType: "bool"
+    }).annotations({
+      title: "\u5339\u914D\u6761\u4EF6",
+      description: "\u8FD4\u56DE `bool` \u7684 CEL \u8868\u8FBE\u5F0F\uFF0C\u6302\u8F7D\u65F6\u4E00\u6B21\u6027\u6C42\u503C\uFF1B\u7A7A\u8868\u793A\u65E0\u6761\u4EF6\u5339\u914D\u3002\u53EF\u7528 `media('(min-width: 1024px)')` \u5305\u88C5 CSS \u5A92\u4F53\u67E5\u8BE2\u3002"
+    })),
+    layout: Layout
+  }).annotations({
+    title: "LayoutSet",
+    description: "\u5E26\u5339\u914D\u6761\u4EF6\u7684\u5E03\u5C40\u96C6\u5408\u9879"
+  });
+}
+export function validatePlacements(items, layouts, label) {
+  const ids = new Set(items.map((it) => it.id));
+  for (const [i, set] of layouts.entries()) {
+    const nCols = set.layout.columns;
+    const nRows = set.layout.rows;
+    for (const [id, placement] of Object.entries(set.layout.placements)) {
+      if (!ids.has(id)) {
+        return `\u5E03\u5C40 #${i} (${set.name}) \u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684${label} id: ${id}`;
+      }
+      const [, [x2, y2]] = placement.area;
+      if (x2 > nCols + 1) {
+        return `\u5E03\u5C40 #${i} (${set.name}) ${label} ${id} \u7684\u5217\u533A\u57DF\u8D85\u51FA\u5217\u5B9A\u4E49\uFF08\u5171 ${nCols} \u5217\uFF09`;
+      }
+      if (nRows !== void 0 && y2 > nRows + 1) {
+        return `\u5E03\u5C40 #${i} (${set.name}) ${label} ${id} \u7684\u884C\u533A\u57DF\u8D85\u51FA\u884C\u5B9A\u4E49\uFF08\u5171 ${nRows} \u884C\uFF09`;
+      }
+    }
+  }
+  return true;
+}
+export function normalizeLayoutSet(ls) {
+  const entries = Object.entries(ls.layout.placements);
+  if (entries.length === 0) {
+    return {
+      ...ls,
+      layout: { ...ls.layout, columns: 1, ...ls.layout.rows !== void 0 ? { rows: 1 } : {} }
+    };
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  for (const [, p] of entries) {
+    if (p.area[0][0] < minX) minX = p.area[0][0];
+    if (p.area[0][1] < minY) minY = p.area[0][1];
+  }
+  const sx = minX !== 1 ? 1 - minX : 0;
+  const sy = minY !== 1 ? 1 - minY : 0;
+  const placements = sx || sy ? Object.fromEntries(entries.map(([id, p]) => {
+    const [[ax, ay], [bx, by]] = p.area;
+    return [id, { ...p, area: [[ax + sx, ay + sy], [bx + sx, by + sy]] }];
+  })) : Object.fromEntries(entries);
+  let cols = 0;
+  let rows = 0;
+  for (const p of Object.values(placements)) {
+    const [, [x2, y2]] = p.area;
+    if (x2 - 1 > cols) cols = x2 - 1;
+    if (y2 - 1 > rows) rows = y2 - 1;
+  }
+  return {
+    ...ls,
+    layout: {
+      ...ls.layout,
+      placements,
+      columns: Math.max(1, cols),
+      ...ls.layout.rows !== void 0 ? { rows: Math.max(1, rows) } : {}
+    }
+  };
+}
+export function findFreePlacement(placements, w, h) {
+  const ww = Math.max(1, w);
+  const hh = Math.max(1, h);
+  const others = Object.values(placements).map((p) => p.area);
+  const overlaps = (a, b) => a[0][0] < b[1][0] && a[1][0] > b[0][0] && a[0][1] < b[1][1] && a[1][1] > b[0][1];
+  for (let y = 1; y < 1e3; y++) {
+    const area = [[1, y], [1 + ww, y + hh]];
+    if (!others.some((o) => overlaps(area, o))) return { area };
+  }
+  return { area: [[1, 1], [1 + ww, 1 + hh]] };
+}
+export function Slot(BlockSchemaUnion, configure) {
+  return Schema.Struct({
+    blocks: Schema.Array(BlockSchemaUnion).annotations({
+      title: "\u5757",
+      description: "\u5757\u5217\u8868\uFF1B\u672A\u7ED1\u5B9A\u5230\u4EFB\u4F55\u5E03\u5C40\u7684\u5757\u4E0D\u4F1A\u88AB\u6E32\u67D3"
+    }),
+    layouts: Schema.Array(LayoutSet(configure)).pipe(Schema.minItems(1)).annotations({
+      title: "\u5E03\u5C40",
+      description: "\u6309\u987A\u5E8F\u6392\u5217\u7684\u5E03\u5C40\u96C6\u5408\uFF1B\u6302\u8F7D\u65F6\u6309\u5E8F\u6C42\u503C\u5404\u9879 `media` CEL \u8868\u8FBE\u5F0F\uFF0C\u4F7F\u7528\u7B2C\u4E00\u4E2A\u4E3A `true` \u7684\u5E03\u5C40\uFF08\u5168\u90E8\u4E0D\u5339\u914D\u65F6\u56DE\u9000\u5230\u6700\u540E\u4E00\u9879\uFF09"
+    })
+  }).pipe(Schema.filter((slot) => {
+    const items = slot.blocks.map((b) => ({ id: b.id }));
+    return validatePlacements(items, slot.layouts, "\u5757");
+  })).annotations({
+    title: "Slot",
+    description: "\u5757\u4E0E\u5E03\u5C40\u7684\u7EC4\u5408\uFF1A\u5B9A\u4E49\u4E00\u7EC4\u5757\u4EE5\u53CA\u5B83\u4EEC\u5728\u4E0D\u540C\u5E03\u5C40\u4E0B\u7684\u4F4D\u7F6E"
+  });
+}
+export { Expression };
+export function defaultSlot() {
+  return {
+    blocks: [],
+    layouts: [{ name: "\u9ED8\u8BA4", layout: { columns: 1, placements: {} } }]
+  };
+}
+function freshId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+function isSlotShape(v) {
+  if (v === null || typeof v !== "object") return false;
+  const o = v;
+  return Array.isArray(o.blocks) && Array.isArray(o.layouts);
+}
+function rewriteNestedSlots(v) {
+  if (v === null || typeof v !== "object") return v;
+  if (Array.isArray(v)) return v.map(rewriteNestedSlots);
+  if (isSlotShape(v)) return regenSlotIds(v);
+  const out = {};
+  for (const [k, val] of Object.entries(v)) {
+    out[k] = rewriteNestedSlots(val);
+  }
+  return out;
+}
+export function regenSlotIds(slot) {
+  const idMap = /* @__PURE__ */ new Map();
+  const newBlocks = slot.blocks.map((b) => {
+    const newId = freshId();
+    idMap.set(b.id, newId);
+    const rewritten = rewriteNestedSlots(b);
+    return { ...rewritten, id: newId };
+  });
+  const newLayouts = slot.layouts.map((ls) => ({
+    ...ls,
+    layout: {
+      ...ls.layout,
+      placements: Object.fromEntries(
+        Object.entries(ls.layout.placements).map(([id, p]) => [idMap.get(id) ?? id, p])
+      )
+    }
+  }));
+  return { blocks: newBlocks, layouts: newLayouts };
+}

package/dist/runtime/share/locale.d.ts

@@ -0,0 +1,11 @@
+import { Schema } from 'effect';
+export declare const Locale: Schema.TupleType<readonly [Schema.Struct<{
+    locale: Schema.Literal<["zh"]>;
+    message: Schema.SchemaClass<string, string, never>;
+}>], [Schema.Struct<{
+    locale: Schema.Literal<["ja", "en", "ko"]>;
+    message: Schema.SchemaClass<string, string, never>;
+}>]>;
+export type LocaleValue = Schema.Schema.Type<typeof Locale>;
+export declare function hasVisibleLocaleValue(value: LocaleValue | undefined): boolean;
+export declare function getLocalizedText(messages: LocaleValue | undefined, locale: string): string | undefined;

package/dist/runtime/share/locale.js

@@ -0,0 +1,37 @@
+import { Schema } from "effect";
+const ZhLocaleItem = Schema.Struct({
+  locale: Schema.Literal("zh").annotations({
+    description: "\u5FC5\u987B\u4E3A zh"
+  }),
+  message: Schema.String.annotations({
+    description: "\u9488\u5BF9\u8BE5\u8BED\u8A00\u7684 UI \u6587\u672C"
+  })
+});
+const OtherLocaleItem = Schema.Struct({
+  locale: Schema.Literal("ja", "en", "ko").annotations({
+    description: "\u652F\u6301\u7684\u8BED\u8A00\u7801\uFF0C\u4EC5\u9650 ja\u3001en\u3001ko"
+  }),
+  message: Schema.String.annotations({
+    description: "\u9488\u5BF9\u8BE5\u8BED\u8A00\u7684 UI \u6587\u672C"
+  })
+});
+export const Locale = Schema.Tuple(
+  [ZhLocaleItem],
+  OtherLocaleItem
+).annotations({
+  title: "Locale",
+  description: "\u672C\u5730\u5316\u6587\u672C\u5217\u8868\uFF0Czh \u5FC5\u987B\u4E3A\u9996\u9879"
+});
+export function hasVisibleLocaleValue(value) {
+  return value?.some((item) => item.message.trim().length > 0) ?? false;
+}
+export function getLocalizedText(messages, locale) {
+  if (!messages) {
+    return void 0;
+  }
+  const localizedMessage = messages.find((message) => message.locale === locale && message.message.trim().length > 0);
+  if (localizedMessage) {
+    return localizedMessage.message;
+  }
+  return messages.find((message) => message.message.trim().length > 0)?.message;
+}

package/dist/runtime/share/markdown.d.ts

@@ -0,0 +1,9 @@
+export type Markdown = string & Record<never, never>;
+/**
+ * Create Markdown text (**Not rendering it into HTML**).
+ *
+ * - Trim the leading and trailing whitespace of the input.
+ * - Escape special characters (except backtick as it will break parsing)
+ * - Use first line indent as the indent of the rest lines.
+ */
+export declare function md(...args: Parameters<typeof String.raw>): Markdown;

package/dist/runtime/share/markdown.js

@@ -0,0 +1,6 @@
+export function md(...args) {
+  const [template, ...rest] = args;
+  const original = String.raw(template, ...rest.map((arg) => arg ?? ""));
+  const indent = (original.startsWith("\n") ? original.slice(1) : original).split("\n", 1)[0]?.match(/^(\s*)/)?.[1]?.length ?? 0;
+  return original.trim().replaceAll("\\`", "`").split("\n").map((line) => line.replace(new RegExp(`^${String.raw`\s`.repeat(indent)}`), "")).join("\n");
+}

package/dist/runtime/share/slot-renderer.d.vue.ts

@@ -0,0 +1,50 @@
+import type { Component } from 'vue';
+import type { Environment } from '../vendor/cel-js/lib/index.js';
+import type { SlotValue } from './layout.js';
+type EntryLike = Readonly<{
+    runtime: Component;
+}>;
+type __VLS_Props = {
+    slotValue: SlotValue;
+    configure: (env: Environment) => void;
+    /**
+     * Registry lookup. Returns `undefined` when the block type/date pair is
+     * not registered — the renderer skips those cells and logs once.
+     */
+    findEntry: (type: string, compatibilityDate: string) => EntryLike | undefined;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    empty?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:slotValue": (next: Readonly<{
+        blocks: ReadonlyArray<Readonly<{
+            id: string;
+        } & Record<string, unknown>>>;
+        layouts: readonly Readonly<{
+            name: string;
+            media?: string;
+            layout: import("./layout.js").LayoutValue;
+        }>[];
+    }>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:slotValue"?: ((next: Readonly<{
+        blocks: ReadonlyArray<Readonly<{
+            id: string;
+        } & Record<string, unknown>>>;
+        layouts: readonly Readonly<{
+            name: string;
+            media?: string;
+            layout: import("./layout.js").LayoutValue;
+        }>[];
+    }>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/share/slot-renderer.vue

@@ -0,0 +1,118 @@
+<script setup>
+import { Effect } from "effect";
+import { computed, onMounted, ref, watch } from "vue";
+import { cel as _rawCel } from "../utils/cel";
+import { celBindings, injectCELContext } from "../utils/cel-context";
+import { DEFAULT_GAP } from "./layout";
+defineOptions({ name: "ShwfedSlotRenderer" });
+const props = defineProps({
+  slotValue: { type: Object, required: true },
+  configure: { type: Function, required: true },
+  findEntry: { type: Function, required: true }
+});
+const emit = defineEmits(["update:slotValue"]);
+const inherited = injectCELContext();
+const $cel = (expression, context) => _rawCel(expression, { ...celBindings(inherited), ...context });
+function pickLayout(sets) {
+  if (sets.length === 0) return void 0;
+  for (const set of sets) {
+    if (!set.media) return set;
+    try {
+      if (Effect.runSync($cel(set.media))) return set;
+    } catch (err) {
+      console.error(`[shwfed-slot-renderer] failed to evaluate layout media for ${set.name}:`, err);
+    }
+  }
+  return sets[sets.length - 1];
+}
+const activeLayout = ref();
+onMounted(() => {
+  activeLayout.value = pickLayout(props.slotValue.layouts);
+});
+watch(() => props.slotValue.layouts, (sets) => {
+  activeLayout.value = pickLayout(sets);
+}, { deep: false });
+const gridStyle = computed(() => {
+  const l = activeLayout.value?.layout;
+  if (!l) return "";
+  const tracks = (n) => `repeat(${n}, minmax(0, 1fr))`;
+  const parts = [
+    "display: grid",
+    `grid-template-columns: ${tracks(l.columns)}`,
+    l.rows ? `grid-template-rows: ${tracks(l.rows)}` : "",
+    // Missing `gap` resolves to `DEFAULT_GAP` — the layout editor's fallback —
+    // so the editor and the rendered slot agree. `gap: 0` stays 0.
+    `gap: calc(${l.gap ?? DEFAULT_GAP} * 0.25rem)`,
+    l.style ?? ""
+  ].filter(Boolean);
+  return parts.join("; ");
+});
+function cellStyle(placement) {
+  const [[x1, y1], [x2, y2]] = placement.area;
+  const parts = [`grid-column: ${x1} / ${x2}`, `grid-row: ${y1} / ${y2}`, "min-width: 0"];
+  const h = placement.h && placement.h !== "stretch" ? placement.h : null;
+  const v = placement.v && placement.v !== "stretch" ? placement.v : null;
+  if (h || v) {
+    parts.push("display: flex");
+    const toFlex = (a) => a === "start" ? "flex-start" : a === "end" ? "flex-end" : "center";
+    if (h) parts.push(`justify-content: ${toFlex(h)}`);
+    if (v) parts.push(`align-items: ${toFlex(v)}`);
+  }
+  return parts.join("; ");
+}
+const warnedMissing = /* @__PURE__ */ new Set();
+const rendered = computed(() => {
+  const layout = activeLayout.value?.layout;
+  if (!layout) return [];
+  const out = [];
+  for (const b of props.slotValue.blocks) {
+    const block = b;
+    const placement = layout.placements[block.id];
+    if (!placement) continue;
+    const entry = props.findEntry(block.type, block.compatibilityDate);
+    if (!entry) {
+      const key = `${block.type}@${block.compatibilityDate}`;
+      if (!warnedMissing.has(key)) {
+        warnedMissing.add(key);
+        console.warn(`[shwfed-slot-renderer] no registered block type for ${key}`);
+      }
+      continue;
+    }
+    out.push({
+      key: block.id,
+      style: cellStyle(placement),
+      component: entry.runtime,
+      block
+    });
+  }
+  return out;
+});
+function updateBlock(id, next) {
+  const blocks = props.slotValue.blocks.map((b) => b.id === id ? next : b);
+  emit("update:slotValue", { ...props.slotValue, blocks });
+}
+</script>
+
+<template>
+  <div
+    :style="gridStyle"
+    :class="rendered.length === 0 && $slots.empty ? 'min-h-32 grid place-items-center text-xs text-zinc-400 select-none' : ''"
+  >
+    <slot
+      v-if="rendered.length === 0"
+      name="empty"
+    />
+    <div
+      v-for="r in rendered"
+      :key="r.key"
+      :style="r.style"
+    >
+      <component
+        :is="r.component"
+        :block="r.block"
+        :configure="configure"
+        @update:block="(next) => updateBlock(r.block.id, next)"
+      />
+    </div>
+  </div>
+</template>

package/dist/runtime/share/slot-renderer.vue.d.ts

@@ -0,0 +1,50 @@
+import type { Component } from 'vue';
+import type { Environment } from '../vendor/cel-js/lib/index.js';
+import type { SlotValue } from './layout.js';
+type EntryLike = Readonly<{
+    runtime: Component;
+}>;
+type __VLS_Props = {
+    slotValue: SlotValue;
+    configure: (env: Environment) => void;
+    /**
+     * Registry lookup. Returns `undefined` when the block type/date pair is
+     * not registered — the renderer skips those cells and logs once.
+     */
+    findEntry: (type: string, compatibilityDate: string) => EntryLike | undefined;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    empty?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:slotValue": (next: Readonly<{
+        blocks: ReadonlyArray<Readonly<{
+            id: string;
+        } & Record<string, unknown>>>;
+        layouts: readonly Readonly<{
+            name: string;
+            media?: string;
+            layout: import("./layout.js").LayoutValue;
+        }>[];
+    }>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:slotValue"?: ((next: Readonly<{
+        blocks: ReadonlyArray<Readonly<{
+            id: string;
+        } & Record<string, unknown>>>;
+        layouts: readonly Readonly<{
+            name: string;
+            media?: string;
+            layout: import("./layout.js").LayoutValue;
+        }>[];
+    }>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/share/use-active-tab-id.d.ts

@@ -0,0 +1,13 @@
+import { type ComputedRef, type Ref } from 'vue';
+/**
+ * Tracks the currently-active tab id for a tabs block.
+ *
+ * - Initial value is `tabIds.value[0]` so SSR and first client render agree
+ *   (no hydration mismatch). The stored id from `sessionStorage` is applied
+ *   in `onMounted`, after hydration completes.
+ * - When `tabIds` changes and the active id is no longer present, fall back
+ *   to the first tab and clear the stored value — otherwise a later re-add
+ *   of the same id would silently re-stick the old selection.
+ * - All writes are guarded against unavailable storage (privacy modes, SSR).
+ */
+export declare function useActiveTabId(blockId: string, tabIds: ComputedRef<string[]>): Ref<string>;