@vanillaskyai/video 0.1.0

package/dist/chart-progress-ring-RMI4A7ZK.js

@@ -0,0 +1,296 @@
+import {
+  getResponsiveFontSize,
+  stripPipe
+} from "./chunk-S7HFLYNN.js";
+import {
+  SceneBackground,
+  getMediaBackgroundProps
+} from "./chunk-IFOW65Z6.js";
+import {
+  TemplateText
+} from "./chunk-BCRUUJ6A.js";
+import "./chunk-L5BTTCZV.js";
+import {
+  TOP_TEXT_AREA_RATIO,
+  withOpacity
+} from "./chunk-ABZACD4G.js";
+import {
+  interpolate
+} from "./chunk-XTOXFMLM.js";
+import {
+  TOKEN_DEFAULTS,
+  resolveTokens
+} from "./chunk-FNAEQ7QO.js";
+
+// src/visual-system/primitives/charts/ProgressRing.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var ProgressRing = ({
+  progress,
+  motionProgress = progress,
+  targetValue,
+  decimalPlaces,
+  unit = "%",
+  chartColor = "#ffffff",
+  textColor = "#ffffff",
+  label: rawLabel = "",
+  font = TOKEN_DEFAULTS.font,
+  width,
+  height,
+  beatIntensity = 0
+}) => {
+  const s = Math.min(width, height) / 1080;
+  const label = stripPipe(String(rawLabel || ""));
+  const radius = Math.min(width, height) * 0.2;
+  const circumference = 2 * Math.PI * radius;
+  const cx = width / 2;
+  const cy = height / 2;
+  const strokeW = 34 * s;
+  const fillPercent = interpolate(progress, [0.05, 0.75], [0, targetValue], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const dashOffset = circumference * (1 - fillPercent / 100);
+  const targetDecimals = Number.isFinite(decimalPlaces) ? Math.max(0, Math.min(2, Math.trunc(decimalPlaces ?? 0))) : Number.isInteger(targetValue) ? 0 : Math.min(2, (String(targetValue).split(".")[1] || "1").length);
+  const displayNumber = targetDecimals === 0 ? String(Math.round(fillPercent)) : fillPercent.toFixed(targetDecimals);
+  const targetDisplayNumber = targetDecimals === 0 ? String(Math.round(targetValue)) : targetValue.toFixed(targetDecimals);
+  const semanticValueIsTransient = displayNumber !== targetDisplayNumber;
+  const beatStroke = strokeW + beatIntensity * 4 * s;
+  const labelFontSize = getResponsiveFontSize(label, width, "subtitle", height) * 1.3;
+  const labelOpacity = interpolate(motionProgress, [0.35, 0.55], [0, 1], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const labelRise = interpolate(motionProgress, [0.35, 0.55], [16 * s, 0], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          top: cy - radius * 1.2,
+          left: cx - radius * 1.2,
+          width: radius * 2.4,
+          height: radius * 2.4,
+          borderRadius: "50%",
+          background: `radial-gradient(circle at 50% 50%, ${withOpacity(chartColor, 0.08)} 0%, transparent 70%)`,
+          pointerEvents: "none"
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      "svg",
+      {
+        viewBox: `0 0 ${width} ${height}`,
+        style: {
+          position: "absolute",
+          inset: 0,
+          width,
+          height
+        },
+        children: [
+          /* @__PURE__ */ jsx(
+            "circle",
+            {
+              cx,
+              cy,
+              r: radius,
+              fill: "none",
+              stroke: withOpacity(chartColor, 0.1),
+              strokeWidth: strokeW
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "circle",
+            {
+              cx,
+              cy,
+              r: radius,
+              fill: "none",
+              stroke: chartColor,
+              strokeWidth: beatStroke,
+              strokeLinecap: "round",
+              strokeDasharray: circumference,
+              strokeDashoffset: dashOffset,
+              transform: `rotate(-90, ${cx}, ${cy})`,
+              style: { transition: "none" }
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        "data-transition-semantic": semanticValueIsTransient ? "transient" : void 0,
+        style: {
+          position: "absolute",
+          left: cx - radius,
+          top: cy - radius,
+          width: radius * 2,
+          height: radius * 2,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          pointerEvents: "none",
+          ...semanticValueIsTransient ? { visibility: "var(--vanillasky-transition-semantic-visibility,visible)" } : {}
+        },
+        children: [
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              style: {
+                fontSize: 120 * s,
+                fontWeight: 800,
+                color: textColor,
+                lineHeight: 1
+              },
+              children: displayNumber
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              style: {
+                fontSize: 56 * s,
+                fontWeight: 700,
+                color: chartColor,
+                marginLeft: 4 * s
+              },
+              children: unit
+            }
+          )
+        ]
+      }
+    ),
+    label && /* @__PURE__ */ jsx(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          top: cy + radius + 48 * s,
+          left: 0,
+          right: 0,
+          display: "flex",
+          justifyContent: "center",
+          pointerEvents: "none"
+        },
+        children: /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              fontSize: labelFontSize,
+              color: withOpacity(textColor, 0.6),
+              textTransform: "uppercase",
+              letterSpacing: 2 * s,
+              textAlign: "center",
+              maxWidth: "80%",
+              opacity: labelOpacity,
+              transform: `translateY(${labelRise}px)`,
+              fontFamily: font
+            },
+            children: label
+          }
+        )
+      }
+    )
+  ] });
+};
+
+// src/visual-system/scene-templates/chart-progress-ring.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var ChartProgressRingTemplate = ({
+  variables,
+  style,
+  progress,
+  motionProgress = progress,
+  beatIntensity,
+  width,
+  height,
+  safeZone,
+  sceneDuration,
+  backgroundEffect,
+  isPlaying = true
+}) => {
+  const { primary, foreground, font } = resolveTokens(style);
+  const chartColor = primary;
+  const textColor = foreground;
+  const textsRaw = String(variables.texts || "");
+  const parsedValue = Number(variables.value);
+  const targetValue = Math.max(0, Math.min(100, Number.isFinite(parsedValue) ? parsedValue : 75));
+  const parsedDecimalPlaces = Number(variables.decimalPlaces);
+  const decimalPlaces = Number.isFinite(parsedDecimalPlaces) ? Math.max(0, Math.min(2, Math.trunc(parsedDecimalPlaces))) : void 0;
+  const unit = String(variables.unit ?? "%");
+  const label = String(variables.label ?? "");
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      style: {
+        width,
+        height,
+        backgroundColor: "#000",
+        position: "relative",
+        overflow: "hidden",
+        fontFamily: font
+      },
+      children: [
+        /* @__PURE__ */ jsx2(
+          SceneBackground,
+          {
+            style,
+            progress,
+            sceneDuration,
+            width,
+            height,
+            ...getMediaBackgroundProps(variables),
+            backgroundEffect,
+            seed: textsRaw,
+            isPlaying,
+            beatIntensity
+          }
+        ),
+        /* @__PURE__ */ jsx2("div", { style: { position: "absolute", top: 0, left: 0, right: 0, height: height * TOP_TEXT_AREA_RATIO, overflow: "visible" }, children: /* @__PURE__ */ jsx2(
+          TemplateText,
+          {
+            motionProgress,
+            typeTreatment: resolveTokens(style).preset.type,
+            archetype: "subtle",
+            text: String(variables.texts ?? ""),
+            progress,
+            sceneDuration: sceneDuration ?? 3,
+            width,
+            height,
+            position: "top",
+            sizeRole: "headline",
+            safeZone,
+            font,
+            color: textColor,
+            beatIntensity
+          }
+        ) }),
+        /* @__PURE__ */ jsx2(
+          ProgressRing,
+          {
+            progress,
+            motionProgress,
+            targetValue,
+            decimalPlaces,
+            unit,
+            chartColor,
+            textColor,
+            label,
+            font,
+            width,
+            height,
+            beatIntensity
+          }
+        )
+      ]
+    }
+  );
+};
+export {
+  ChartProgressRingTemplate
+};

