event-contract-builder 0.1.0

package/dist/src/index.js

@@ -0,0 +1,221 @@
+// src/cnl.ts
+var COMPARATOR_PHRASES = {
+  "greater-than": "is greater than",
+  "greater-than-or-equal": "is greater than or equal to",
+  "less-than": "is less than",
+  "less-than-or-equal": "is less than or equal to",
+  "equal-to": "is exactly equal to",
+  "between-inclusive": "is greater than or equal to the lower bound and less than or equal to the upper bound of",
+  occurs: "occurs",
+  "does-not-occur": "does not occur"
+};
+var TEMPLATES = {
+  binaryThreshold: "This contract resolves YES if {METRIC}, as published by {PUBLISHER} ({SOURCE}), measured over {WINDOW}, {COMPARATOR_PHRASE} {THRESHOLD} {UNIT}, applying the {REVISION_POLICY} as of the resolution deadline; otherwise it resolves NO.",
+  binaryOccurrence: "This contract resolves YES if the following event {COMPARATOR_PHRASE} within {WINDOW}: {EVENT_CLAUSE} Otherwise it resolves NO.",
+  bucketMembership: "This contract resolves to the single bucket outcome listed in section payout whose range contains the value of {METRIC}, as published by {PUBLISHER} ({SOURCE}), measured over {WINDOW}, applying the {REVISION_POLICY}; bucket lower bounds are inclusive and upper bounds are exclusive."
+};
+var UNMET_DISPOSITION_PHRASES = {
+  "void-and-refund": "is voided and all positions are refunded at acquisition price",
+  "resolve-no": "resolves NO",
+  "resolve-to-floor": "settles at the floor value stated in section payout",
+  "exchange-determination-per-rulebook": "is resolved by exchange determination under the rulebook"
+};
+var REVISION_POLICY_PHRASES = {
+  "first-published-value": "first published value",
+  "value-as-of-observation-time": "value displayed at the stated observation time",
+  "final-revised-value": "final revised value"
+};
+function phraseFor(phrases, key, label) {
+  const phrase = phrases[key];
+  if (phrase === undefined) {
+    throw new Error(`Unsupported ${label}: ${key}`);
+  }
+  return phrase;
+}
+function windowPhrase(spec) {
+  const w = spec.resolution.observationWindow;
+  return `the period from ${w.start} to ${w.end} (${w.timezone})`;
+}
+function renderCanonicalStatement(spec) {
+  const c = spec.resolution.criterion;
+  const primary = spec.resolution.sources.find((s) => s.id === spec.resolution.primarySourceId);
+  const W = windowPhrase(spec);
+  switch (c.kind) {
+    case "threshold": {
+      const threshold = c.comparator === "between-inclusive" ? `the range [${c.threshold}, ${c.thresholdUpper}]` : String(c.threshold);
+      return TEMPLATES.binaryThreshold.replace("{METRIC}", c.metric.name).replace("{PUBLISHER}", primary.publisher).replace("{SOURCE}", primary.name).replace("{WINDOW}", W).replace("{COMPARATOR_PHRASE}", phraseFor(COMPARATOR_PHRASES, c.comparator, "comparator")).replace("{THRESHOLD}", threshold).replace("{UNIT}", c.metric.unit).replace("{REVISION_POLICY}", phraseFor(REVISION_POLICY_PHRASES, c.metric.revisionPolicy, "revision policy"));
+    }
+    case "occurrence":
+      return TEMPLATES.binaryOccurrence.replace("{COMPARATOR_PHRASE}", phraseFor(COMPARATOR_PHRASES, c.comparator, "comparator")).replace("{WINDOW}", W).replace("{EVENT_CLAUSE}", c.eventClause);
+    case "bucket-membership":
+      return TEMPLATES.bucketMembership.replace("{METRIC}", c.metric.name).replace("{PUBLISHER}", primary.publisher).replace("{SOURCE}", primary.name).replace("{WINDOW}", W).replace("{REVISION_POLICY}", phraseFor(REVISION_POLICY_PHRASES, c.metric.revisionPolicy, "revision policy"));
+  }
+}
+
+// src/schema/event-contract.ts
+import { z as z2 } from "zod";
+
+// src/schema/resolution.ts
+import { z } from "zod";
+var IsoDateTime = z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:\d{2})$/, "Must be ISO 8601 date-time with explicit offset (e.g. 2026-07-15T16:00:00-04:00)").describe("ISO 8601 date-time with mandatory UTC offset");
+var IanaTimezone = z.string().regex(/^[A-Za-z]+\/[A-Za-z_+\-]+(\/[A-Za-z_+\-]+)?$|^UTC$/, "Must be an IANA timezone or UTC").describe("IANA timezone identifier (e.g. America/New_York) or UTC");
+var Slug = z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "Must be lowercase kebab-case").describe("Stable lowercase kebab-case identifier");
+var CnlSentence = z.string().min(20).max(600).regex(/^[A-Z].*\.$/s, "Must be a complete sentence (capitalized, ending in a period)").refine((s) => !/\b(approximately|roughly|about|around|reasonable|significant|materially|generally|etc\.?)\b/i.test(s), "CNL sentences must not contain hedging/vague terms (approximately, roughly, significant, etc.)").describe("A single precise sentence in the controlled vocabulary; vague terms are rejected");
+var Metric = z.object({
+  name: z.string().min(3).describe("Exact name of the data point as the source publishes it"),
+  unit: z.string().min(1),
+  extraction: CnlSentence.describe("Exactly which table/field/series ID the value is read from"),
+  revisionPolicy: z.enum([
+    "first-published-value",
+    "value-as-of-observation-time",
+    "final-revised-value"
+  ])
+});
+var ThresholdCriterion = z.object({
+  kind: z.literal("threshold"),
+  metric: Metric,
+  comparator: z.enum([
+    "greater-than",
+    "greater-than-or-equal",
+    "less-than",
+    "less-than-or-equal",
+    "equal-to",
+    "between-inclusive"
+  ]),
+  threshold: z.number(),
+  thresholdUpper: z.number().optional()
+});
+var OccurrenceCriterion = z.object({
+  kind: z.literal("occurrence"),
+  comparator: z.enum(["occurs", "does-not-occur"]),
+  eventClause: CnlSentence,
+  evidenceStandard: CnlSentence
+});
+var BucketMembershipCriterion = z.object({
+  kind: z.literal("bucket-membership"),
+  metric: Metric
+});
+var Criterion = z.discriminatedUnion("kind", [
+  ThresholdCriterion,
+  OccurrenceCriterion,
+  BucketMembershipCriterion
+]).describe("Structured resolution criterion; canonicalStatement is rendered from this");
+var DataSource = z.object({
+  id: Slug,
+  name: z.string().min(3),
+  publisher: z.string().min(2).describe("Organization that produces the data"),
+  url: z.url(),
+  datasetId: z.string().optional(),
+  publicationSchedule: z.string().min(10).describe("When and how often the value is published"),
+  publiclyAccessible: z.boolean(),
+  independenceNote: z.string().min(30).describe("Publisher's independence from market participants")
+});
+var Fallback = z.object({
+  trigger: z.enum([
+    "primary-not-published-by-deadline",
+    "primary-discontinued",
+    "primary-methodology-materially-changed",
+    "primary-retracted-or-corrected"
+  ]),
+  sourceId: Slug.describe("id of a source in resolution.sources"),
+  procedure: CnlSentence
+});
+var TerminalAmbiguityPolicy = z.enum([
+  "resolve-no",
+  "resolve-to-floor",
+  "void-and-refund",
+  "exchange-determination-per-rulebook"
+]).describe("Pre-committed disposition when no source/criterion can determine the outcome");
+var Resolution = z.object({
+  criterion: Criterion,
+  canonicalStatement: CnlSentence,
+  observationWindow: z.object({
+    start: IsoDateTime,
+    end: IsoDateTime,
+    timezone: IanaTimezone.describe("Governing timezone for any date words in CNL sentences")
+  }),
+  sources: z.array(DataSource).min(1).describe("All sources; first usable one per fallback order governs"),
+  primarySourceId: Slug,
+  fallbacks: z.array(Fallback).max(5).default([]),
+  resolutionDeadline: IsoDateTime,
+  earlyResolution: z.discriminatedUnion("allowed", [
+    z.object({ allowed: z.literal(false) }),
+    z.object({
+      allowed: z.literal(true),
+      condition: CnlSentence.describe("CNL condition under which the outcome is irreversibly determined early")
+    })
+  ]),
+  terminalAmbiguityPolicy: TerminalAmbiguityPolicy,
+  edgeCases: z.array(z.object({
+    scenario: CnlSentence,
+    disposition: CnlSentence
+  })).min(3).max(40).describe("At least 3 pre-decided edge cases (revisions, ties, postponements, source outages...)"),
+  disputeWindowHours: z.number().int().min(0).max(168)
+}).describe("Complete resolution mechanics: criterion, sources, fallbacks, deadline, edge cases").superRefine((r, ctx) => {
+  const ids = new Set(r.sources.map((s) => s.id));
+  if (!ids.has(r.primarySourceId)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["primarySourceId"],
+      message: "primarySourceId must match a source id"
+    });
+  }
+  for (const [i, f] of r.fallbacks.entries()) {
+    if (!ids.has(f.sourceId)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["fallbacks", i, "sourceId"],
+        message: "fallback sourceId must match a source id"
+      });
+    }
+  }
+  if (r.criterion.kind === "threshold") {
+    const hasUpper = r.criterion.thresholdUpper !== undefined;
+    const needsUpper = r.criterion.comparator === "between-inclusive";
+    if (needsUpper !== hasUpper) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["criterion", "thresholdUpper"],
+        message: "thresholdUpper is required iff comparator is between-inclusive"
+      });
+    }
+  }
+  const phrase = "comparator" in r.criterion ? COMPARATOR_PHRASES[r.criterion.comparator] : undefined;
+  if (phrase && !r.canonicalStatement.includes(phrase)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["canonicalStatement"],
+      message: `canonicalStatement must contain the fixed CNL phrase "${phrase}"`
+    });
+  }
+});
+
+// src/schema/event-contract.ts
+var EventContractSpec = z2.object({
+  dsl: z2.literal("event-contract-cnl/0.1"),
+  resolution: Resolution
+}).describe("Draft event-contract specification (CNL DSL v0.1) for pre-DCM review");
+// src/schema/outcome.ts
+import { z as z3 } from "zod";
+var OutcomeSchema = z3.object({
+  type: z3.literal("binary").describe("Outcome type discriminator."),
+  values: z3.tuple([z3.literal("Yes"), z3.literal("No")]).describe("Binary outcome values.")
+});
+export {
+  renderCanonicalStatement,
+  UNMET_DISPOSITION_PHRASES,
+  TerminalAmbiguityPolicy,
+  TEMPLATES,
+  Slug,
+  Resolution,
+  OutcomeSchema,
+  Metric,
+  IsoDateTime,
+  IanaTimezone,
+  Fallback,
+  EventContractSpec,
+  DataSource,
+  Criterion,
+  CnlSentence,
+  COMPARATOR_PHRASES
+};

