@coxwave/tap-kit-types 2.0.0 → 2.0.2

package/dist/index.js

@@ -1,5 +1,3 @@
-import * as v from 'valibot';
-
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -161,178 +159,745 @@ var MaterialViewerError = class _MaterialViewerError extends TapKitError {
 
 // src/protocol/alarm.ts
 var ALARM_DURATION = 18e3;
-var CSSStyleSchema = v.record(
-  v.string(),
-  v.union([v.string(), v.number()])
+
+// ../../node_modules/.pnpm/valibot@1.1.0_typescript@5.9.2/node_modules/valibot/dist/index.js
+var store;
+// @__NO_SIDE_EFFECTS__
+function getGlobalConfig(config2) {
+  return {
+    lang: config2?.lang ?? store?.lang,
+    message: config2?.message,
+    abortEarly: config2?.abortEarly ?? store?.abortEarly,
+    abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
+  };
+}
+var store2;
+// @__NO_SIDE_EFFECTS__
+function getGlobalMessage(lang) {
+  return store2?.get(lang);
+}
+var store3;
+// @__NO_SIDE_EFFECTS__
+function getSchemaMessage(lang) {
+  return store3?.get(lang);
+}
+var store4;
+// @__NO_SIDE_EFFECTS__
+function getSpecificMessage(reference, lang) {
+  return store4?.get(reference)?.get(lang);
+}
+// @__NO_SIDE_EFFECTS__
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string") {
+    return `"${input}"`;
+  }
+  if (type === "number" || type === "bigint" || type === "boolean") {
+    return `${input}`;
+  }
+  if (type === "object" || type === "function") {
+    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  }
+  return type;
+}
+function _addIssue(context, label, dataset, config2, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config2.lang,
+    abortEarly: config2.abortEarly,
+    abortPipeEarly: config2.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message2 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config2.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message2 !== void 0) {
+    issue.message = typeof message2 === "function" ? (
+      // @ts-expect-error
+      message2(issue)
+    ) : message2;
+  }
+  if (isSchema) {
+    dataset.typed = false;
+  }
+  if (dataset.issues) {
+    dataset.issues.push(issue);
+  } else {
+    dataset.issues = [issue];
+  }
+}
+// @__NO_SIDE_EFFECTS__
+function _getStandardProps(context) {
+  return {
+    version: 1,
+    vendor: "valibot",
+    validate(value2) {
+      return context["~run"]({ value: value2 }, /* @__PURE__ */ getGlobalConfig());
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _isValidObjectKey(object2, key) {
+  return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+// @__NO_SIDE_EFFECTS__
+function _joinExpects(values2, separator) {
+  const list = [...new Set(values2)];
+  if (list.length > 1) {
+    return `(${list.join(` ${separator} `)})`;
+  }
+  return list[0] ?? "never";
+}
+// @__NO_SIDE_EFFECTS__
+function getFallback(schema, dataset, config2) {
+  return typeof schema.fallback === "function" ? (
+    // @ts-expect-error
+    schema.fallback(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.fallback
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function getDefault(schema, dataset, config2) {
+  return typeof schema.default === "function" ? (
+    // @ts-expect-error
+    schema.default(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.default
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function any() {
+  return {
+    kind: "schema",
+    type: "any",
+    reference: any,
+    expects: "any",
+    async: false,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset) {
+      dataset.typed = true;
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function array(item, message2) {
+  return {
+    kind: "schema",
+    type: "array",
+    reference: array,
+    expects: "Array",
+    async: false,
+    item,
+    message: message2,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      const input = dataset.value;
+      if (Array.isArray(input)) {
+        dataset.typed = true;
+        dataset.value = [];
+        for (let key = 0; key < input.length; key++) {
+          const value2 = input[key];
+          const itemDataset = this.item["~run"]({ value: value2 }, config2);
+          if (itemDataset.issues) {
+            const pathItem = {
+              type: "array",
+              origin: "value",
+              input,
+              key,
+              value: value2
+            };
+            for (const issue of itemDataset.issues) {
+              if (issue.path) {
+                issue.path.unshift(pathItem);
+              } else {
+                issue.path = [pathItem];
+              }
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) {
+              dataset.issues = itemDataset.issues;
+            }
+            if (config2.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!itemDataset.typed) {
+            dataset.typed = false;
+          }
+          dataset.value.push(itemDataset.value);
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function boolean(message2) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
+    async: false,
+    message: message2,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "boolean") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function lazy(getter) {
+  return {
+    kind: "schema",
+    type: "lazy",
+    reference: lazy,
+    expects: "unknown",
+    async: false,
+    getter,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      return this.getter(dataset.value)["~run"](dataset, config2);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function literal(literal_, message2) {
+  return {
+    kind: "schema",
+    type: "literal",
+    reference: literal,
+    expects: /* @__PURE__ */ _stringify(literal_),
+    async: false,
+    literal: literal_,
+    message: message2,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (dataset.value === this.literal) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function number(message2) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message: message2,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function object(entries2, message2) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries: entries2,
+    message: message2,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && // @ts-expect-error
+          valueSchema.default !== void 0) {
+            const value2 = key in input ? (
+              // @ts-expect-error
+              input[key]
+            ) : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value2
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) {
+                  issue.path.unshift(pathItem);
+                } else {
+                  issue.path = [pathItem];
+                }
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = valueDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) {
+              dataset.typed = false;
+            }
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) {
+            dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          } else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config2, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [
+                {
+                  type: "object",
+                  origin: "key",
+                  input,
+                  key,
+                  // @ts-expect-error
+                  value: input[key]
+                }
+              ]
+            });
+            if (config2.abortEarly) {
+              break;
+            }
+          }
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function optional(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (dataset.value === void 0) {
+        if (this.default !== void 0) {
+          dataset.value = /* @__PURE__ */ getDefault(this, dataset, config2);
+        }
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config2);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function record(key, value2, message2) {
+  return {
+    kind: "schema",
+    type: "record",
+    reference: record,
+    expects: "Object",
+    async: false,
+    key,
+    value: value2,
+    message: message2,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const entryKey in input) {
+          if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+            const entryValue = input[entryKey];
+            const keyDataset = this.key["~run"]({ value: entryKey }, config2);
+            if (keyDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "key",
+                input,
+                key: entryKey,
+                value: entryValue
+              };
+              for (const issue of keyDataset.issues) {
+                issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = keyDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            const valueDataset = this.value["~run"](
+              { value: entryValue },
+              config2
+            );
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key: entryKey,
+                value: entryValue
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) {
+                  issue.path.unshift(pathItem);
+                } else {
+                  issue.path = [pathItem];
+                }
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = valueDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!keyDataset.typed || !valueDataset.typed) {
+              dataset.typed = false;
+            }
+            if (keyDataset.typed) {
+              dataset.value[keyDataset.value] = valueDataset.value;
+            }
+          }
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function string(message2) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message: message2,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "string") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _subIssues(datasets) {
+  let issues;
+  if (datasets) {
+    for (const dataset of datasets) {
+      if (issues) {
+        issues.push(...dataset.issues);
+      } else {
+        issues = dataset.issues;
+      }
+    }
+  }
+  return issues;
+}
+// @__NO_SIDE_EFFECTS__
+function union(options, message2) {
+  return {
+    kind: "schema",
+    type: "union",
+    reference: union,
+    expects: /* @__PURE__ */ _joinExpects(
+      options.map((option) => option.expects),
+      "|"
+    ),
+    async: false,
+    options,
+    message: message2,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      let validDataset;
+      let typedDatasets;
+      let untypedDatasets;
+      for (const schema of this.options) {
+        const optionDataset = schema["~run"]({ value: dataset.value }, config2);
+        if (optionDataset.typed) {
+          if (optionDataset.issues) {
+            if (typedDatasets) {
+              typedDatasets.push(optionDataset);
+            } else {
+              typedDatasets = [optionDataset];
+            }
+          } else {
+            validDataset = optionDataset;
+            break;
+          }
+        } else {
+          if (untypedDatasets) {
+            untypedDatasets.push(optionDataset);
+          } else {
+            untypedDatasets = [optionDataset];
+          }
+        }
+      }
+      if (validDataset) {
+        return validDataset;
+      }
+      if (typedDatasets) {
+        if (typedDatasets.length === 1) {
+          return typedDatasets[0];
+        }
+        _addIssue(this, "type", dataset, config2, {
+          issues: /* @__PURE__ */ _subIssues(typedDatasets)
+        });
+        dataset.typed = true;
+      } else if (untypedDatasets?.length === 1) {
+        return untypedDatasets[0];
+      } else {
+        _addIssue(this, "type", dataset, config2, {
+          issues: /* @__PURE__ */ _subIssues(untypedDatasets)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+
+// src/protocol/schema.ts
+var CSSStyleSchema = record(
+  string(),
+  union([string(), number()])
 );
-var AlarmElementPropsSchema = v.object({
-  style: v.optional(CSSStyleSchema),
-  className: v.optional(v.string()),
-  id: v.optional(v.string()),
-  src: v.optional(v.string()),
-  alt: v.optional(v.string()),
-  href: v.optional(v.string()),
-  target: v.optional(v.string()),
-  type: v.optional(v.string()),
-  placeholder: v.optional(v.string()),
-  value: v.optional(v.string()),
-  disabled: v.optional(v.boolean())
+var AlarmElementPropsSchema = object({
+  style: optional(CSSStyleSchema),
+  className: optional(string()),
+  id: optional(string()),
+  src: optional(string()),
+  alt: optional(string()),
+  href: optional(string()),
+  target: optional(string()),
+  type: optional(string()),
+  placeholder: optional(string()),
+  value: optional(string()),
+  disabled: optional(boolean())
 });
-var AlarmElementSchema = v.lazy(
-  () => v.object({
-    tag: v.string(),
-    props: v.optional(AlarmElementPropsSchema),
-    children: v.optional(v.array(v.union([AlarmElementSchema, v.string()]))),
-    payload: v.optional(
-      v.object({
-        message: v.string(),
-        pingMessageId: v.optional(v.string())
+var AlarmElementSchema = lazy(
+  () => object({
+    tag: string(),
+    props: optional(AlarmElementPropsSchema),
+    children: optional(array(union([AlarmElementSchema, string()]))),
+    payload: optional(
+      object({
+        message: string(),
+        pingMessageId: optional(string())
       })
     )
   })
 );
-var AlarmMessageInstanceSchema = v.object({
+var AlarmMessageInstanceSchema = object({
   content: AlarmElementSchema,
-  duration: v.optional(v.number())
+  duration: optional(number())
 });
-var TapReadySchema = v.object({
-  type: v.literal("tap:ready"),
-  gaId: v.string()
+var TapReadySchema = object({
+  type: literal("tap:ready"),
+  gaId: string()
 });
-var TapCloseSchema = v.object({
-  type: v.literal("tap:close")
+var TapCloseSchema = object({
+  type: literal("tap:close")
 });
-var TimelineSeekSchema = v.object({
-  type: v.literal("timeline:seek"),
-  clipId: v.string(),
-  clipPlayHead: v.number()
+var TimelineSeekSchema = object({
+  type: literal("timeline:seek"),
+  clipId: string(),
+  clipPlayHead: number()
 });
-var AlarmClickSchema = v.object({
-  type: v.literal("alarm:click"),
+var AlarmClickSchema = object({
+  type: literal("alarm:click"),
   messageInfo: AlarmMessageInstanceSchema
 });
-var AlarmFadeInSchema = v.object({
-  type: v.literal("alarm:fadeIn"),
+var AlarmFadeInSchema = object({
+  type: literal("alarm:fadeIn"),
   messageInfo: AlarmMessageInstanceSchema
 });
-var PopUpOpenSchema = v.object({
-  type: v.literal("popUp:open"),
-  popUpInfo: v.object({
-    html: v.string(),
-    requestId: v.optional(v.string())
+var PopUpOpenSchema = object({
+  type: literal("popUp:open"),
+  popUpInfo: object({
+    html: string(),
+    requestId: optional(string())
   })
 });
-var PopUpCloseSchema = v.object({
-  type: v.literal("popUp:close")
+var PopUpCloseSchema = object({
+  type: literal("popUp:close")
 });
-var MaterialViewOpenSchema = v.object({
-  type: v.literal("material:view:open"),
-  materialId: v.string(),
-  presignedUrl: v.string(),
-  pageStart: v.number(),
-  pageEnd: v.number(),
-  nonce: v.optional(v.union([v.string(), v.number()]))
+var MaterialViewOpenSchema = object({
+  type: literal("material:view:open"),
+  materialId: string(),
+  presignedUrl: string(),
+  pageStart: number(),
+  pageEnd: number(),
+  nonce: optional(union([string(), number()]))
 });
-var MaterialViewCloseSchema = v.object({
-  type: v.literal("material:view:close")
+var MaterialViewCloseSchema = object({
+  type: literal("material:view:close")
 });
-var MaterialViewErrorSchema = v.object({
-  type: v.literal("material:view:error"),
-  materialId: v.string(),
-  error: v.union([
-    v.literal("fetch_failed"),
-    v.literal("expired_url"),
-    v.literal("extraction_failed"),
-    v.literal("unknown")
+var MaterialViewErrorSchema = object({
+  type: literal("material:view:error"),
+  materialId: string(),
+  error: union([
+    literal("fetch_failed"),
+    literal("expired_url"),
+    literal("extraction_failed"),
+    literal("unknown")
   ]),
-  message: v.optional(v.string())
+  message: optional(string())
 });
-var ContainerModeChangeSchema = v.object({
-  type: v.literal("container:mode:change"),
-  mode: v.union([v.literal("floating"), v.literal("sidebar")]),
-  nonce: v.optional(v.union([v.string(), v.number()]))
+var ContainerModeChangeSchema = object({
+  type: literal("container:mode:change"),
+  mode: union([literal("floating"), literal("sidebar")]),
+  nonce: optional(union([string(), number()]))
 });
-var ContainerModeChangeAckSchema = v.object({
-  type: v.literal("container:mode:change:ack"),
-  success: v.boolean(),
-  currentMode: v.union([
-    v.literal("floating"),
-    v.literal("sidebar"),
-    v.literal("floating-forced")
+var ContainerModeChangeAckSchema = object({
+  type: literal("container:mode:change:ack"),
+  success: boolean(),
+  currentMode: union([
+    literal("floating"),
+    literal("sidebar"),
+    literal("floating-forced")
   ]),
-  nonce: v.optional(v.union([v.string(), v.number()]))
+  nonce: optional(union([string(), number()]))
 });
-var ContainerLayoutStateChangedSchema = v.object({
-  type: v.literal("container:layout:state:changed"),
-  layoutState: v.union([
-    v.literal("floating"),
-    v.literal("sidebar"),
-    v.literal("floating-forced")
-  ])
+var ContainerLayoutStateChangedSchema = object({
+  type: literal("container:layout:state:changed"),
+  layoutState: union([literal("floating"), literal("sidebar")]),
+  isNarrowViewport: optional(boolean())
 });
-var ViewportResizeSchema = v.object({
-  type: v.literal("viewport:resize"),
-  viewportWidth: v.number()
+var ViewportResizeSchema = object({
+  type: literal("viewport:resize"),
+  viewportWidth: number()
 });
-var ConfigUpdateSchema = v.object({
-  type: v.literal("config:update"),
-  apiKey: v.optional(v.string()),
-  hostOrigin: v.optional(v.string()),
-  tapUrl: v.optional(v.string()),
-  apiUrl: v.optional(v.string()),
-  environment: v.optional(
-    v.union([
-      v.literal("dev"),
-      v.literal("prod"),
-      v.literal("demo"),
-      v.literal("staging")
+var ConfigUpdateSchema = object({
+  type: literal("config:update"),
+  apiKey: optional(string()),
+  hostOrigin: optional(string()),
+  tapUrl: optional(string()),
+  apiUrl: optional(string()),
+  environment: optional(
+    union([
+      literal("dev"),
+      literal("prod"),
+      literal("demo"),
+      literal("staging")
     ])
   ),
-  language: v.optional(v.string()),
-  userId: v.optional(v.string()),
-  courseId: v.optional(v.string()),
-  clipId: v.optional(v.string()),
-  clipPlayHead: v.optional(v.number()),
-  inline: v.optional(v.boolean()),
-  container: v.optional(
-    v.object({
-      mode: v.optional(
-        v.union([
-          v.literal("auto"),
-          v.literal("floating"),
-          v.literal("sidebar")
-        ])
-      ),
-      floatingConfig: v.optional(
-        v.object({
-          position: v.optional(
-            v.object({
-              top: v.optional(v.string()),
-              left: v.optional(v.string()),
-              right: v.optional(v.string()),
-              bottom: v.optional(v.string())
+  language: optional(string()),
+  userId: optional(string()),
+  courseId: optional(string()),
+  clipId: optional(string()),
+  clipPlayHead: optional(number()),
+  mode: optional(
+    union([literal("inline"), literal("floating"), literal("sidebar")])
+  ),
+  allowLayoutToggle: optional(boolean()),
+  container: optional(
+    object({
+      floatingConfig: optional(
+        object({
+          position: optional(
+            object({
+              top: optional(string()),
+              left: optional(string()),
+              right: optional(string()),
+              bottom: optional(string())
             })
           ),
-          width: v.optional(v.string()),
-          height: v.optional(v.string()),
-          borderRadius: v.optional(v.string())
+          width: optional(string()),
+          height: optional(string()),
+          borderRadius: optional(string())
         })
       ),
-      sidebarConfig: v.optional(
-        v.object({
-          maxWidth: v.optional(v.string()),
-          minViewportWidth: v.optional(v.number())
+      sidebarConfig: optional(
+        object({
+          maxWidth: optional(string()),
+          minViewportWidth: optional(number())
         })
       )
     })
   )
 });
-var GAEventSchema = v.object({
-  type: v.literal("GA_EVENT"),
-  payload: v.record(v.string(), v.any())
+var GAEventSchema = object({
+  type: literal("GA_EVENT"),
+  payload: record(string(), any())
   // 유연한 payload 구조
 });
-var TapMessageSchema = v.union([
+var TapMessageSchema = union([
   TapReadySchema,
   TapCloseSchema,
   TimelineSeekSchema,