@sonordev/contracts 2.18.0 → 2.20.0

package/dist/signal-experiments.d.ts

@@ -0,0 +1,219 @@
+/** Existing Signal experiment management semantics. No assignment or inference engine. */
+import { type Field, type Value } from './wire-schema';
+export declare class SignalExperimentValidationError extends Error {
+    readonly path: string;
+    constructor(path: string, reason: string);
+}
+declare const variant: Field<{
+    key: string;
+    name: string;
+    weight: number;
+} & {
+    description?: string | undefined;
+}>;
+declare const targeting: Field<{} & {
+    pages?: string[] | undefined;
+    segments?: string[] | undefined;
+    devices?: ("desktop" | "mobile" | "tablet")[] | undefined;
+    geo?: string[] | undefined;
+}>;
+declare const create: Field<{
+    name: string;
+    variants: ({
+        key: string;
+        name: string;
+        weight: number;
+    } & {
+        description?: string | undefined;
+    })[];
+} & {
+    description?: string | undefined;
+    traffic_allocation?: number | undefined;
+    targeting_rules?: ({} & {
+        pages?: string[] | undefined;
+        segments?: string[] | undefined;
+        devices?: ("desktop" | "mobile" | "tablet")[] | undefined;
+        geo?: string[] | undefined;
+    }) | undefined;
+}>;
+declare const update: Field<{} & {
+    name?: string | undefined;
+    description?: string | undefined;
+    variants?: ({
+        key: string;
+        name: string;
+        weight: number;
+    } & {
+        description?: string | undefined;
+    })[] | undefined;
+    traffic_allocation?: number | undefined;
+    targeting_rules?: ({} & {
+        pages?: string[] | undefined;
+        segments?: string[] | undefined;
+        devices?: ("desktop" | "mobile" | "tablet")[] | undefined;
+        geo?: string[] | undefined;
+    }) | undefined;
+}>;
+export type SignalExperimentVariant = Value<typeof variant>;
+export type SignalExperimentTargetingRules = Value<typeof targeting>;
+export type SignalExperimentCreate = Value<typeof create>;
+export type SignalExperimentUpdate = Value<typeof update>;
+/** Leaves defaults to the existing service; parsing never grants Full-plan access. */
+export declare const parseSignalExperimentCreate: (v: unknown) => SignalExperimentCreate;
+export declare const parseSignalExperimentUpdate: (v: unknown) => SignalExperimentUpdate;
+export declare const SIGNAL_EXPERIMENT_CREATE_JSON_SCHEMA: import("./wire-schema").JsonSchema;
+export declare const SIGNAL_EXPERIMENT_UPDATE_JSON_SCHEMA: import("./wire-schema").JsonSchema;
+declare const measurement: Field<({
+    schemaVersion: 1;
+    mode: "trusted_source";
+    state: "observed";
+    observedAt: string;
+    scope: {
+        projectId: string;
+        experimentId: string;
+        site: string;
+        experimentRevision: number;
+        goalRevision: string;
+        campaignId: string;
+        campaignVersionId: string;
+        assignedFrom: string;
+        assignedTo: string;
+    } & {};
+    countingUnit: "consent_subject";
+    coverage: "assigned_population_only";
+    semanticRole: "accepted_form_diagnostic";
+    businessMetrics: {
+        uniqueQualifiedContacts: {
+            state: "unavailable";
+            reasonCode: "original_qualified_lineage_not_bound";
+        } & {};
+        wonValue: {
+            state: "unavailable";
+            reasonCode: "original_deal_lineage_not_bound";
+        } & {};
+        paidRevenue: {
+            state: "unavailable";
+            reasonCode: "original_paid_source_lineage_not_bound";
+        } & {};
+    } & {};
+    originalGoal: {
+        sourceId: string;
+        sourceRevision: string;
+        countingUnit: "net_order" | "unique_qualified_contact" | "unique_source";
+        sourceKind: "accepted_form" | "qualified_lead";
+    } & {};
+    diagnosticType: "accepted_form";
+    diagnosticState: "available";
+    variants: ({
+        variantKey: string;
+        assignedUnits: string;
+        exposureEvents: string;
+        exposedUnits: string;
+        matureAssignedUnits: string;
+        immatureAssignedUnits: string;
+        assignmentsWithoutExposure: string;
+        acceptedFormEvents: string;
+        acceptedFormUnits: string;
+        matureAcceptedFormUnits: string;
+    } & {})[];
+} & {}) | ({
+    schemaVersion: 1;
+    mode: "trusted_source";
+    state: "observed";
+    observedAt: string;
+    scope: {
+        projectId: string;
+        experimentId: string;
+        site: string;
+        experimentRevision: number;
+        goalRevision: string;
+        campaignId: string;
+        campaignVersionId: string;
+        assignedFrom: string;
+        assignedTo: string;
+    } & {};
+    countingUnit: "consent_subject";
+    coverage: "assigned_population_only";
+    semanticRole: "accepted_form_diagnostic";
+    businessMetrics: {
+        uniqueQualifiedContacts: {
+            state: "unavailable";
+            reasonCode: "original_qualified_lineage_not_bound";
+        } & {};
+        wonValue: {
+            state: "unavailable";
+            reasonCode: "original_deal_lineage_not_bound";
+        } & {};
+        paidRevenue: {
+            state: "unavailable";
+            reasonCode: "original_paid_source_lineage_not_bound";
+        } & {};
+    } & {};
+    originalGoal: {
+        sourceId: string;
+        sourceRevision: string;
+        countingUnit: "net_order" | "unique_qualified_contact" | "unique_source";
+        sourceKind: "approved_application" | "completed_booking" | "net_paid_order";
+    } & {};
+    diagnosticType: null;
+    diagnosticState: "unsupported_original_source";
+    variants: ({
+        variantKey: string;
+        assignedUnits: string;
+        exposureEvents: string;
+        exposedUnits: string;
+        matureAssignedUnits: string;
+        immatureAssignedUnits: string;
+        assignmentsWithoutExposure: string;
+        acceptedFormEvents: null;
+        acceptedFormUnits: null;
+        matureAcceptedFormUnits: null;
+    } & {})[];
+} & {}) | ({
+    schemaVersion: 1;
+    mode: "legacy";
+    state: "unavailable";
+    reasonCode: "legacy_assignment_outcome_events_only";
+} & {}) | ({
+    schemaVersion: 1;
+    mode: "trusted_source";
+    state: "unavailable";
+    reasonCode: "measurement_scope_required";
+} & {})>;
+export type SignalExperimentMeasurement = Value<typeof measurement>;
+/** Decodes only the additive measurement block. Native scope, source facts and
+ * statement time must be authenticated by the existing results owner. Structural
+ * JSON Schema is shared; BigInt algebra and interval checks run in this parser. */
+export declare const parseSignalExperimentMeasurement: (v: unknown) => SignalExperimentMeasurement;
+export declare const SIGNAL_EXPERIMENT_MEASUREMENT_JSON_SCHEMA: import("./wire-schema").JsonSchema;
+declare const scopeOptions: Field<{
+    observedAt: string;
+    items: ({
+        campaignId: string;
+        campaignVersionId: string;
+        campaignDefinitionRevision: number;
+        acceptedAt: string;
+        site: string;
+        experimentId: string;
+        experimentRevision: number;
+        goalRevision: string;
+        goalLabel: string | null;
+        assignmentExtent: ({
+            firstAssignedAt: string;
+            lastAssignedAt: string;
+        } & {}) | null;
+        suggestedCohort: ({
+            assignedFrom: string;
+            assignedTo: string;
+        } & {}) | null;
+    } & {})[];
+    nextCursor: string | null;
+} & {}>;
+export type SignalExperimentScopeOptions = Value<typeof scopeOptions>;
+/** Structural decoding and internal time/tuple invariants only. Native scope,
+ * membership, acceptance and statement time remain the existing owner's facts.
+ * A shaped opaque cursor grants no read authority. JSON Schema documents the
+ * structural subset; cross-field ordering and tuple checks run in this parser. */
+export declare const parseSignalExperimentScopeOptions: (v: unknown) => SignalExperimentScopeOptions;
+export declare const SIGNAL_EXPERIMENT_SCOPE_OPTIONS_JSON_SCHEMA: import("./wire-schema").JsonSchema;
+export {};