package/dist/src/schema/event-contract.d.ts

@@ -0,0 +1,99 @@
+import { z } from "zod";
+/**
+ * Root schema for one event-contract specification document (one YAML file).
+ */
+export declare const EventContractSpec: z.ZodObject<{
+    dsl: z.ZodLiteral<"event-contract-cnl/0.1">;
+    resolution: z.ZodObject<{
+        criterion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"threshold">;
+            metric: z.ZodObject<{
+                name: z.ZodString;
+                unit: z.ZodString;
+                extraction: z.ZodString;
+                revisionPolicy: z.ZodEnum<{
+                    "first-published-value": "first-published-value";
+                    "value-as-of-observation-time": "value-as-of-observation-time";
+                    "final-revised-value": "final-revised-value";
+                }>;
+            }, z.core.$strip>;
+            comparator: z.ZodEnum<{
+                "greater-than": "greater-than";
+                "greater-than-or-equal": "greater-than-or-equal";
+                "less-than": "less-than";
+                "less-than-or-equal": "less-than-or-equal";
+                "equal-to": "equal-to";
+                "between-inclusive": "between-inclusive";
+            }>;
+            threshold: z.ZodNumber;
+            thresholdUpper: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"occurrence">;
+            comparator: z.ZodEnum<{
+                occurs: "occurs";
+                "does-not-occur": "does-not-occur";
+            }>;
+            eventClause: z.ZodString;
+            evidenceStandard: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"bucket-membership">;
+            metric: z.ZodObject<{
+                name: z.ZodString;
+                unit: z.ZodString;
+                extraction: z.ZodString;
+                revisionPolicy: z.ZodEnum<{
+                    "first-published-value": "first-published-value";
+                    "value-as-of-observation-time": "value-as-of-observation-time";
+                    "final-revised-value": "final-revised-value";
+                }>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "kind">;
+        canonicalStatement: z.ZodString;
+        observationWindow: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+            timezone: z.ZodString;
+        }, z.core.$strip>;
+        sources: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            publisher: z.ZodString;
+            url: z.ZodURL;
+            datasetId: z.ZodOptional<z.ZodString>;
+            publicationSchedule: z.ZodString;
+            publiclyAccessible: z.ZodBoolean;
+            independenceNote: z.ZodString;
+        }, z.core.$strip>>;
+        primarySourceId: z.ZodString;
+        fallbacks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            trigger: z.ZodEnum<{
+                "primary-not-published-by-deadline": "primary-not-published-by-deadline";
+                "primary-discontinued": "primary-discontinued";
+                "primary-methodology-materially-changed": "primary-methodology-materially-changed";
+                "primary-retracted-or-corrected": "primary-retracted-or-corrected";
+            }>;
+            sourceId: z.ZodString;
+            procedure: z.ZodString;
+        }, z.core.$strip>>>;
+        resolutionDeadline: z.ZodString;
+        earlyResolution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            allowed: z.ZodLiteral<false>;
+        }, z.core.$strip>, z.ZodObject<{
+            allowed: z.ZodLiteral<true>;
+            condition: z.ZodString;
+        }, z.core.$strip>], "allowed">;
+        terminalAmbiguityPolicy: z.ZodEnum<{
+            "resolve-no": "resolve-no";
+            "resolve-to-floor": "resolve-to-floor";
+            "void-and-refund": "void-and-refund";
+            "exchange-determination-per-rulebook": "exchange-determination-per-rulebook";
+        }>;
+        edgeCases: z.ZodArray<z.ZodObject<{
+            scenario: z.ZodString;
+            disposition: z.ZodString;
+        }, z.core.$strip>>;
+        disputeWindowHours: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type EventContractSpecT = z.infer<typeof EventContractSpec>;
+//# sourceMappingURL=event-contract.d.ts.map