package/dist/check-runtime.d.ts

@@ -0,0 +1,15 @@
+interface TemplateRenderCheckInput {
+    sourceUrl: string;
+    exportName: string;
+    templateId: string;
+    exampleName: string;
+    variables: Record<string, unknown>;
+    duration: number;
+    timeoutMs: number;
+}
+interface TemplateRenderCheckResult {
+    renders: number;
+}
+declare function renderTemplateChecks(input: TemplateRenderCheckInput): Promise<TemplateRenderCheckResult>;
+
+export { type TemplateRenderCheckInput, type TemplateRenderCheckResult, renderTemplateChecks };

package/dist/check-runtime.js

@@ -0,0 +1,102 @@
+import {
+  VideoFrame
+} from "./chunk-XB7LH4J2.js";
+import "./chunk-FNAEQ7QO.js";
+import "./chunk-SPVTJH3F.js";
+import {
+  resolveVideoBrand
+} from "./chunk-XGRA2MUV.js";
+import "./chunk-73NTSFFI.js";
+
+// src/cli/check-runtime.ts
+import * as React from "react";
+import { createElement } from "react";
+import { PassThrough } from "stream";
+import { renderToPipeableStream } from "react-dom/server";
+function renderFrame(element, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const output = new PassThrough();
+    const chunks = [];
+    let renderError;
+    output.on("data", (chunk) => chunks.push(chunk));
+    output.on("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    output.on("end", () => {
+      clearTimeout(timeout);
+      if (renderError == null) resolve(Buffer.concat(chunks).toString("utf8"));
+      else reject(renderError);
+    });
+    const stream = renderToPipeableStream(element, {
+      onAllReady: () => stream.pipe(output),
+      onError: (error) => {
+        renderError ??= error;
+      }
+    });
+    const timeout = setTimeout(() => stream.abort(new Error(`SSR timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+}
+async function renderTemplateChecks(input) {
+  Object.assign(globalThis, { React });
+  const progressPoints = [0, 0.5, 0.999];
+  let renders = 0;
+  let importSequence = 0;
+  for (const orientation of ["portrait", "landscape"]) {
+    const [width, height] = orientation === "portrait" ? [1080, 1920] : [1920, 1080];
+    const config = {
+      schemaVersion: "0.1",
+      orientation,
+      scenes: [{
+        id: "authoring-check",
+        templateId: input.templateId,
+        variables: input.variables,
+        timing: { startTime: 0, endTime: input.duration, fixedDuration: input.duration }
+      }],
+      style: {
+        brand: resolveVideoBrand({
+          font: "Inter, sans-serif",
+          colors: { primary: "#6D5EF5", secondary: "#17122F", foreground: "#FFFFFF" }
+        })
+      }
+    };
+    for (const progress of progressPoints) {
+      let first;
+      let second;
+      try {
+        const frame = async () => {
+          const loaded = await import(`${input.sourceUrl}?vanillasky-render=${Date.now()}-${importSequence++}`);
+          const template = loaded[input.exportName];
+          if (!template || typeof template.component !== "function") throw new Error(`could not resolve export ${JSON.stringify(input.exportName)}`);
+          const kit = {
+            templates: [template],
+            capabilities: { templates: [template.id] },
+            getTemplate: (id) => id === template.id ? template : void 0,
+            getTemplateMetadata: (id) => id === template.id ? template : void 0,
+            listTemplateMetadata: () => [template]
+          };
+          return renderFrame(createElement(VideoFrame, {
+            kit,
+            config,
+            time: progress * input.duration,
+            width,
+            height
+          }), input.timeoutMs);
+        };
+        first = await frame();
+        second = await frame();
+      } catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`${input.templateId} example ${JSON.stringify(input.exampleName)} ${orientation} at progress ${progress}: ${detail}`);
+      }
+      if (first !== second) {
+        throw new Error(`${input.templateId} example ${JSON.stringify(input.exampleName)} ${orientation} at progress ${progress} is nondeterministic`);
+      }
+      renders += 2;
+    }
+  }
+  return { renders };
+}
+export {
+  renderTemplateChecks
+};

package/dist/chunk-2E6T633S.js

@@ -0,0 +1,27 @@
+// src/visual-system/catalog/transition-contract.ts
+var TRANSITION_TIMING_KEYS = /* @__PURE__ */ new Set(["entryReadyProgress", "holdProgress"]);
+function assertTemplateTransitionMetadata(template) {
+  const timing = template.transitionTiming;
+  if (!template.usesGlobalTransition) {
+    if (timing !== void 0) {
+      throw new Error(`${template.id}.transitionTiming requires usesGlobalTransition: true`);
+    }
+    return;
+  }
+  if (!timing || typeof timing !== "object" || Array.isArray(timing)) {
+    throw new Error(`${template.id}.transitionTiming is required when usesGlobalTransition is true`);
+  }
+  for (const key of Object.keys(timing)) {
+    if (!TRANSITION_TIMING_KEYS.has(key)) throw new Error(`${template.id}.transitionTiming.${key} is not supported`);
+  }
+  const { entryReadyProgress, holdProgress } = timing;
+  if (!Number.isFinite(entryReadyProgress) || !Number.isFinite(holdProgress) || entryReadyProgress < 0 || holdProgress > 1 || entryReadyProgress >= holdProgress) {
+    throw new Error(
+      `${template.id}.transitionTiming must satisfy 0 <= entryReadyProgress < holdProgress <= 1`
+    );
+  }
+}
+
+export {
+  assertTemplateTransitionMetadata
+};

package/dist/chunk-352ZZCET.js

@@ -0,0 +1,83 @@
+// src/visual-system/catalog/value-validation.ts
+var STRING_FORMATS = /* @__PURE__ */ new Set(["uri", "supplied-image", "grounded-quote", "stock-media-keyword", "emoji"]);
+function isTemplatePropertyFormatSupported(format, type) {
+  return format === "grounded-stat" ? type === "number" || type === "integer" : STRING_FORMATS.has(format) && type === "string";
+}
+function validUrl(value) {
+  try {
+    return ["https:", "http:", "data:"].includes(new URL(value).protocol);
+  } catch {
+    return false;
+  }
+}
+function validSingleEmoji(value) {
+  const text = value.trim();
+  const graphemes = Array.from(new Intl.Segmenter(void 0, { granularity: "grapheme" }).segment(text));
+  return graphemes.length === 1 && /\p{Extended_Pictographic}|\p{Regional_Indicator}|\u20e3/u.test(text);
+}
+function validateTemplateSchemaValue(schema, value, path, options = {}) {
+  const fail = (message) => {
+    throw new Error(`${options.errorPrefix ?? ""}${path} ${message}`);
+  };
+  if (schema.enum && (typeof value !== "string" || !schema.enum.includes(value))) fail("must match an allowed value");
+  if (schema.type === "string") {
+    if (typeof value !== "string") fail("must be string");
+    const text = value;
+    if (schema.minLength != null && text.length < schema.minLength) fail(`must contain at least ${schema.minLength} characters`);
+    if (schema.maxLength != null && text.length > schema.maxLength) fail(`must contain at most ${schema.maxLength} characters`);
+    if (schema.format === "uri" || schema.format === "supplied-image") {
+      const emptySentinel = options.allowEmptyOptionalMedia && options.optional && text === "";
+      if (!emptySentinel && !validUrl(text)) fail("must be a valid URL");
+    }
+    if (schema.format === "emoji" && !validSingleEmoji(text)) fail("must be a single emoji");
+  } else if (schema.type === "number" || schema.type === "integer") {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      fail(`must be ${options.includeTypeArticle ? "a " : ""}${schema.type}`);
+    }
+    const number = value;
+    if (schema.type === "integer" && !Number.isInteger(number)) fail("must be integer");
+    if (schema.minimum != null && number < schema.minimum) fail(`must be at least ${schema.minimum}`);
+    if (schema.maximum != null && number > schema.maximum) fail(`must be at most ${schema.maximum}`);
+  } else if (schema.type === "boolean") {
+    if (typeof value !== "boolean") fail("must be boolean");
+  } else if (schema.type === "array") {
+    if (!Array.isArray(value)) fail("must be array");
+    const items = value;
+    if (schema.minItems === schema.maxItems && schema.minItems != null && items.length !== schema.minItems) {
+      fail(`must contain exactly ${schema.minItems} items`);
+    }
+    if (schema.minItems != null && items.length < schema.minItems) fail(`must contain at least ${schema.minItems} items`);
+    if (schema.maxItems != null && items.length > schema.maxItems) fail(`must contain at most ${schema.maxItems} items`);
+    if (schema.items) items.forEach((item, index) => validateTemplateSchemaValue(schema.items, item, `${path}.${index}`, {
+      ...options,
+      optional: false
+    }));
+  } else if (schema.type === "object") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) fail("must be object");
+    const object = value;
+    for (const required2 of schema.required ?? []) {
+      if (!Object.hasOwn(object, required2)) fail(`requires ${required2}`);
+    }
+    const properties = schema.properties ?? {};
+    if (schema.additionalProperties === false) {
+      for (const name of Object.keys(object)) {
+        if (!Object.hasOwn(properties, name)) {
+          throw new Error(`${options.errorPrefix ?? ""}${path}.${name} is not declared`);
+        }
+      }
+    }
+    const required = new Set(schema.required ?? []);
+    for (const [name, property] of Object.entries(properties)) {
+      if (Object.hasOwn(object, name)) validateTemplateSchemaValue(property, object[name], `${path}.${name}`, {
+        ...options,
+        allowEmptyOptionalMedia: property.default === "",
+        optional: !required.has(name)
+      });
+    }
+  }
+}
+
+export {
+  isTemplatePropertyFormatSupported,
+  validateTemplateSchemaValue
+};

package/dist/chunk-73NTSFFI.js

@@ -0,0 +1,81 @@
+// src/visual-system/catalog/schema.ts
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function getTemplateDefaults(schema) {
+  return Object.fromEntries(Object.entries(schema.properties).filter(([, property]) => property.default !== void 0).map(([name, property]) => [name, cloneJson(property.default)]));
+}
+function isMeaningfullyPresentTemplateValue(value) {
+  if (value == null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function schemaProperties(schema) {
+  return [
+    schema,
+    ...Object.values(schema.properties ?? {}).flatMap(schemaProperties),
+    ...schema.items ? schemaProperties(schema.items) : []
+  ];
+}
+function getTemplateSchemaGates(schema) {
+  const requiredAnyOf = schema["x-vanillasky"]?.requiredAnyOf ?? [];
+  for (const [groupIndex, group] of requiredAnyOf.entries()) {
+    if (!Array.isArray(group) || group.length === 0) {
+      throw new Error(`Template schema x-vanillasky.requiredAnyOf[${groupIndex}] must name at least one field`);
+    }
+    for (const field of group) {
+      if (typeof field !== "string" || !Object.hasOwn(schema.properties, field)) {
+        throw new Error(`Template schema x-vanillasky.requiredAnyOf[${groupIndex}] field ${String(field)} is not declared`);
+      }
+    }
+  }
+  const properties = Object.values(schema.properties).flatMap(schemaProperties);
+  return {
+    requiresStat: schema["x-vanillasky"]?.requiresStat === true || properties.some(({ format }) => format === "grounded-stat"),
+    requiresQuote: properties.some(({ format }) => format === "grounded-quote"),
+    requiresScreenshot: properties.some(({ format }) => format === "supplied-image"),
+    allowsStockMedia: schema["x-vanillasky"]?.allowsStockMedia === true || properties.some(({ format }) => format === "stock-media-keyword"),
+    requiredAnyOf
+  };
+}
+function summaryType(property) {
+  if (property.format === "uri" || property.format === "supplied-image") return "media";
+  if (property.enum) return "enum";
+  if (property.type === "number" || property.type === "integer") return "number";
+  if (property.type === "boolean") return "boolean";
+  if (property.type === "array" && property.items?.type === "object") return "data-points";
+  if (property.type === "array") return "string-array";
+  return "string";
+}
+function summarizeTemplateVariables(schema) {
+  const required = new Set(schema.required ?? []);
+  return Object.fromEntries(Object.entries(schema.properties).map(([name, property]) => [name, {
+    type: summaryType(property),
+    ...property.title == null ? {} : { title: property.title },
+    ...property.description == null ? {} : { description: property.description },
+    ...property.default === void 0 ? {} : { default: cloneJson(property.default) },
+    ...property.examples == null ? {} : { examples: cloneJson(property.examples) },
+    ...property.enum == null ? {} : { options: [...property.enum] },
+    required: required.has(name),
+    ...property.minItems == null ? {} : { minItems: property.minItems },
+    ...property.maxItems == null ? {} : { maxItems: property.maxItems }
+  }]));
+}
+function templateVariableNotation(property, required) {
+  const type = summaryType(property);
+  const options = property.enum?.length ? `(${property.enum.join("|")})` : "";
+  const itemCount = property.minItems === property.maxItems && property.minItems != null ? `[${property.minItems}]` : property.minItems != null || property.maxItems != null ? `[${property.minItems ?? 0}..${property.maxItems ?? "\u221E"}]` : "";
+  const textProperty = property.type === "array" ? property.items : property;
+  const characterCount = textProperty?.type === "string" && (textProperty.minLength != null || textProperty.maxLength != null) ? `{${textProperty.minLength ?? 0}..${textProperty.maxLength ?? "\u221E"}}` : "";
+  return `${type}${itemCount}${characterCount}${options}${required ? "!" : ""}`;
+}
+
+export {
+  getTemplateDefaults,
+  isMeaningfullyPresentTemplateValue,
+  getTemplateSchemaGates,
+  summarizeTemplateVariables,
+  templateVariableNotation
+};

package/dist/chunk-A2X45FET.js

@@ -0,0 +1,46 @@
+import {
+  BUILTIN_TEMPLATE_CATALOG
+} from "./chunk-CHLGW22F.js";
+import {
+  assertTemplateTransitionMetadata
+} from "./chunk-2E6T633S.js";
+
+// src/visual-system/catalog/server-kit.ts
+function createServerTemplateRegistry(options) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const template of options.templates) {
+    assertTemplateTransitionMetadata(template);
+    if (byId.has(template.id)) throw new Error(`Duplicate template id: ${template.id}`);
+    byId.set(template.id, template);
+  }
+  const templates = Object.freeze([...options.templates]);
+  const capabilities = { templates: templates.map(({ id }) => id) };
+  return Object.freeze({
+    capabilities,
+    getTemplateMetadata: (id) => byId.get(id),
+    listTemplateMetadata: () => [...templates]
+  });
+}
+function overlayServerTemplateRegistry(defaults, customer) {
+  const defaultTemplates = defaults.listTemplateMetadata();
+  const customerTemplates = customer.listTemplateMetadata();
+  const customerMetadata = new Map(customerTemplates.map((template) => [template.id, template]));
+  const defaultIds = new Set(defaultTemplates.map(({ id }) => id));
+  return createServerTemplateRegistry({
+    templates: [
+      ...defaultTemplates.map((template) => customerMetadata.get(template.id) ?? template),
+      ...customerTemplates.filter(({ id }) => !defaultIds.has(id))
+    ]
+  });
+}
+
+// src/visual-system/catalog/builtin-server.ts
+var BUILTIN_SERVER_TEMPLATE_KIT = createServerTemplateRegistry({
+  templates: BUILTIN_TEMPLATE_CATALOG
+});
+
+export {
+  createServerTemplateRegistry,
+  overlayServerTemplateRegistry,
+  BUILTIN_SERVER_TEMPLATE_KIT
+};