package/dist/signal-experiments.js

@@ -0,0 +1,270 @@
+'use strict';
+
+// src/contracts/wire-schema.ts
+function createWireSchema(fail2, isValidationError) {
+  const own = (v, k) => Object.prototype.hasOwnProperty.call(v, k);
+  const field2 = (schema, read) => ({ schema, read });
+  const text2 = (max = 200, pattern, min = 1) => field2({ type: "string", minLength: min, maxLength: max, ...pattern ? { pattern: pattern.source } : {} }, (v, p) => typeof v === "string" && v.length >= min && v.length <= max && (!pattern || pattern.test(v)) ? v : fail2(p, "invalid string"));
+  const choice2 = (...values) => field2({ type: "string", enum: values }, (v, p) => typeof v === "string" && values.includes(v) ? v : fail2(p, "unsupported value"));
+  const literal2 = (value) => field2({ const: value }, (v, p) => v === value ? value : fail2(p, "unexpected value"));
+  const integer2 = (min = 0, max = Number.MAX_SAFE_INTEGER) => field2({ type: "integer", minimum: min, maximum: max }, (v, p) => typeof v === "number" && Number.isSafeInteger(v) && v >= min && v <= max ? v : fail2(p, "invalid integer"));
+  const bool = field2({ type: "boolean" }, (v, p) => typeof v === "boolean" ? v : fail2(p, "must be boolean"));
+  const optional2 = (f) => ({ ...f, optional: true });
+  const nullable2 = (f) => field2({ anyOf: [f.schema, { type: "null" }] }, (v, p) => v === null ? null : f.read(v, p));
+  const list2 = (f, max = 100, min = 0) => field2({ type: "array", items: f.schema, minItems: min, maxItems: max }, (v, p) => {
+    if (!Array.isArray(v) || v.length < min || v.length > max) fail2(p, "invalid array");
+    return v.map((x, i) => f.read(x, `${p}[${i}]`));
+  });
+  const object2 = (fields2) => field2({ type: "object", additionalProperties: false, properties: Object.fromEntries(Object.entries(fields2).map(([k, f]) => [k, f.schema])), required: Object.keys(fields2).filter((k) => !("optional" in fields2[k])) }, (v, p) => {
+    if (!v || typeof v !== "object" || Array.isArray(v) || ![Object.prototype, null].includes(Object.getPrototypeOf(v))) fail2(p, "must be a plain object");
+    const source = v, result = {};
+    for (const key of Reflect.ownKeys(source)) if (typeof key !== "string" || !own(fields2, key)) fail2(p, "unknown field");
+    for (const [key, f] of Object.entries(fields2)) {
+      if (!own(source, key)) {
+        if ("optional" in f) continue;
+        fail2(`${p}.${key}`, "required");
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(source, key);
+      if (!own(descriptor, "value")) fail2(`${p}.${key}`, "accessors are not wire data");
+      result[key] = f.read(descriptor.value, `${p}.${key}`);
+    }
+    return result;
+  });
+  const union2 = (...fields2) => field2({ oneOf: fields2.map((f) => f.schema) }, (v, p) => {
+    const found = [];
+    for (const f of fields2) {
+      try {
+        found.push(f.read(v, p));
+      } catch (e) {
+        if (!isValidationError(e)) throw e;
+      }
+    }
+    return found.length === 1 ? found[0] : fail2(p, "must match exactly one supported shape");
+  });
+  const refine2 = (f, check) => field2(f.schema, (v, p) => {
+    const result = f.read(v, p);
+    check(result, p);
+    return result;
+  });
+  return { field: field2, text: text2, choice: choice2, literal: literal2, integer: integer2, bool, optional: optional2, nullable: nullable2, list: list2, object: object2, union: union2, refine: refine2 };
+}
+
+// src/contracts/sites-normalize.ts
+function normalizeSiteHost(site) {
+  if (!site || typeof site !== "string") return null;
+  let s = site.trim().toLowerCase();
+  if (!s) return null;
+  s = s.replace(/^https?:\/\//, "");
+  const slash = s.indexOf("/");
+  if (slash >= 0) s = s.slice(0, slash);
+  const colon = s.indexOf(":");
+  if (colon >= 0) s = s.slice(0, colon);
+  s = s.replace(/\.+$/, "");
+  return s || null;
+}
+
+// src/contracts/sites.ts
+function isNormalizedSiteHost(value) {
+  return typeof value === "string" && value.length > 0 && normalizeSiteHost(value) === value;
+}
+
+// src/contracts/public-url-host.ts
+function isPrivateIpv4(a, b) {
+  return a === 127 || a === 10 || a === 0 || a === 192 && b === 168 || a === 172 && b >= 16 && b <= 31 || a === 169 && b === 254 || a === 100 && b >= 64 && b <= 127 || a >= 224;
+}
+function ipv6Words(host) {
+  if (!host.includes(":") || !/^[a-f\d:.]+$/.test(host)) return null;
+  let canonical;
+  try {
+    canonical = new URL(`http://[${host}]/`).hostname.slice(1, -1);
+  } catch {
+    return null;
+  }
+  const sides = canonical.split("::");
+  const left = sides[0] ? sides[0].split(":") : [];
+  const right = sides.length > 1 && sides[1] ? sides[1].split(":") : [];
+  return [...left, ...Array(sides.length > 1 ? 8 - left.length - right.length : 0).fill("0"), ...right].map((word) => parseInt(word, 16));
+}
+function isBlockedPublicUrlHost(rawHost) {
+  const host = rawHost.toLowerCase().replace(/^\[|\]$/g, "");
+  const blockedName = host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal");
+  if (host.includes(":") && host.includes("%")) return true;
+  const ipv4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  const blockedIp = !!ipv4 && isPrivateIpv4(Number(ipv4[1]), Number(ipv4[2]));
+  const words = ipv6Words(host);
+  const blockedIpv6 = !!words && // Unspecified/loopback, unique-local, link-local, deprecated site-local
+  // and multicast destinations aren't public logo/webhook endpoints.
+  (words.every((word) => word === 0) || words.slice(0, 7).every((word) => word === 0) && words[7] === 1 || (words[0] & 65024) === 64512 || (words[0] & 65472) === 65152 || (words[0] & 65472) === 65216 || (words[0] & 65280) === 65280 || // IPv4-mapped and older IPv4-compatible forms carry an IPv4 destination.
+  words.slice(0, 5).every((word) => word === 0) && [0, 65535].includes(words[5]) && isPrivateIpv4(words[6] >> 8, words[6] & 255));
+  return blockedName || blockedIp || blockedIpv6;
+}
+
+// src/contracts/signal-experiments.ts
+var SignalExperimentValidationError = class extends Error {
+  constructor(path, reason) {
+    super(`${path}: ${reason}`);
+    this.path = path;
+    this.name = "SignalExperimentValidationError";
+  }
+};
+var fail = (path, reason) => {
+  throw new SignalExperimentValidationError(path, reason);
+};
+var { field, text, choice, literal, integer, optional, nullable, list, object, union, refine } = createWireSchema(fail, (error) => error instanceof SignalExperimentValidationError);
+var percent = field({ type: "number", minimum: 0, maximum: 100 }, (v, p) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 100 ? v : fail(p, "must be a finite percentage from 0 to 100"));
+var page = refine(text(2048, /^\/(?!\/)[^?#\s\\]*$/), (v, p) => {
+  const parsed = new URL(v, "https://example.com");
+  if (parsed.pathname !== v) fail(p, "must be a canonical page path");
+});
+var variant = object({ key: text(80), name: text(160), weight: percent, description: optional(text(1e3, void 0, 0)) });
+var variants = refine(list(variant, 50, 2), (v, p) => {
+  if (new Set(v.map((x) => x.key)).size !== v.length) fail(p, "variant keys must be unique");
+  if (Math.abs(v.reduce((sum, x) => sum + x.weight, 0) - 100) > 0.01) fail(p, "variant weights must sum to 100");
+});
+var targeting = object({ pages: optional(list(page, 100)), segments: optional(list(text(160), 100)), devices: optional(list(choice("desktop", "mobile", "tablet"), 3)), geo: optional(list(text(160), 100)) });
+var fields = { name: text(160), description: text(1e4, void 0, 0), variants, traffic_allocation: percent, targeting_rules: targeting };
+var create = object({ ...fields, description: optional(fields.description), traffic_allocation: optional(fields.traffic_allocation), targeting_rules: optional(fields.targeting_rules) });
+var update = object({ name: optional(fields.name), description: optional(fields.description), variants: optional(fields.variants), traffic_allocation: optional(fields.traffic_allocation), targeting_rules: optional(fields.targeting_rules) });
+var parseSignalExperimentCreate = (v) => create.read(v, "experimentCreate");
+var parseSignalExperimentUpdate = (v) => update.read(v, "experimentUpdate");
+var SIGNAL_EXPERIMENT_CREATE_JSON_SCHEMA = create.schema;
+var SIGNAL_EXPERIMENT_UPDATE_JSON_SCHEMA = update.schema;
+var measurementUuid = text(36, /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+var measurementRevision = text(128, /^[a-zA-Z0-9._:-]+$/);
+var measurementInstant = refine(text(30, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/), (v, p) => {
+  if (!Number.isFinite(Date.parse(v)) || new Date(v).toISOString().replace(".000Z", "Z") !== v.replace(".000Z", "Z")) fail(p, "invalid UTC instant");
+});
+var measurementSite = refine(text(253), (v, p) => {
+  if (!isNormalizedSiteHost(v) || isBlockedPublicUrlHost(v)) fail(p, "must be a normalized public site host");
+});
+var measurementCount = text(30, /^(?:0|[1-9][0-9]*)$/);
+var measurementScope = object({
+  projectId: measurementUuid,
+  experimentId: measurementUuid,
+  site: measurementSite,
+  experimentRevision: integer(1),
+  goalRevision: measurementRevision,
+  campaignId: measurementUuid,
+  campaignVersionId: measurementUuid,
+  assignedFrom: measurementInstant,
+  assignedTo: measurementInstant
+});
+var assignmentCounts = {
+  variantKey: text(80),
+  assignedUnits: measurementCount,
+  exposureEvents: measurementCount,
+  exposedUnits: measurementCount,
+  matureAssignedUnits: measurementCount,
+  immatureAssignedUnits: measurementCount,
+  assignmentsWithoutExposure: measurementCount
+};
+var availableVariant = object({ ...assignmentCounts, acceptedFormEvents: measurementCount, acceptedFormUnits: measurementCount, matureAcceptedFormUnits: measurementCount });
+var unsupportedVariant = object({ ...assignmentCounts, acceptedFormEvents: literal(null), acceptedFormUnits: literal(null), matureAcceptedFormUnits: literal(null) });
+var businessMetrics = object({
+  uniqueQualifiedContacts: object({ state: literal("unavailable"), reasonCode: literal("original_qualified_lineage_not_bound") }),
+  wonValue: object({ state: literal("unavailable"), reasonCode: literal("original_deal_lineage_not_bound") }),
+  paidRevenue: object({ state: literal("unavailable"), reasonCode: literal("original_paid_source_lineage_not_bound") })
+});
+var goalCountingUnit = choice("unique_source", "unique_qualified_contact", "net_order");
+var originalGoalFields = { sourceId: measurementUuid, sourceRevision: measurementRevision, countingUnit: goalCountingUnit };
+var formSourceKind = choice("accepted_form", "qualified_lead");
+var unsupportedSourceKind = choice("completed_booking", "net_paid_order", "approved_application");
+var observedFields = {
+  schemaVersion: literal(1),
+  mode: literal("trusted_source"),
+  state: literal("observed"),
+  observedAt: measurementInstant,
+  scope: measurementScope,
+  countingUnit: literal("consent_subject"),
+  coverage: literal("assigned_population_only"),
+  semanticRole: literal("accepted_form_diagnostic"),
+  businessMetrics
+};
+var observedMeasurement = refine(union(
+  object({
+    ...observedFields,
+    originalGoal: object({ ...originalGoalFields, sourceKind: formSourceKind }),
+    diagnosticType: literal("accepted_form"),
+    diagnosticState: literal("available"),
+    variants: list(availableVariant, 50)
+  }),
+  object({
+    ...observedFields,
+    originalGoal: object({ ...originalGoalFields, sourceKind: unsupportedSourceKind }),
+    diagnosticType: literal(null),
+    diagnosticState: literal("unsupported_original_source"),
+    variants: list(unsupportedVariant, 50)
+  })
+), (value, p) => {
+  if (Date.parse(value.scope.assignedFrom) >= Date.parse(value.scope.assignedTo) || Date.parse(value.scope.assignedTo) > Date.parse(value.observedAt))
+    fail(p + ".scope", "requires an increasing assignment cohort ending by the native observation");
+  if (new Set(value.variants.map((v) => v.variantKey)).size !== value.variants.length) fail(p + ".variants", "variant keys must be unique");
+  for (const [index, v] of value.variants.entries()) {
+    const assigned = BigInt(v.assignedUnits), exposed = BigInt(v.exposedUnits), mature = BigInt(v.matureAssignedUnits);
+    const at = `${p}.variants[${index}]`;
+    if (exposed > assigned || BigInt(v.exposureEvents) < exposed || BigInt(v.assignmentsWithoutExposure) !== assigned - exposed || mature + BigInt(v.immatureAssignedUnits) !== assigned)
+      fail(at, "assignment, exposure and maturity counts are inconsistent");
+    if (v.acceptedFormUnits !== null && v.acceptedFormEvents !== null && v.matureAcceptedFormUnits !== null) {
+      const accepted = BigInt(v.acceptedFormUnits), matureAccepted = BigInt(v.matureAcceptedFormUnits);
+      if (accepted > exposed || accepted > BigInt(v.acceptedFormEvents) || matureAccepted > mature || matureAccepted > accepted)
+        fail(at, "accepted form units must remain within their exposed, event and mature cohorts");
+    }
+  }
+});
+var measurement = union(
+  object({ schemaVersion: literal(1), mode: literal("legacy"), state: literal("unavailable"), reasonCode: literal("legacy_assignment_outcome_events_only") }),
+  object({ schemaVersion: literal(1), mode: literal("trusted_source"), state: literal("unavailable"), reasonCode: literal("measurement_scope_required") }),
+  observedMeasurement
+);
+var parseSignalExperimentMeasurement = (v) => measurement.read(v, "experimentMeasurement");
+var SIGNAL_EXPERIMENT_MEASUREMENT_JSON_SCHEMA = measurement.schema;
+var scopeOption = object({
+  campaignId: measurementUuid,
+  campaignVersionId: measurementUuid,
+  campaignDefinitionRevision: integer(1),
+  acceptedAt: measurementInstant,
+  site: measurementSite,
+  experimentId: measurementUuid,
+  experimentRevision: integer(1),
+  goalRevision: measurementRevision,
+  goalLabel: nullable(text(200)),
+  assignmentExtent: nullable(object({ firstAssignedAt: measurementInstant, lastAssignedAt: measurementInstant })),
+  suggestedCohort: nullable(object({ assignedFrom: measurementInstant, assignedTo: measurementInstant }))
+});
+var scopeOptions = refine(object({ observedAt: measurementInstant, items: list(scopeOption, 100), nextCursor: nullable(text(4096)) }), (value, p) => {
+  const observed = Date.parse(value.observedAt), tuples = /* @__PURE__ */ new Set();
+  for (const [index, item] of value.items.entries()) {
+    const at = `${p}.items[${index}]`, accepted = Date.parse(item.acceptedAt);
+    const tuple = JSON.stringify([
+      item.campaignId.toLowerCase(),
+      item.campaignVersionId.toLowerCase(),
+      item.site,
+      item.experimentId.toLowerCase(),
+      item.experimentRevision,
+      item.goalRevision
+    ]);
+    if (tuples.has(tuple)) fail(at, "original scope tuples must be unique");
+    tuples.add(tuple);
+    if (accepted > observed) fail(at + ".acceptedAt", "must not follow the native observation");
+    if (item.assignmentExtent) {
+      const first = Date.parse(item.assignmentExtent.firstAssignedAt), last = Date.parse(item.assignmentExtent.lastAssignedAt);
+      if (first > last || last > observed) fail(at + ".assignmentExtent", "requires first <= last <= native observation");
+    }
+    if (item.suggestedCohort) {
+      const from = Date.parse(item.suggestedCohort.assignedFrom), to = Date.parse(item.suggestedCohort.assignedTo);
+      if (from !== accepted || from >= to || to > observed) fail(at + ".suggestedCohort", "requires original acceptance start and increasing cohort ending by native observation");
+    }
+  }
+});
+var parseSignalExperimentScopeOptions = (v) => scopeOptions.read(v, "experimentScopeOptions");
+var SIGNAL_EXPERIMENT_SCOPE_OPTIONS_JSON_SCHEMA = scopeOptions.schema;
+
+exports.SIGNAL_EXPERIMENT_CREATE_JSON_SCHEMA = SIGNAL_EXPERIMENT_CREATE_JSON_SCHEMA;
+exports.SIGNAL_EXPERIMENT_MEASUREMENT_JSON_SCHEMA = SIGNAL_EXPERIMENT_MEASUREMENT_JSON_SCHEMA;
+exports.SIGNAL_EXPERIMENT_SCOPE_OPTIONS_JSON_SCHEMA = SIGNAL_EXPERIMENT_SCOPE_OPTIONS_JSON_SCHEMA;
+exports.SIGNAL_EXPERIMENT_UPDATE_JSON_SCHEMA = SIGNAL_EXPERIMENT_UPDATE_JSON_SCHEMA;
+exports.SignalExperimentValidationError = SignalExperimentValidationError;
+exports.parseSignalExperimentCreate = parseSignalExperimentCreate;
+exports.parseSignalExperimentMeasurement = parseSignalExperimentMeasurement;
+exports.parseSignalExperimentScopeOptions = parseSignalExperimentScopeOptions;
+exports.parseSignalExperimentUpdate = parseSignalExperimentUpdate;