stagebook 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1551 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+var _chunkI2WMGA4Qcjs = require('./chunk-I2WMGA4Q.cjs');
+
+// src/schemas/treatment.ts
+var _zod = require('zod');
+var fieldPlaceholderSchema = _zod.z.string().regex(/\$\{[a-zA-Z0-9_]+\}/, {
+  message: "Field placeholder must be in the format `${fieldKey}` (alphanumeric and underscores only)"
+});
+var nameSchema = _zod.z.string().min(1, "Name is required").max(64).regex(/^(?:[a-zA-Z0-9 _-]|\$\{[a-zA-Z0-9_]+\})+$/, {
+  message: "Name must be alphanumeric, cannot have special characters, with optional template fields in the format ${fieldname}"
+});
+var descriptionSchema = _zod.z.string();
+var fileSchema = _zod.z.string().optional();
+var promptFilePathSchema = _zod.z.string().refine((s) => s.endsWith(".prompt.md"), {
+  message: 'Prompt files must use the .prompt.md extension (e.g., "myPrompt.prompt.md")'
+});
+var urlSchema = _zod.z.string().url().refine(
+  (url) => {
+    try {
+      const parsed = new URL(url);
+      return ["http:", "https:"].includes(parsed.protocol);
+    } catch (e2) {
+      return false;
+    }
+  },
+  { message: "URL must use http or https protocol" }
+);
+var durationSchema = _zod.z.number().int().positive();
+var displayTimeSchema = _zod.z.number().int().nonnegative();
+var hideTimeSchema = _zod.z.number().int().positive();
+var positionSchema = _zod.z.number().int().nonnegative();
+var positionSelectorSchema = _zod.z.enum(["shared", "player", "all", "any"]).or(positionSchema).default("player");
+var showToPositionsSchema = _zod.z.array(positionSchema, {
+  required_error: "Expected an array for `showToPositions`. Make sure each item starts with a dash (`-`) in YAML.",
+  invalid_type_error: "Expected an array for `showToPositions`. Make sure each item starts with a dash (`-`) in YAML."
+}).nonempty();
+var hideFromPositionsSchema = _zod.z.array(positionSchema, {
+  required_error: "Expected an array for `hideFromPositions`. Make sure each item starts with a dash (`-`) in YAML.",
+  invalid_type_error: "Expected an array for `hideFromPositions`. Make sure each item starts with a dash (`-`) in YAML."
+}).nonempty();
+var displayRegionRangeSchema = _zod.z.object({
+  first: _zod.z.number().int().nonnegative(),
+  last: _zod.z.number().int().nonnegative()
+}).strict().superRefine((value, ctx) => {
+  if (value.last < value.first) {
+    ctx.addIssue({
+      code: _zod.z.ZodIssueCode.custom,
+      message: "`last` must be greater than or equal to `first`."
+    });
+  }
+});
+var displayRegionAxisSchema = _zod.z.union([
+  _zod.z.number().int().nonnegative(),
+  displayRegionRangeSchema
+]);
+var displayRegionSchema = _zod.z.object({
+  rows: displayRegionAxisSchema,
+  cols: displayRegionAxisSchema
+}).strict();
+var feedMediaSchema = _zod.z.object({
+  audio: _zod.z.boolean().optional(),
+  video: _zod.z.boolean().optional(),
+  screen: _zod.z.boolean().optional()
+}).strict();
+var participantSourceSchema = _zod.z.object({
+  type: _zod.z.literal("participant"),
+  position: positionSchema
+}).strict();
+var selfSourceSchema = _zod.z.object({
+  type: _zod.z.literal("self")
+}).strict();
+var otherSourceSchema = _zod.z.object({
+  type: _zod.z.string().min(1).refine(
+    (value) => value !== "participant" && value !== "self",
+    "Provide additional data using a different source type."
+  ),
+  position: _zod.z.union([positionSchema, _zod.z.string()]).optional()
+}).strict();
+var feedSourceSchema = _zod.z.union([
+  participantSourceSchema,
+  selfSourceSchema,
+  otherSourceSchema
+]);
+var renderHintSchema = _zod.z.union([
+  _zod.z.literal("auto"),
+  _zod.z.literal("tile"),
+  _zod.z.literal("audioOnlyBadge"),
+  _zod.z.literal("hidden"),
+  _zod.z.string().min(1)
+]);
+var feedOptionsSchema = _zod.z.record(_zod.z.string(), _zod.z.unknown());
+var layoutFeedSchema = _zod.z.object({
+  source: feedSourceSchema,
+  media: feedMediaSchema.optional(),
+  displayRegion: displayRegionSchema,
+  zOrder: _zod.z.number().int().optional(),
+  render: renderHintSchema.optional(),
+  label: _zod.z.string().optional(),
+  options: feedOptionsSchema.optional()
+}).strict();
+var layoutFeedDefaultsSchema = _zod.z.object({
+  media: feedMediaSchema.optional(),
+  zOrder: _zod.z.number().int().optional(),
+  render: renderHintSchema.optional(),
+  label: _zod.z.string().optional(),
+  options: feedOptionsSchema.optional()
+}).strict();
+var layoutGridOptionsSchema = _zod.z.object({
+  gap: _zod.z.number().nonnegative().optional(),
+  background: _zod.z.string().optional()
+}).strict();
+var layoutGridSchema = _zod.z.object({
+  rows: _zod.z.number().int().positive(),
+  cols: _zod.z.number().int().positive(),
+  options: layoutGridOptionsSchema.optional()
+}).strict();
+var layoutDefinitionSchema = _zod.z.object({
+  grid: layoutGridSchema,
+  feeds: _zod.z.array(layoutFeedSchema).nonempty(),
+  defaults: layoutFeedDefaultsSchema.optional()
+}).strict().superRefine((value, ctx) => {
+  const gridRows = value.grid.rows;
+  const gridCols = value.grid.cols;
+  value.feeds.forEach((feed, feedIndex) => {
+    const rows = typeof feed.displayRegion.rows === "number" ? { first: feed.displayRegion.rows, last: feed.displayRegion.rows } : feed.displayRegion.rows;
+    const cols = typeof feed.displayRegion.cols === "number" ? { first: feed.displayRegion.cols, last: feed.displayRegion.cols } : feed.displayRegion.cols;
+    if (rows.first >= gridRows || rows.last >= gridRows) {
+      ctx.addIssue({
+        code: _zod.z.ZodIssueCode.custom,
+        path: ["feeds", feedIndex, "displayRegion", "rows"],
+        message: "`rows` indices must be within the grid bounds."
+      });
+    }
+    if (cols.first >= gridCols || cols.last >= gridCols) {
+      ctx.addIssue({
+        code: _zod.z.ZodIssueCode.custom,
+        path: ["feeds", feedIndex, "displayRegion", "cols"],
+        message: "`cols` indices must be within the grid bounds."
+      });
+    }
+  });
+});
+var layoutBySeatSchema = _zod.z.record(_zod.z.string(), layoutDefinitionSchema).superRefine((value, ctx) => {
+  Object.keys(value).forEach((key) => {
+    const seat = Number(key);
+    if (!Number.isInteger(seat) || seat < 0) {
+      ctx.addIssue({
+        code: _zod.z.ZodIssueCode.custom,
+        path: [key],
+        message: "Layout keys must be zero-based nonnegative integers."
+      });
+    }
+  });
+});
+var discussionRoomSchema = _zod.z.object({
+  includePositions: _zod.z.array(positionSchema, {
+    required_error: "Expected an array for `includePositions`. Make sure each item starts with a dash (`-`) in YAML.",
+    invalid_type_error: "Expected an array for `includePositions`. Make sure each item starts with a dash (`-`) in YAML."
+  }).nonempty()
+}).strict();
+var discussionSchema = _zod.z.object({
+  chatType: _zod.z.enum(["text", "audio", "video"]),
+  showNickname: _zod.z.boolean(),
+  showTitle: _zod.z.boolean(),
+  showSelfView: _zod.z.boolean().optional().default(true),
+  showReportMissing: _zod.z.boolean().optional().default(true),
+  showAudioMute: _zod.z.boolean().optional().default(true),
+  showVideoMute: _zod.z.boolean().optional().default(true),
+  reactionEmojisAvailable: _zod.z.array(_zod.z.string()).optional(),
+  reactToSelf: _zod.z.boolean().optional(),
+  numReactionsPerMessage: _zod.z.number().int().nonnegative().optional(),
+  layout: layoutBySeatSchema.optional(),
+  rooms: _zod.z.array(discussionRoomSchema).nonempty().optional(),
+  // New: allow discussion-level position-based visibility controls
+  showToPositions: showToPositionsSchema.optional(),
+  hideFromPositions: hideFromPositionsSchema.optional(),
+  conditions: _zod.z.lazy(() => conditionsSchema).optional()
+}).strict().superRefine((data, ctx) => {
+  if (data.chatType !== "text") {
+    if (data.reactionEmojisAvailable !== void 0) {
+      ctx.addIssue({
+        code: _zod.z.ZodIssueCode.custom,
+        path: ["reactionEmojisAvailable"],
+        message: "reactionEmojisAvailable can only be used with chatType 'text'"
+      });
+    }
+    if (data.reactToSelf !== void 0) {
+      ctx.addIssue({
+        code: _zod.z.ZodIssueCode.custom,
+        path: ["reactToSelf"],
+        message: "reactToSelf can only be used with chatType 'text'"
+      });
+    }
+    if (data.numReactionsPerMessage !== void 0) {
+      ctx.addIssue({
+        code: _zod.z.ZodIssueCode.custom,
+        path: ["numReactionsPerMessage"],
+        message: "numReactionsPerMessage can only be used with chatType 'text'"
+      });
+    }
+  }
+  if (data.layout !== void 0 && data.chatType !== "video") {
+    ctx.addIssue({
+      code: _zod.z.ZodIssueCode.custom,
+      path: ["layout"],
+      message: "layout can only be used with chatType 'video'"
+    });
+  }
+  if (data.rooms !== void 0 && data.chatType !== "video") {
+    ctx.addIssue({
+      code: _zod.z.ZodIssueCode.custom,
+      path: ["rooms"],
+      message: "rooms can only be used with chatType 'video'"
+    });
+  }
+});
+var templateFieldKeysSchema = _zod.z.string().regex(/^(?!d[0-9]+$)([a-zA-Z0-9_]+|\$\{[a-zA-Z0-9_]+\})$/, {
+  message: "Field key must be alphanumeric with underscores only (no hyphens or spaces), or a placeholder `${fieldKey}`. Cannot conflict with reserved keys (d0, d1, etc.)."
+}).min(1).superRefine((val, ctx) => {
+  if (val == "type") {
+    ctx.addIssue({
+      code: _zod.z.ZodIssueCode.custom,
+      message: "Field key cannot be 'type', as it is reserved for element types."
+    });
+  }
+});
+var templateFieldsSchema = _zod.z.record(templateFieldKeysSchema, _zod.z.any());
+var templateBroadcastAxisNameSchema = _zod.z.string().regex(/^d\d+$/, {
+  message: "String must start with 'd' followed by a nonnegative integer"
+});
+var templateBroadcastAxisValuesSchema = _zod.z.lazy(
+  () => _zod.z.array(templateFieldsSchema).nonempty().or(templateContextSchema).or(templateFieldKeysSchema)
+);
+var templateContextSchema = _zod.z.object({
+  template: nameSchema,
+  fields: templateFieldsSchema.optional(),
+  broadcast: _zod.z.record(
+    templateBroadcastAxisNameSchema,
+    templateBroadcastAxisValuesSchema
+  ).optional()
+}).strict();
+function altTemplateContext(baseSchema) {
+  return _zod.z.any().superRefine((data, ctx) => {
+    if (data === void 0) {
+      return;
+    }
+    const schemaToUse = data !== null && typeof data === "object" && "template" in data ? templateContextSchema : baseSchema;
+    const result = schemaToUse.safeParse(data);
+    if (!result.success) {
+      result.error.issues.forEach(
+        (issue) => ctx.addIssue({
+          ...issue,
+          path: [...issue.path]
+        })
+      );
+    }
+  });
+}
+var referenceSchema = _zod.z.string().transform((str) => str.split(".")).superRefine((arr, ctx) => {
+  const [givenType] = arr;
+  let name;
+  let path;
+  switch (givenType) {
+    case "survey":
+    case "submitButton":
+    case "qualtrics":
+      [, name, ...path] = arr;
+      if (path.length < 1) {
+        ctx.addIssue({
+          code: _zod.z.ZodIssueCode.custom,
+          message: `A path must be provided, e.g. '${givenType}.${name}.object.selectors.here'`,
+          path: []
+        });
+      }
+      if (name === void 0 || name.length < 1) {
+        ctx.addIssue({
+          code: _zod.z.ZodIssueCode.custom,
+          message: `A name must be provided, e.g. '${givenType}.elementName.object.selectors.here'`,
+          path: []
+        });
+      }
+      break;
+    case "discussion":
+    case "participantInfo":
+    case "prompt":
+    case "trackedLink":
+      [, name] = arr;
+      if (name === void 0 || name.length < 1) {
+        ctx.addIssue({
+          code: _zod.z.ZodIssueCode.custom,
+          message: `A name must be provided, e.g. '${givenType}.elementName'`,
+          path: []
+        });
+      }
+      break;
+    case "urlParams":
+    case "connectionInfo":
+    case "browserInfo":
+      [, ...path] = arr;
+      if (path.length < 1) {
+        ctx.addIssue({
+          code: _zod.z.ZodIssueCode.custom,
+          message: `A path must be provided, e.g. '${givenType}.object.selectors.here.`,
+          path: []
+        });
+      }
+      break;
+    default:
+      ctx.addIssue({
+        code: _zod.z.ZodIssueCode.custom,
+        message: `Invalid reference type "${givenType}", need to be in form of a valid reference type such as 'survey', 'submitButton', 'qualtrics', 'discussion', 'participantInfo', 'prompt', 'urlParams', 'connectionInfo', or 'browserInfo' followed by a . and name or path.`,
+        path: []
+      });
+  }
+});
+var baseConditionSchema = _zod.z.object({
+  reference: referenceSchema,
+  position: _zod.z.enum(["shared", "player", "all", "any", "percentAgreement"]).or(_zod.z.number().nonnegative().int()).optional()
+}).strict();
+var conditionExistsSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("exists"),
+  value: _zod.z.undefined()
+}).strict();
+var conditionDoesNotExistSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("doesNotExist"),
+  value: _zod.z.undefined()
+}).strict();
+var conditionEqualsSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("equals"),
+  value: _zod.z.string().or(_zod.z.number()).or(_zod.z.boolean()).or(fieldPlaceholderSchema)
+}).strict();
+var conditionDoesNotEqualSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("doesNotEqual"),
+  value: _zod.z.string().or(_zod.z.number()).or(_zod.z.boolean()).or(fieldPlaceholderSchema)
+}).strict();
+var conditionIsAboveSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("isAbove"),
+  value: _zod.z.number().or(fieldPlaceholderSchema)
+}).strict();
+var conditionIsBelowSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("isBelow"),
+  value: _zod.z.number().or(fieldPlaceholderSchema)
+}).strict();
+var conditionIsAtLeastSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("isAtLeast"),
+  value: _zod.z.number().or(fieldPlaceholderSchema)
+}).strict();
+var conditionIsAtMostSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("isAtMost"),
+  value: _zod.z.number().or(fieldPlaceholderSchema)
+}).strict();
+var conditionHasLengthAtLeastSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("hasLengthAtLeast"),
+  value: _zod.z.number().nonnegative().int().or(fieldPlaceholderSchema)
+}).strict();
+var conditionHasLengthAtMostSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("hasLengthAtMost"),
+  value: _zod.z.number().nonnegative().int().or(fieldPlaceholderSchema)
+}).strict();
+var conditionIncludesSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("includes"),
+  value: _zod.z.string().or(fieldPlaceholderSchema)
+}).strict();
+var conditionDoesNotIncludeSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("doesNotInclude"),
+  value: _zod.z.string().or(fieldPlaceholderSchema)
+}).strict();
+var conditionMatchesSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("matches"),
+  value: _zod.z.string().or(fieldPlaceholderSchema)
+}).strict();
+var conditionDoesNotMatchSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("doesNotMatch"),
+  value: _zod.z.string().or(fieldPlaceholderSchema)
+}).strict();
+var conditionIsOneOfSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("isOneOf"),
+  value: _zod.z.array(_zod.z.string().or(_zod.z.number())).nonempty().or(fieldPlaceholderSchema)
+}).strict();
+var conditionIsNotOneOfSchema = baseConditionSchema.extend({
+  comparator: _zod.z.literal("isNotOneOf"),
+  value: _zod.z.array(_zod.z.string().or(_zod.z.number())).nonempty().or(fieldPlaceholderSchema)
+}).strict();
+var conditionSchema = altTemplateContext(
+  _zod.z.discriminatedUnion("comparator", [
+    conditionExistsSchema,
+    conditionDoesNotExistSchema,
+    conditionEqualsSchema,
+    conditionDoesNotEqualSchema,
+    conditionIsAboveSchema,
+    conditionIsBelowSchema,
+    conditionIsAtLeastSchema,
+    conditionIsAtMostSchema,
+    conditionHasLengthAtLeastSchema,
+    conditionHasLengthAtMostSchema,
+    conditionIncludesSchema,
+    conditionDoesNotIncludeSchema,
+    conditionMatchesSchema,
+    conditionDoesNotMatchSchema,
+    conditionIsOneOfSchema,
+    conditionIsNotOneOfSchema
+  ])
+);
+var conditionsSchema = altTemplateContext(
+  _zod.z.array(conditionSchema, {
+    required_error: "Expected an array for `conditions`. Make sure each item starts with a dash (`-`) in YAML.",
+    invalid_type_error: "Expected an array for `conditions`. Make sure each item starts with a dash (`-`) in YAML."
+  }).nonempty()
+);
+var playerSchema = _zod.z.object({
+  desc: descriptionSchema.optional(),
+  position: positionSchema,
+  title: _zod.z.string().max(25).optional(),
+  conditions: _zod.z.array(conditionSchema, {
+    invalid_type_error: "Expected an array for `conditions`. Make sure each item starts with a dash (`-`) in YAML."
+  }).optional()
+}).strict();
+var elementBaseSchema = _zod.z.object({
+  name: nameSchema.optional(),
+  desc: descriptionSchema.optional(),
+  file: fileSchema.or(fieldPlaceholderSchema).optional(),
+  displayTime: displayTimeSchema.or(fieldPlaceholderSchema).optional(),
+  hideTime: hideTimeSchema.or(fieldPlaceholderSchema).optional(),
+  showToPositions: showToPositionsSchema.or(fieldPlaceholderSchema).optional(),
+  hideFromPositions: hideFromPositionsSchema.or(fieldPlaceholderSchema).optional(),
+  conditions: conditionsSchema.optional(),
+  tags: _zod.z.array(_zod.z.string(), {
+    invalid_type_error: "Expected an array for `tags`. Make sure each item starts with a dash (`-`) in YAML."
+  }).optional()
+}).strict();
+var audioSchema = elementBaseSchema.extend({
+  type: _zod.z.literal("audio"),
+  file: fileSchema
+  // Todo: check that file exists
+}).strict();
+var imageSchema = elementBaseSchema.extend({
+  type: _zod.z.literal("image"),
+  file: fileSchema
+  // Todo: check that file exists
+}).strict();
+var displaySchema = elementBaseSchema.extend({
+  type: _zod.z.literal("display"),
+  reference: referenceSchema,
+  position: positionSelectorSchema
+}).strict();
+var promptSchema = elementBaseSchema.extend({
+  type: _zod.z.literal("prompt"),
+  file: promptFilePathSchema,
+  shared: _zod.z.boolean().optional()
+}).strict();
+var promptShorthandSchema = promptFilePathSchema.transform((str) => {
+  const newElement = {
+    type: "prompt",
+    file: str,
+    name: str
+  };
+  return newElement;
+});
+var separatorSchema = elementBaseSchema.extend({
+  type: _zod.z.literal("separator"),
+  style: _zod.z.enum(["thin", "thick", "regular"]).optional()
+}).strict();
+var sharedNotepadSchema = elementBaseSchema.extend({
+  type: _zod.z.literal("sharedNotepad")
+}).strict();
+var submitButtonSchema = elementBaseSchema.extend({
+  type: _zod.z.literal("submitButton"),
+  buttonText: _zod.z.string().max(50).optional()
+}).strict();
+var surveySchema = elementBaseSchema.extend({
+  type: _zod.z.literal("survey"),
+  surveyName: _zod.z.string()
+  // Todo: check that surveyName is a valid survey name
+}).strict();
+var talkMeterSchema = elementBaseSchema.extend({
+  type: _zod.z.literal("talkMeter")
+}).strict();
+var timerSchema = elementBaseSchema.extend({
+  type: _zod.z.literal("timer"),
+  startTime: _zod.z.number().gt(0).optional(),
+  endTime: _zod.z.number().gt(0).optional(),
+  warnTimeRemaining: _zod.z.number().gt(0).optional()
+  // Todo: check that startTime < endTime
+  // Todo: check that warnTimeRemaining < endTime - startTime
+}).strict();
+var mediaPlayerControlsSchema = _zod.z.object({
+  playPause: _zod.z.boolean().optional(),
+  seek: _zod.z.boolean().optional(),
+  step: _zod.z.boolean().optional(),
+  speed: _zod.z.boolean().optional()
+}).strict().optional();
+var mediaPlayerSchema = elementBaseSchema.extend({
+  type: _zod.z.literal("mediaPlayer"),
+  url: _zod.z.string(),
+  playVideo: _zod.z.boolean().optional(),
+  playAudio: _zod.z.boolean().optional(),
+  captionsFile: _zod.z.string().optional(),
+  startAt: _zod.z.number().nonnegative().optional(),
+  stopAt: _zod.z.number().positive().optional(),
+  allowScrubOutsideBounds: _zod.z.boolean().optional(),
+  stepDuration: _zod.z.number().positive().optional(),
+  syncToStageTime: _zod.z.boolean().optional(),
+  submitOnComplete: _zod.z.boolean().optional(),
+  controls: mediaPlayerControlsSchema
+}).strict();
+var timelineSchema = elementBaseSchema.extend({
+  type: _zod.z.literal("timeline"),
+  source: nameSchema,
+  name: nameSchema,
+  selectionType: _zod.z.enum(["range", "point"]),
+  selectionScope: _zod.z.enum(["track", "all"]).optional(),
+  multiSelect: _zod.z.boolean().optional(),
+  showWaveform: _zod.z.boolean().optional(),
+  trackLabels: _zod.z.array(_zod.z.string(), {
+    invalid_type_error: "Expected an array for `trackLabels`. Make sure each item starts with a dash (`-`) in YAML."
+  }).optional()
+}).strict();
+var trackedLinkParamSchema = _zod.z.object({
+  key: _zod.z.string().min(1),
+  value: _zod.z.union([_zod.z.string(), _zod.z.number(), _zod.z.boolean(), fieldPlaceholderSchema]).optional(),
+  reference: referenceSchema.optional(),
+  position: positionSelectorSchema.optional()
+}).strict().superRefine((data, ctx) => {
+  if (data.value !== void 0 && data.reference !== void 0) {
+    ctx.addIssue({
+      code: _zod.z.ZodIssueCode.custom,
+      message: "Provide either `value` or `reference`, not both.",
+      path: ["value"]
+    });
+  }
+});
+var qualtricsSchema = elementBaseSchema.extend({
+  type: _zod.z.literal("qualtrics"),
+  url: urlSchema,
+  urlParams: _zod.z.array(trackedLinkParamSchema, {
+    invalid_type_error: "Expected an array for `urlParams`. Make sure each item starts with a dash (`-`) in YAML."
+  }).optional()
+}).strict();
+var trackedLinkSchema = elementBaseSchema.extend({
+  type: _zod.z.literal("trackedLink"),
+  name: nameSchema,
+  url: urlSchema,
+  displayText: _zod.z.string().min(1),
+  helperText: _zod.z.string().optional(),
+  urlParams: _zod.z.array(trackedLinkParamSchema, {
+    invalid_type_error: "Expected an array for `urlParams`. Make sure each item starts with a dash (`-`) in YAML."
+  }).optional()
+}).strict();
+var elementSchema = altTemplateContext(
+  _zod.z.any().superRefine((data, ctx) => {
+    const isObject = typeof data === "object" && data !== null;
+    const hasTypeKey = isObject && "type" in data;
+    const schemaToUse = hasTypeKey ? _zod.z.discriminatedUnion("type", [
+      audioSchema,
+      displaySchema,
+      imageSchema,
+      promptSchema,
+      qualtricsSchema,
+      separatorSchema,
+      sharedNotepadSchema,
+      submitButtonSchema,
+      surveySchema,
+      talkMeterSchema,
+      timerSchema,
+      mediaPlayerSchema,
+      timelineSchema,
+      trackedLinkSchema
+    ]) : promptShorthandSchema;
+    const result = schemaToUse.safeParse(data);
+    if (!result.success) {
+      if (!hasTypeKey && isObject && schemaToUse === promptShorthandSchema) {
+        ctx.addIssue({
+          code: "invalid_type",
+          expected: "string",
+          received: "object",
+          message: `promptShorthandSchema expects a string, but received object.`
+        });
+        for (const key of Object.keys(data)) {
+          ctx.addIssue({
+            code: "unrecognized_keys",
+            keys: [key]
+          });
+        }
+      } else {
+        result.error.issues.forEach(
+          (issue) => ctx.addIssue({
+            ...issue,
+            path: [...issue.path]
+          })
+        );
+      }
+    }
+    if (isObject && data.type === "mediaPlayer" && result.success) {
+      const mp = data;
+      if (mp.startAt !== void 0 && mp.stopAt !== void 0 && mp.stopAt <= mp.startAt) {
+        ctx.addIssue({
+          code: _zod.z.ZodIssueCode.custom,
+          message: "stopAt must be greater than startAt",
+          path: ["stopAt"]
+        });
+      }
+      const mpSync = data;
+      if (mpSync.syncToStageTime && mpSync.controls) {
+        ctx.addIssue({
+          code: _zod.z.ZodIssueCode.custom,
+          message: "controls cannot be specified when syncToStageTime is true (playback is locked to stage time)",
+          path: ["controls"]
+        });
+      }
+    }
+  })
+);
+var elementsSchema = altTemplateContext(
+  _zod.z.array(elementSchema, {
+    required_error: "Expected an array for `elements`. Make sure each item starts with a dash (`-`) in YAML.",
+    invalid_type_error: "Expected an array for `elements`. Make sure each item starts with a dash (`-`) in YAML."
+  }).nonempty()
+);
+var stageSchema = altTemplateContext(
+  _zod.z.object({
+    name: nameSchema,
+    desc: descriptionSchema.optional(),
+    discussion: discussionSchema.optional(),
+    duration: durationSchema.or(fieldPlaceholderSchema),
+    elements: elementsSchema
+  }).strict().superRefine((data, ctx) => {
+    if (!data.elements) {
+      ctx.addIssue({
+        code: _zod.z.ZodIssueCode.custom,
+        message: "Stage must have elements field (check elementsSchema)."
+      });
+    }
+    const duration = data.duration;
+    if (typeof duration !== "number" || !Array.isArray(data.elements)) return;
+    data.elements.forEach(
+      (element, elementIndex) => {
+        if (!element || typeof element !== "object") return;
+        const timeFields = [
+          "displayTime",
+          "hideTime",
+          "startTime",
+          "endTime"
+        ];
+        for (const field of timeFields) {
+          const value = element[field];
+          if (typeof value === "number" && value > duration) {
+            ctx.addIssue({
+              code: _zod.z.ZodIssueCode.custom,
+              path: ["elements", elementIndex, field],
+              message: `${field} (${value}) exceeds stage duration (${duration}) for element "${String(element.name || element.type)}"`
+            });
+          }
+        }
+      }
+    );
+  })
+);
+var stagesSchema = altTemplateContext(
+  _zod.z.array(stageSchema, {
+    required_error: "Expected an array for `stages`. Make sure each item starts with a dash (`-`) in YAML.",
+    invalid_type_error: "Expected an array for `stages`. Make sure each item starts with a dash (`-`) in YAML."
+  }).nonempty()
+);
+var introExitStepSchema = altTemplateContext(
+  _zod.z.object({
+    name: nameSchema,
+    desc: descriptionSchema.optional(),
+    elements: elementsSchema
+  }).strict()
+);
+var introExitStepsBaseSchema = altTemplateContext(
+  _zod.z.array(introExitStepSchema, {
+    required_error: "Expected an array for `introSteps`. Make sure each item starts with a dash (`-`) in YAML.",
+    invalid_type_error: "Expected an array for `introSteps`. Make sure each item starts with a dash (`-`) in YAML."
+  }).nonempty()
+);
+var introExitStepsSchema = introExitStepsBaseSchema;
+function isAdvancementElement(element) {
+  if (!element || typeof element !== "object") return false;
+  const el = element;
+  if (el.type === "submitButton") return true;
+  if (el.type === "survey") return true;
+  if (el.type === "qualtrics") return true;
+  if (el.type === "mediaPlayer" && el.submitOnComplete === true) return true;
+  return false;
+}
+var introStepsSchema = introExitStepsBaseSchema.superRefine(
+  (data, ctx) => {
+    _optionalChain([data, 'optionalAccess', _2 => _2.forEach, 'call', _3 => _3((step, stepIdx) => {
+      if (Array.isArray(step.elements)) {
+        step.elements.forEach((element, elementIdx) => {
+          if (element && typeof element === "object" && "shared" in element && element.shared) {
+            ctx.addIssue({
+              code: _zod.z.ZodIssueCode.custom,
+              path: [stepIdx, "elements", elementIdx, "shared"],
+              message: `Prompt element in intro/exit steps cannot be shared.`
+            });
+          }
+          if (element && typeof element === "object" && "position" in element) {
+            ctx.addIssue({
+              code: _zod.z.ZodIssueCode.custom,
+              path: [stepIdx, "elements", elementIdx, "position"],
+              message: `Elements in intro steps cannot have a 'position' field.`
+            });
+          }
+          if (element && typeof element === "object" && "showToPositions" in element) {
+            ctx.addIssue({
+              code: _zod.z.ZodIssueCode.custom,
+              path: [stepIdx, "elements", elementIdx],
+              message: `Elements in intro steps cannot have a 'showToPositions' field.`
+            });
+          }
+          if (element && typeof element === "object" && "hideFromPositions" in element) {
+            ctx.addIssue({
+              code: _zod.z.ZodIssueCode.custom,
+              path: [stepIdx, "elements", elementIdx],
+              message: `Elements in intro steps cannot have a 'hideFromPositions' field.`
+            });
+          }
+        });
+        if (!step.elements.some(isAdvancementElement)) {
+          ctx.addIssue({
+            code: _zod.z.ZodIssueCode.custom,
+            path: [stepIdx, "elements"],
+            message: "Intro/exit step must include at least one advancement element: submitButton, survey, qualtrics, or mediaPlayer with submitOnComplete: true."
+          });
+        }
+      }
+    })]);
+  }
+);
+var exitStepsSchema = introExitStepsBaseSchema.superRefine(
+  (data, ctx) => {
+    _optionalChain([data, 'optionalAccess', _4 => _4.forEach, 'call', _5 => _5((step, stepIdx) => {
+      if (Array.isArray(step.elements)) {
+        step.elements.forEach((element, elementIdx) => {
+          if (element && typeof element === "object" && "shared" in element && element.shared) {
+            ctx.addIssue({
+              code: _zod.z.ZodIssueCode.custom,
+              path: [stepIdx, "elements", elementIdx, "shared"],
+              message: `Prompt element in intro/exit steps cannot be shared.`
+            });
+          }
+        });
+        if (!step.elements.some(isAdvancementElement)) {
+          ctx.addIssue({
+            code: _zod.z.ZodIssueCode.custom,
+            path: [stepIdx, "elements"],
+            message: "Intro/exit step must include at least one advancement element: submitButton, survey, qualtrics, or mediaPlayer with submitOnComplete: true."
+          });
+        }
+      }
+    })]);
+  }
+);
+var introSequenceSchema = altTemplateContext(
+  _zod.z.object({
+    name: nameSchema,
+    desc: descriptionSchema.optional(),
+    introSteps: introStepsSchema
+  }).strict()
+);
+var introSequencesSchema = altTemplateContext(
+  _zod.z.array(introSequenceSchema, {
+    required_error: "Expected an array for `introSequence`. Make sure each item starts with a dash (`-`) in YAML.",
+    invalid_type_error: "Expected an array for `introSequence`. Make sure each item starts with a dash (`-`) in YAML."
+  }).nonempty()
+);
+var baseTreatmentSchema = _zod.z.object({
+  name: nameSchema,
+  desc: descriptionSchema.optional(),
+  playerCount: _zod.z.number(),
+  groupComposition: _zod.z.array(playerSchema, {
+    invalid_type_error: "Expected an array for `groupComposition`. Make sure each item starts with a dash (`-`) in YAML."
+  }).optional(),
+  gameStages: stagesSchema,
+  exitSequence: exitStepsSchema.optional()
+}).strict();
+var treatmentSchema = altTemplateContext(
+  baseTreatmentSchema.superRefine((treatment, ctx) => {
+    const baseResult = baseTreatmentSchema.safeParse(treatment);
+    if (!baseResult.success) {
+      return;
+    }
+    const { playerCount, groupComposition, gameStages } = treatment;
+    _optionalChain([groupComposition, 'optionalAccess', _6 => _6.forEach, 'call', _7 => _7((player, index) => {
+      if (typeof player.position === "number" && player.position >= playerCount) {
+        ctx.addIssue({
+          code: _zod.z.ZodIssueCode.custom,
+          path: ["groupComposition", index, "position"],
+          message: `Player position index ${player.position} in groupComposition exceeds playerCount of ${playerCount}.`
+        });
+      }
+    })]);
+    if (groupComposition) {
+      const positions = groupComposition.map((player) => player.position).filter((pos) => typeof pos === "number");
+      const uniquePositions = new Set(positions);
+      if (uniquePositions.size !== positions.length) {
+        ctx.addIssue({
+          code: _zod.z.ZodIssueCode.custom,
+          path: ["groupComposition"],
+          message: `Player positions in groupComposition must be unique.`
+        });
+      }
+      const expectedPositions = Array.from(
+        { length: playerCount },
+        (_, i) => i
+      );
+      const missingPositions = expectedPositions.filter(
+        (pos) => !uniquePositions.has(pos)
+      );
+      if (missingPositions.length > 0) {
+        ctx.addIssue({
+          code: _zod.z.ZodIssueCode.custom,
+          path: ["groupComposition"],
+          message: `Player positions in groupComposition must include all nonnegative integers below playerCount (${playerCount}). Missing: ${missingPositions.join(", ")}.`
+        });
+      }
+    }
+    _optionalChain([gameStages, 'optionalAccess', _8 => _8.forEach, 'call', _9 => _9(
+      (stage, stageIndex) => {
+        _optionalChain([stage, 'optionalAccess', _10 => _10.elements, 'optionalAccess', _11 => _11.forEach, 'call', _12 => _12(
+          (element, elementIndex) => {
+            ["showToPositions", "hideFromPositions"].forEach((key) => {
+              const positions = element[key];
+              if (Array.isArray(positions)) {
+                _optionalChain([positions, 'optionalAccess', _13 => _13.forEach, 'call', _14 => _14((pos, posIndex) => {
+                  if (typeof pos === "number" && pos >= playerCount) {
+                    ctx.addIssue({
+                      code: _zod.z.ZodIssueCode.custom,
+                      path: [
+                        "gameStages",
+                        stageIndex,
+                        "elements",
+                        elementIndex,
+                        key,
+                        posIndex
+                      ],
+                      message: `${key} index ${pos} in stage "${stage.name}" exceeds playerCount of ${playerCount}.`
+                    });
+                  }
+                })]);
+              }
+            });
+          }
+        )]);
+        const discussion = _optionalChain([stage, 'optionalAccess', _15 => _15.discussion]);
+        if (discussion) {
+          ["showToPositions", "hideFromPositions"].forEach((key) => {
+            const positions = _optionalChain([discussion, 'optionalAccess', _16 => _16[key]]);
+            if (Array.isArray(positions)) {
+              positions.forEach((pos, posIndex) => {
+                if (typeof pos === "number" && pos >= playerCount) {
+                  ctx.addIssue({
+                    code: _zod.z.ZodIssueCode.custom,
+                    path: [
+                      "gameStages",
+                      stageIndex,
+                      "discussion",
+                      key,
+                      posIndex
+                    ],
+                    message: `${key} index ${pos} in discussion of stage "${stage.name}" exceeds playerCount of ${playerCount}.`
+                  });
+                }
+              });
+            }
+          });
+          const { rooms, showToPositions, hideFromPositions } = discussion || {};
+          if (Array.isArray(rooms) && rooms.length > 0) {
+            const allPositions = Array.from(
+              { length: playerCount },
+              (_, i) => i
+            );
+            let candidatePositions = allPositions;
+            if (Array.isArray(showToPositions) && showToPositions.length > 0) {
+              candidatePositions = candidatePositions.filter(
+                (p) => showToPositions.includes(p)
+              );
+            }
+            if (Array.isArray(hideFromPositions) && hideFromPositions.length > 0) {
+              candidatePositions = candidatePositions.filter(
+                (p) => !hideFromPositions.includes(p)
+              );
+            }
+            const assigned = /* @__PURE__ */ new Set();
+            rooms.forEach(
+              (room, roomIndex) => {
+                const inc = _optionalChain([room, 'optionalAccess', _17 => _17.includePositions]);
+                if (Array.isArray(inc)) {
+                  inc.forEach((pos, posIndex) => {
+                    if (typeof pos === "number") {
+                      assigned.add(pos);
+                      if (pos >= playerCount) {
+                        ctx.addIssue({
+                          code: _zod.z.ZodIssueCode.custom,
+                          path: [
+                            "gameStages",
+                            stageIndex,
+                            "discussion",
+                            "rooms",
+                            roomIndex,
+                            "includePositions",
+                            posIndex
+                          ],
+                          message: `includePositions index ${pos} in discussion room exceeds playerCount of ${playerCount}.`
+                        });
+                      }
+                    }
+                  });
+                }
+              }
+            );
+            const missing = candidatePositions.filter(
+              (p) => !assigned.has(p)
+            );
+            if (missing.length > 0) {
+              ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                path: ["gameStages", stageIndex, "discussion", "rooms"],
+                message: `Rooms defined but the following visible player positions are not assigned to any room: ${missing.join(
+                  ", "
+                )}. Each visible position (respecting showToPositions/hideFromPositions) must appear in one includePositions array.`
+              });
+            }
+          }
+        }
+      }
+    )]);
+  })
+);
+var treatmentsSchema = altTemplateContext(
+  _zod.z.array(treatmentSchema, {
+    required_error: "Expected an array for `treatments`. Make sure each item starts with a dash (`-`) in YAML.",
+    invalid_type_error: "Expected an array for `treatments`. Make sure each item starts with a dash (`-`) in YAML."
+  }).nonempty()
+);
+var templateContentSchema = _zod.z.any().superRefine((data, ctx) => {
+  const schemas = [
+    { schema: introSequenceSchema, name: "Intro Sequence" },
+    { schema: introSequencesSchema, name: "Intro Sequences" },
+    { schema: elementsSchema, name: "Elements" },
+    { schema: elementSchema, name: "Element" },
+    { schema: stageSchema, name: "Stage" },
+    { schema: stagesSchema, name: "Stages" },
+    { schema: treatmentSchema, name: "Treatment" },
+    { schema: treatmentsSchema, name: "Treatments" },
+    { schema: referenceSchema, name: "Reference" },
+    { schema: conditionSchema, name: "Condition" },
+    { schema: playerSchema, name: "Player" },
+    // specify intro step or exit step, not both
+    { schema: introExitStepSchema, name: "Intro Exit Step" },
+    { schema: exitStepsSchema, name: "Exit Steps" },
+    //commented out for now, matches too many schemas
+    {
+      schema: templateBroadcastAxisValuesSchema,
+      name: "Template Broadcast Axis Values"
+    }
+  ];
+  let bestSchemaResult = null;
+  let fewestUnmatchedKeys = Infinity;
+  for (const { schema, name } of schemas) {
+    const result = schema.safeParse(data);
+    if (result.success) {
+      console.log(`Schema "${name}" matched successfully.`);
+      return;
+    } else {
+      const rootTypeError = result.error.issues.find(
+        (issue) => issue.code === "invalid_type" && issue.path.length === 0
+      );
+      if (rootTypeError) {
+        continue;
+      }
+      const discriminatorIssue = result.error.issues.find(
+        (issue) => issue.code === "invalid_union_discriminator" && issue.path.length === 1
+      );
+      const promptShorthandIssue = result.error.issues.find(
+        (issue) => issue.code === "invalid_type" && issue.expected === "string" && issue.received === "object" && issue.message === "promptShorthandSchema expects a string, but received object."
+      );
+      if (discriminatorIssue !== void 0) {
+        continue;
+      }
+      const unmatchedKeysCount = result.error.issues.filter((issue) => issue.code === "unrecognized_keys").reduce(
+        (sum, issue) => sum + (issue.keys ? issue.keys.length : 0),
+        0
+      );
+      if (unmatchedKeysCount < fewestUnmatchedKeys) {
+        if (promptShorthandIssue) {
+          continue;
+        }
+        fewestUnmatchedKeys = unmatchedKeysCount;
+        bestSchemaResult = { result, name };
+      }
+    }
+  }
+  if (bestSchemaResult) {
+    console.log(
+      `Best schema match is "${bestSchemaResult.name}" with ${fewestUnmatchedKeys} unmatched keys.`
+    );
+    bestSchemaResult.result.error.issues.forEach((issue) => {
+      ctx.addIssue({
+        ...issue,
+        path: issue.path,
+        message: `Closest schema match: ${bestSchemaResult.name}. ${issue.message}`
+      });
+    });
+  } else {
+    ctx.addIssue({
+      code: _zod.z.ZodIssueCode.custom,
+      message: "No schema matched the provided data."
+    });
+  }
+});
+var templateSchema = _zod.z.object({
+  templateName: nameSchema,
+  contentType: _zod.z.enum([
+    "introSequence",
+    "introSequences",
+    "elements",
+    "element",
+    "stage",
+    "stages",
+    "treatment",
+    "treatments",
+    "reference",
+    "condition",
+    "player",
+    "introExitStep",
+    "exitSteps",
+    "other"
+  ]).optional(),
+  templateDesc: descriptionSchema.optional(),
+  templateContent: _zod.z.any()
+}).strict().superRefine((data, ctx) => {
+  if (!data.contentType) {
+    const res = templateContentSchema.safeParse(data.templateContent);
+    if (!res.success) {
+      res.error.issues.forEach(
+        (issue) => ctx.addIssue({
+          ...issue,
+          path: ["templateContent", ...issue.path]
+        })
+      );
+    }
+    ctx.addIssue({
+      code: _zod.z.ZodIssueCode.custom,
+      message: "contentType field is required. Please specify a valid content type. Valid content types are 'introSequence', 'introSequences', 'elements', 'element', 'stage', 'stages', 'treatment', 'treatments', 'reference', 'condition', 'player', 'introExitStep', or 'exitSteps'."
+    });
+    return;
+  } else if (data.contentType === "other") {
+    ctx.addIssue({
+      code: _zod.z.ZodIssueCode.custom,
+      message: "contentType 'other' cannot be validated. Only use when custom content is required that does not match any of the other defined content types. Please use at your own discretion."
+    });
+    return;
+  }
+  const result = matchContentType(data.contentType).safeParse(
+    data.templateContent
+  );
+  if (!result.success) {
+    result.error.issues.forEach(
+      (issue) => ctx.addIssue({
+        ...issue,
+        path: ["templateContent", ...issue.path],
+        message: `Invalid template content for content type '${data.contentType}': ${issue.message}`
+      })
+    );
+  }
+});
+function matchContentType(contentType) {
+  switch (contentType) {
+    case "introSequence":
+      return introSequenceSchema;
+    case "introSequences":
+      return introSequencesSchema;
+    case "elements":
+      return elementsSchema;
+    case "element":
+      return elementSchema;
+    case "stage":
+      return stageSchema;
+    case "stages":
+      return stagesSchema;
+    case "treatment":
+      return treatmentSchema;
+    case "treatments":
+      return treatmentsSchema;
+    case "reference":
+      return referenceSchema;
+    case "condition":
+      return conditionSchema;
+    case "player":
+      return playerSchema;
+    case "introExitStep":
+      return introExitStepSchema;
+    case "exitSteps":
+      return exitStepsSchema;
+    default:
+      throw new Error(`Unknown content type: ${contentType}`);
+  }
+}
+var treatmentFileSchema = _zod.z.object({
+  templates: _zod.z.array(templateSchema).min(1, "Templates cannot be empty").optional(),
+  introSequences: introSequencesSchema,
+  treatments: treatmentsSchema
+});
+
+// src/schemas/resolved.ts
+
+var resolvedConditionSchema = _zod.z.object({
+  reference: referenceSchema,
+  position: _zod.z.enum(["shared", "player", "all", "any", "percentAgreement"]).or(_zod.z.number().nonnegative().int()).optional(),
+  comparator: _zod.z.enum([
+    "exists",
+    "doesNotExist",
+    "equals",
+    "doesNotEqual",
+    "isAbove",
+    "isBelow",
+    "isAtLeast",
+    "isAtMost",
+    "hasLengthAtLeast",
+    "hasLengthAtMost",
+    "includes",
+    "doesNotInclude",
+    "matches",
+    "doesNotMatch",
+    "isOneOf",
+    "isNotOneOf"
+  ]),
+  value: _zod.z.union([
+    _zod.z.string(),
+    _zod.z.number(),
+    _zod.z.boolean(),
+    _zod.z.array(_zod.z.string().or(_zod.z.number()))
+  ]).optional()
+}).strict();
+var resolvedConditionsSchema = _zod.z.array(resolvedConditionSchema).optional();
+var resolvedElementBaseSchema = _zod.z.object({
+  type: _zod.z.string(),
+  name: nameSchema.optional(),
+  desc: descriptionSchema.optional(),
+  file: _zod.z.string().optional(),
+  displayTime: displayTimeSchema.optional(),
+  hideTime: hideTimeSchema.optional(),
+  showToPositions: showToPositionsSchema.optional(),
+  hideFromPositions: hideFromPositionsSchema.optional(),
+  conditions: resolvedConditionsSchema,
+  tags: _zod.z.array(_zod.z.string()).optional(),
+  // Allow additional fields for specific element types
+  shared: _zod.z.boolean().optional(),
+  buttonText: _zod.z.string().optional(),
+  url: _zod.z.string().optional(),
+  displayText: _zod.z.string().optional(),
+  helperText: _zod.z.string().optional(),
+  reference: _zod.z.string().optional(),
+  position: positionSelectorSchema.optional(),
+  surveyName: _zod.z.string().optional(),
+  startTime: _zod.z.number().optional(),
+  endTime: _zod.z.number().optional(),
+  warnTimeRemaining: _zod.z.number().optional(),
+  style: _zod.z.enum(["thin", "regular", "thick", ""]).optional(),
+  width: _zod.z.number().optional(),
+  urlParams: _zod.z.array(
+    _zod.z.object({
+      key: _zod.z.string(),
+      value: _zod.z.union([_zod.z.string(), _zod.z.number(), _zod.z.boolean()]).optional(),
+      reference: _zod.z.string().optional(),
+      position: positionSelectorSchema.optional()
+    })
+  ).optional(),
+  // mediaPlayer fields
+  syncToStageTime: _zod.z.boolean().optional(),
+  submitOnComplete: _zod.z.boolean().optional(),
+  playVideo: _zod.z.boolean().optional(),
+  playAudio: _zod.z.boolean().optional(),
+  captionsFile: _zod.z.string().optional(),
+  startAt: _zod.z.number().optional(),
+  stopAt: _zod.z.number().optional(),
+  allowScrubOutsideBounds: _zod.z.boolean().optional(),
+  stepDuration: _zod.z.number().optional(),
+  controls: _zod.z.object({
+    playPause: _zod.z.boolean().optional(),
+    seek: _zod.z.boolean().optional(),
+    step: _zod.z.boolean().optional(),
+    speed: _zod.z.boolean().optional()
+  }).optional()
+});
+var resolvedElementSchema = resolvedElementBaseSchema;
+var resolvedStageSchema = _zod.z.object({
+  name: nameSchema,
+  desc: descriptionSchema.optional(),
+  discussion: discussionSchema.optional(),
+  duration: durationSchema,
+  elements: _zod.z.array(resolvedElementSchema).nonempty()
+});
+var resolvedIntroExitStepSchema = _zod.z.object({
+  name: nameSchema,
+  desc: descriptionSchema.optional(),
+  elements: _zod.z.array(resolvedElementSchema).nonempty()
+});
+var resolvedTreatmentSchema = _zod.z.object({
+  name: nameSchema,
+  desc: descriptionSchema.optional(),
+  playerCount: _zod.z.number(),
+  groupComposition: _zod.z.array(
+    _zod.z.object({
+      desc: descriptionSchema.optional(),
+      position: positionSchema,
+      title: _zod.z.string().max(25).optional(),
+      conditions: resolvedConditionsSchema
+    })
+  ).optional(),
+  gameStages: _zod.z.array(resolvedStageSchema).nonempty(),
+  exitSequence: _zod.z.array(resolvedIntroExitStepSchema).optional()
+});
+
+// src/utils/reference.ts
+function getNestedValueByPath(obj, path = []) {
+  return path.reduce(
+    (acc, key) => acc !== null && acc !== void 0 ? acc[key] : void 0,
+    obj
+  );
+}
+function getReferenceKeyAndPath(reference) {
+  const segments = reference.split(".");
+  const [type, ...rest] = segments;
+  let name;
+  let path = [];
+  let referenceKey;
+  if (["survey", "submitButton", "qualtrics"].includes(type)) {
+    [name, ...path] = rest;
+    referenceKey = `${type}_${name}`;
+  } else if (type === "prompt") {
+    [name] = rest;
+    referenceKey = `${type}_${name}`;
+    path = ["value"];
+  } else if (type === "trackedLink") {
+    [name, ...path] = rest;
+    referenceKey = `trackedLink_${name}`;
+  } else if (["urlParams", "connectionInfo", "browserInfo"].includes(type)) {
+    path = rest;
+    referenceKey = type;
+  } else if (["participantInfo", "discussion"].includes(type)) {
+    [name, ...path] = rest;
+    referenceKey = name;
+  } else {
+    throw new Error(`Invalid reference type: ${type}`);
+  }
+  if (!referenceKey || !name && [
+    "survey",
+    "submitButton",
+    "qualtrics",
+    "prompt",
+    "trackedLink",
+    "participantInfo",
+    "discussion"
+  ].includes(type)) {
+    throw new Error(`Reference ${reference} is missing a name segment.`);
+  }
+  return { referenceKey, path };
+}
+
+// src/templates/fillTemplates.ts
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var FIELD_PLACEHOLDER_REGEX = /\$\{([a-zA-Z0-9_]+)\}/g;
+function substituteFields({
+  templateContent,
+  fields
+}) {
+  let expandedTemplate = JSON.parse(JSON.stringify(templateContent));
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === void 0) continue;
+    let stringifiedTemplate = JSON.stringify(expandedTemplate);
+    const stringifiedValue = JSON.stringify(value);
+    const escapedKey = escapeRegExp(key);
+    const objectReplacementRegex = new RegExp(`"\\$\\{${escapedKey}\\}"`, "g");
+    stringifiedTemplate = stringifiedTemplate.replace(
+      objectReplacementRegex,
+      stringifiedValue
+    );
+    if (typeof value === "string") {
+      const stringReplacementRegex = new RegExp(`\\$\\{${escapedKey}\\}`, "g");
+      stringifiedTemplate = stringifiedTemplate.replace(
+        stringReplacementRegex,
+        value
+      );
+    }
+    expandedTemplate = JSON.parse(stringifiedTemplate);
+  }
+  return expandedTemplate;
+}
+function expandTemplate({
+  templates,
+  context
+}) {
+  const newContext = JSON.parse(JSON.stringify(context));
+  if (newContext.fields) {
+    newContext.fields = recursivelyFillTemplates({
+      obj: newContext.fields,
+      templates
+    });
+  }
+  if (newContext.broadcast) {
+    newContext.broadcast = recursivelyFillTemplates({
+      obj: newContext.broadcast,
+      templates
+    });
+  }
+  const template = templates.find(
+    (t) => t.templateName === newContext.template
+  );
+  if (!template) {
+    throw new Error(`Template "${newContext.template}" not found`);
+  }
+  let expandedTemplate = JSON.parse(JSON.stringify(template.templateContent));
+  if (newContext.fields) {
+    expandedTemplate = substituteFields({
+      templateContent: expandedTemplate,
+      fields: newContext.fields
+    });
+  }
+  function flattenBroadcast(dimensions) {
+    const dimensionIndices = Object.keys(dimensions);
+    const dimensionNumbers = dimensionIndices.map((i) => parseInt(i.slice(1)));
+    const lowestDimension = Math.min(...dimensionNumbers);
+    const currentDimension = dimensions[`d${lowestDimension}`];
+    const remainingDimensions = JSON.parse(JSON.stringify(dimensions));
+    delete remainingDimensions[`d${lowestDimension}`];
+    let partialFields = [{}];
+    if (Object.keys(remainingDimensions).length > 0) {
+      partialFields = flattenBroadcast(remainingDimensions);
+    }
+    const flatFields = [];
+    for (const [index, entry] of currentDimension.entries()) {
+      for (const partialField of partialFields) {
+        const newField = { ...entry, ...partialField };
+        newField[`d${lowestDimension}`] = `${index}`;
+        flatFields.push(newField);
+      }
+    }
+    return flatFields;
+  }
+  if (newContext.broadcast) {
+    const broadcastFieldsArray = flattenBroadcast(newContext.broadcast);
+    const returnObjects = [];
+    for (const broadcastFields of broadcastFieldsArray) {
+      const newObj = substituteFields({
+        templateContent: expandedTemplate,
+        fields: broadcastFields
+      });
+      if (Array.isArray(newObj)) {
+        returnObjects.push(...newObj);
+      } else if (typeof newObj === "object") {
+        returnObjects.push(newObj);
+      } else {
+        throw new Error("Unexpected type in broadcast fields");
+      }
+    }
+    return returnObjects;
+  }
+  return expandedTemplate;
+}
+var MAX_TEMPLATE_DEPTH = 100;
+function recursivelyFillTemplates({
+  obj,
+  templates,
+  depth = 0,
+  templateChain = []
+}) {
+  if (depth > MAX_TEMPLATE_DEPTH) {
+    const chain = templateChain.length > 0 ? ` Template chain: ${templateChain.slice(-10).join(" \u2192 ")}` : "";
+    throw new Error(
+      `Maximum template nesting depth (${MAX_TEMPLATE_DEPTH}) exceeded.${chain} Check for circular template references in your treatment file.`
+    );
+  }
+  let newObj;
+  try {
+    newObj = JSON.parse(JSON.stringify(obj));
+  } catch (e) {
+    console.log("Error parsing", obj);
+    throw e;
+  }
+  if (!Array.isArray(newObj) && typeof newObj === "object") {
+    if (newObj && newObj.template) {
+      const templateName = newObj.template;
+      const context = templateContextSchema.parse(newObj);
+      newObj = expandTemplate({ templates, context });
+      newObj = recursivelyFillTemplates({
+        obj: newObj,
+        templates,
+        depth: depth + 1,
+        templateChain: [...templateChain, templateName]
+      });
+    } else {
+      for (const key in newObj) {
+        if (newObj[key] == null) {
+          console.log(`key ${key} is undefined in`, newObj);
+        }
+        newObj[key] = recursivelyFillTemplates({
+          obj: newObj[key],
+          templates,
+          depth: depth + 1,
+          templateChain
+        });
+      }
+    }
+  } else if (Array.isArray(newObj)) {
+    for (const [index, item] of newObj.entries()) {
+      if (item.template) {
+        const context = templateContextSchema.parse(item);
+        const expandedItem = expandTemplate({ templates, context });
+        if (Array.isArray(expandedItem)) {
+          newObj.splice(index, 1, ...expandedItem);
+        } else if (typeof expandedItem === "object") {
+          newObj[index] = expandedItem;
+        } else {
+          throw new Error("Unexpected type in expanded item");
+        }
+      } else {
+        newObj[index] = recursivelyFillTemplates({
+          obj: item,
+          templates,
+          depth: depth + 1,
+          templateChain
+        });
+      }
+    }
+  }
+  return newObj;
+}
+function fillTemplates({
+  obj,
+  templates,
+  additionalFields,
+  allowUnresolved = false
+}) {
+  let newObj = recursivelyFillTemplates({ obj, templates });
+  const templatesRemainingRegex = /"template":/g;
+  let templatesRemaining = JSON.stringify(newObj).match(
+    templatesRemainingRegex
+  );
+  while (templatesRemaining) {
+    newObj = recursivelyFillTemplates({ obj: newObj, templates });
+    templatesRemaining = JSON.stringify(newObj).match(templatesRemainingRegex);
+  }
+  if (additionalFields && Object.keys(additionalFields).length > 0) {
+    newObj = substituteFields({
+      templateContent: newObj,
+      fields: additionalFields
+    });
+  }
+  const matches = JSON.stringify(newObj).matchAll(
+    new RegExp(FIELD_PLACEHOLDER_REGEX.source, "g")
+  );
+  const unresolvedSet = /* @__PURE__ */ new Set();
+  for (const match of matches) {
+    unresolvedSet.add(match[1]);
+  }
+  const unresolvedFields = [...unresolvedSet];
+  if (!allowUnresolved && unresolvedFields.length > 0) {
+    throw new Error(
+      `Missing fields: ${unresolvedFields.map((f) => `\${${f}}`).join(", ")}`
+    );
+  }
+  return { result: newObj, unresolvedFields };
+}
+function getUnresolvedFields({
+  obj,
+  templates
+}) {
+  const { unresolvedFields } = fillTemplates({
+    obj,
+    templates,
+    allowUnresolved: true
+  });
+  return unresolvedFields;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.baseTreatmentSchema = baseTreatmentSchema; exports.compare = _chunkI2WMGA4Qcjs.compare; exports.computeWatchedRanges = _chunkI2WMGA4Qcjs.computeWatchedRanges; exports.conditionSchema = conditionSchema; exports.conditionsSchema = conditionsSchema; exports.descriptionSchema = descriptionSchema; exports.discussionSchema = discussionSchema; exports.displayRegionSchema = displayRegionSchema; exports.displayTimeSchema = displayTimeSchema; exports.durationSchema = durationSchema; exports.elementSchema = elementSchema; exports.elementsSchema = elementsSchema; exports.evaluateCondition = _chunkI2WMGA4Qcjs.evaluateCondition; exports.evaluateConditions = _chunkI2WMGA4Qcjs.evaluateConditions; exports.exitStepsSchema = exitStepsSchema; exports.expandTemplate = expandTemplate; exports.fileSchema = fileSchema; exports.fillTemplates = fillTemplates; exports.getNestedValueByPath = getNestedValueByPath; exports.getReferenceKeyAndPath = getReferenceKeyAndPath; exports.getUnresolvedFields = getUnresolvedFields; exports.hideFromPositionsSchema = hideFromPositionsSchema; exports.hideTimeSchema = hideTimeSchema; exports.introExitStepSchema = introExitStepSchema; exports.introExitStepsBaseSchema = introExitStepsBaseSchema; exports.introExitStepsSchema = introExitStepsSchema; exports.introSequenceSchema = introSequenceSchema; exports.introSequencesSchema = introSequencesSchema; exports.introStepsSchema = introStepsSchema; exports.matchContentType = matchContentType; exports.metadataLogicalSchema = _chunkI2WMGA4Qcjs.metadataLogicalSchema; exports.metadataRefineSchema = _chunkI2WMGA4Qcjs.metadataRefineSchema; exports.metadataTypeSchema = _chunkI2WMGA4Qcjs.metadataTypeSchema; exports.nameSchema = nameSchema; exports.playerSchema = playerSchema; exports.positionSchema = positionSchema; exports.positionSelectorSchema = positionSelectorSchema; exports.promptFileSchema = _chunkI2WMGA4Qcjs.promptFileSchema; exports.promptSchema = promptSchema; exports.recursivelyFillTemplates = recursivelyFillTemplates; exports.referenceSchema = referenceSchema; exports.resolvedConditionSchema = resolvedConditionSchema; exports.resolvedConditionsSchema = resolvedConditionsSchema; exports.resolvedElementSchema = resolvedElementSchema; exports.resolvedIntroExitStepSchema = resolvedIntroExitStepSchema; exports.resolvedStageSchema = resolvedStageSchema; exports.resolvedTreatmentSchema = resolvedTreatmentSchema; exports.showToPositionsSchema = showToPositionsSchema; exports.stageSchema = stageSchema; exports.substituteFields = substituteFields; exports.templateContentSchema = templateContentSchema; exports.templateContextSchema = templateContextSchema; exports.templateSchema = templateSchema; exports.timelineSchema = timelineSchema; exports.treatmentFileSchema = treatmentFileSchema; exports.treatmentSchema = treatmentSchema; exports.treatmentsSchema = treatmentsSchema; exports.urlSchema = urlSchema; exports.validateSliderLabels = _chunkI2WMGA4Qcjs.validateSliderLabels;
+//# sourceMappingURL=index.cjs.map