package/dist/src/schema/event-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-contract.d.ts","sourceRoot":"","sources":["../../../src/schema/event-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQ3B,CAAC;AAEJ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/src/schema/event-contract.js

@@ -0,0 +1,200 @@
+// src/cnl.ts
+var COMPARATOR_PHRASES = {
+  "greater-than": "is greater than",
+  "greater-than-or-equal": "is greater than or equal to",
+  "less-than": "is less than",
+  "less-than-or-equal": "is less than or equal to",
+  "equal-to": "is exactly equal to",
+  "between-inclusive": "is greater than or equal to the lower bound and less than or equal to the upper bound of",
+  occurs: "occurs",
+  "does-not-occur": "does not occur"
+};
+var TEMPLATES = {
+  binaryThreshold: "This contract resolves YES if {METRIC}, as published by {PUBLISHER} ({SOURCE}), measured over {WINDOW}, {COMPARATOR_PHRASE} {THRESHOLD} {UNIT}, applying the {REVISION_POLICY} as of the resolution deadline; otherwise it resolves NO.",
+  binaryOccurrence: "This contract resolves YES if the following event {COMPARATOR_PHRASE} within {WINDOW}: {EVENT_CLAUSE} Otherwise it resolves NO.",
+  bucketMembership: "This contract resolves to the single bucket outcome listed in section payout whose range contains the value of {METRIC}, as published by {PUBLISHER} ({SOURCE}), measured over {WINDOW}, applying the {REVISION_POLICY}; bucket lower bounds are inclusive and upper bounds are exclusive."
+};
+var UNMET_DISPOSITION_PHRASES = {
+  "void-and-refund": "is voided and all positions are refunded at acquisition price",
+  "resolve-no": "resolves NO",
+  "resolve-to-floor": "settles at the floor value stated in section payout",
+  "exchange-determination-per-rulebook": "is resolved by exchange determination under the rulebook"
+};
+var REVISION_POLICY_PHRASES = {
+  "first-published-value": "first published value",
+  "value-as-of-observation-time": "value displayed at the stated observation time",
+  "final-revised-value": "final revised value"
+};
+function phraseFor(phrases, key, label) {
+  const phrase = phrases[key];
+  if (phrase === undefined) {
+    throw new Error(`Unsupported ${label}: ${key}`);
+  }
+  return phrase;
+}
+function windowPhrase(spec) {
+  const w = spec.resolution.observationWindow;
+  return `the period from ${w.start} to ${w.end} (${w.timezone})`;
+}
+function renderCanonicalStatement(spec) {
+  const c = spec.resolution.criterion;
+  const primary = spec.resolution.sources.find((s) => s.id === spec.resolution.primarySourceId);
+  const W = windowPhrase(spec);
+  switch (c.kind) {
+    case "threshold": {
+      const threshold = c.comparator === "between-inclusive" ? `the range [${c.threshold}, ${c.thresholdUpper}]` : String(c.threshold);
+      return TEMPLATES.binaryThreshold.replace("{METRIC}", c.metric.name).replace("{PUBLISHER}", primary.publisher).replace("{SOURCE}", primary.name).replace("{WINDOW}", W).replace("{COMPARATOR_PHRASE}", phraseFor(COMPARATOR_PHRASES, c.comparator, "comparator")).replace("{THRESHOLD}", threshold).replace("{UNIT}", c.metric.unit).replace("{REVISION_POLICY}", phraseFor(REVISION_POLICY_PHRASES, c.metric.revisionPolicy, "revision policy"));
+    }
+    case "occurrence":
+      return TEMPLATES.binaryOccurrence.replace("{COMPARATOR_PHRASE}", phraseFor(COMPARATOR_PHRASES, c.comparator, "comparator")).replace("{WINDOW}", W).replace("{EVENT_CLAUSE}", c.eventClause);
+    case "bucket-membership":
+      return TEMPLATES.bucketMembership.replace("{METRIC}", c.metric.name).replace("{PUBLISHER}", primary.publisher).replace("{SOURCE}", primary.name).replace("{WINDOW}", W).replace("{REVISION_POLICY}", phraseFor(REVISION_POLICY_PHRASES, c.metric.revisionPolicy, "revision policy"));
+  }
+}
+
+// src/schema/event-contract.ts
+import { z as z2 } from "zod";
+
+// src/schema/resolution.ts
+import { z } from "zod";
+var IsoDateTime = z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:\d{2})$/, "Must be ISO 8601 date-time with explicit offset (e.g. 2026-07-15T16:00:00-04:00)").describe("ISO 8601 date-time with mandatory UTC offset");
+var IanaTimezone = z.string().regex(/^[A-Za-z]+\/[A-Za-z_+\-]+(\/[A-Za-z_+\-]+)?$|^UTC$/, "Must be an IANA timezone or UTC").describe("IANA timezone identifier (e.g. America/New_York) or UTC");
+var Slug = z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "Must be lowercase kebab-case").describe("Stable lowercase kebab-case identifier");
+var CnlSentence = z.string().min(20).max(600).regex(/^[A-Z].*\.$/s, "Must be a complete sentence (capitalized, ending in a period)").refine((s) => !/\b(approximately|roughly|about|around|reasonable|significant|materially|generally|etc\.?)\b/i.test(s), "CNL sentences must not contain hedging/vague terms (approximately, roughly, significant, etc.)").describe("A single precise sentence in the controlled vocabulary; vague terms are rejected");
+var Metric = z.object({
+  name: z.string().min(3).describe("Exact name of the data point as the source publishes it"),
+  unit: z.string().min(1),
+  extraction: CnlSentence.describe("Exactly which table/field/series ID the value is read from"),
+  revisionPolicy: z.enum([
+    "first-published-value",
+    "value-as-of-observation-time",
+    "final-revised-value"
+  ])
+});
+var ThresholdCriterion = z.object({
+  kind: z.literal("threshold"),
+  metric: Metric,
+  comparator: z.enum([
+    "greater-than",
+    "greater-than-or-equal",
+    "less-than",
+    "less-than-or-equal",
+    "equal-to",
+    "between-inclusive"
+  ]),
+  threshold: z.number(),
+  thresholdUpper: z.number().optional()
+});
+var OccurrenceCriterion = z.object({
+  kind: z.literal("occurrence"),
+  comparator: z.enum(["occurs", "does-not-occur"]),
+  eventClause: CnlSentence,
+  evidenceStandard: CnlSentence
+});
+var BucketMembershipCriterion = z.object({
+  kind: z.literal("bucket-membership"),
+  metric: Metric
+});
+var Criterion = z.discriminatedUnion("kind", [
+  ThresholdCriterion,
+  OccurrenceCriterion,
+  BucketMembershipCriterion
+]).describe("Structured resolution criterion; canonicalStatement is rendered from this");
+var DataSource = z.object({
+  id: Slug,
+  name: z.string().min(3),
+  publisher: z.string().min(2).describe("Organization that produces the data"),
+  url: z.url(),
+  datasetId: z.string().optional(),
+  publicationSchedule: z.string().min(10).describe("When and how often the value is published"),
+  publiclyAccessible: z.boolean(),
+  independenceNote: z.string().min(30).describe("Publisher's independence from market participants")
+});
+var Fallback = z.object({
+  trigger: z.enum([
+    "primary-not-published-by-deadline",
+    "primary-discontinued",
+    "primary-methodology-materially-changed",
+    "primary-retracted-or-corrected"
+  ]),
+  sourceId: Slug.describe("id of a source in resolution.sources"),
+  procedure: CnlSentence
+});
+var TerminalAmbiguityPolicy = z.enum([
+  "resolve-no",
+  "resolve-to-floor",
+  "void-and-refund",
+  "exchange-determination-per-rulebook"
+]).describe("Pre-committed disposition when no source/criterion can determine the outcome");
+var Resolution = z.object({
+  criterion: Criterion,
+  canonicalStatement: CnlSentence,
+  observationWindow: z.object({
+    start: IsoDateTime,
+    end: IsoDateTime,
+    timezone: IanaTimezone.describe("Governing timezone for any date words in CNL sentences")
+  }),
+  sources: z.array(DataSource).min(1).describe("All sources; first usable one per fallback order governs"),
+  primarySourceId: Slug,
+  fallbacks: z.array(Fallback).max(5).default([]),
+  resolutionDeadline: IsoDateTime,
+  earlyResolution: z.discriminatedUnion("allowed", [
+    z.object({ allowed: z.literal(false) }),
+    z.object({
+      allowed: z.literal(true),
+      condition: CnlSentence.describe("CNL condition under which the outcome is irreversibly determined early")
+    })
+  ]),
+  terminalAmbiguityPolicy: TerminalAmbiguityPolicy,
+  edgeCases: z.array(z.object({
+    scenario: CnlSentence,
+    disposition: CnlSentence
+  })).min(3).max(40).describe("At least 3 pre-decided edge cases (revisions, ties, postponements, source outages...)"),
+  disputeWindowHours: z.number().int().min(0).max(168)
+}).describe("Complete resolution mechanics: criterion, sources, fallbacks, deadline, edge cases").superRefine((r, ctx) => {
+  const ids = new Set(r.sources.map((s) => s.id));
+  if (!ids.has(r.primarySourceId)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["primarySourceId"],
+      message: "primarySourceId must match a source id"
+    });
+  }
+  for (const [i, f] of r.fallbacks.entries()) {
+    if (!ids.has(f.sourceId)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["fallbacks", i, "sourceId"],
+        message: "fallback sourceId must match a source id"
+      });
+    }
+  }
+  if (r.criterion.kind === "threshold") {
+    const hasUpper = r.criterion.thresholdUpper !== undefined;
+    const needsUpper = r.criterion.comparator === "between-inclusive";
+    if (needsUpper !== hasUpper) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["criterion", "thresholdUpper"],
+        message: "thresholdUpper is required iff comparator is between-inclusive"
+      });
+    }
+  }
+  const phrase = "comparator" in r.criterion ? COMPARATOR_PHRASES[r.criterion.comparator] : undefined;
+  if (phrase && !r.canonicalStatement.includes(phrase)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["canonicalStatement"],
+      message: `canonicalStatement must contain the fixed CNL phrase "${phrase}"`
+    });
+  }
+});
+
+// src/schema/event-contract.ts
+var EventContractSpec = z2.object({
+  dsl: z2.literal("event-contract-cnl/0.1"),
+  resolution: Resolution
+}).describe("Draft event-contract specification (CNL DSL v0.1) for pre-DCM review");
+export {
+  EventContractSpec
+};

package/dist/src/schema/outcome.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+/**
+ * Phase 1 supports binary outcomes only. This will become a
+ * `z.discriminatedUnion("type", [...])` once categorical and scalar
+ * outcomes are added (see PLAN.md roadmap).
+ */
+export declare const OutcomeSchema: z.ZodObject<{
+    type: z.ZodLiteral<"binary">;
+    values: z.ZodTuple<[z.ZodLiteral<"Yes">, z.ZodLiteral<"No">], null>;
+}, z.core.$strip>;
+//# sourceMappingURL=outcome.d.ts.map

package/dist/src/schema/outcome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcome.d.ts","sourceRoot":"","sources":["../../../src/schema/outcome.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;iBAGxB,CAAC"}