@oxyhq/crowdsource-contracts 0.1.0

package/dist/decisions.d.ts

@@ -0,0 +1,353 @@
+/**
+ * Decisions (§9.6, §9.9, Appendix B).
+ *
+ * "A published decision is never edited, only superseded." No parse can see a
+ * second write, so schema-level immutability would be theatre — and a shallow
+ * `Object.freeze` on the parsed result would be worse than theatre, since it
+ * would leave `findings` mutable while looking like a guarantee. Immutability
+ * is enforced where it is real: the store never updates a published revision.
+ *
+ * What the schema CAN enforce is the shape of the supersession chain, and it
+ * does: revision 1 supersedes nothing, and every later revision names what it
+ * replaced. §9.9's worked example is exactly that, and a revision 2 that
+ * supersedes nothing would be an edit wearing a new number.
+ *
+ * Decisions travel outbound, to tenants and to the reviewer app, so they are
+ * `.loose()`: §10.11 requires unknown fields not to break clients, and passing
+ * them through rather than stripping them means a client that persists a
+ * decision keeps whatever a newer CrowdSource added. This is the opposite of
+ * the inbound rule in `case-envelope.ts`, for the opposite reason.
+ */
+import { z } from 'zod';
+/** §3.2 decision states. */
+export declare const DECISION_STATUSES: readonly ["provisional", "final", "superseded", "corrected"];
+export declare const DecisionStatusSchema: z.ZodEnum<{
+    provisional: "provisional";
+    final: "final";
+    superseded: "superseded";
+    corrected: "corrected";
+}>;
+export type DecisionStatus = z.infer<typeof DecisionStatusSchema>;
+/**
+ * §9.6 outcomes.
+ *
+ * `inconclusive` is its own outcome and must never collapse into
+ * `no_violation`: a jury that reviewed the case and did not reach the threshold
+ * has said something different from a jury that agreed nothing was wrong. Both
+ * are here, distinctly, and no code in this package maps one to the other.
+ */
+export declare const DECISION_OUTCOMES: readonly ["violation", "no_violation", "insufficient_context", "inconclusive", "content_unavailable", "duplicate", "escalated"];
+export declare const DecisionOutcomeSchema: z.ZodEnum<{
+    violation: "violation";
+    no_violation: "no_violation";
+    insufficient_context: "insufficient_context";
+    content_unavailable: "content_unavailable";
+    inconclusive: "inconclusive";
+    duplicate: "duplicate";
+    escalated: "escalated";
+}>;
+export type DecisionOutcome = z.infer<typeof DecisionOutcomeSchema>;
+/**
+ * A confirmed finding (Appendix B).
+ *
+ * Carries two fields a `ReviewFinding` does not. `scope` says how far the
+ * finding reaches and is what §11.7.5 gates an Oxy Trust effect on;
+ * `attribution` names whose conduct it is. Neither belongs on an individual
+ * review: a reviewer classifies material, and it is the consensus process that
+ * decides the classification is confirmed and therefore attributable.
+ *
+ * `attribution` is optional because plenty of confirmed findings attribute
+ * nothing to anybody — material can violate a rule without any principal having
+ * behaved badly.
+ *
+ * `context` carries §6.2's exception through unchanged from the reviews that
+ * agreed on it. It is one of §9.4's six consensus dimensions, so a published
+ * finding that dropped it would be a decision nobody could reproduce from the
+ * ballots.
+ */
+export declare const DecisionFindingSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        "integrity.spam": "integrity.spam";
+        "integrity.scam": "integrity.scam";
+        "integrity.fraud": "integrity.fraud";
+        "integrity.impersonation": "integrity.impersonation";
+        "integrity.coordinated_manipulation": "integrity.coordinated_manipulation";
+        "harassment.insult": "harassment.insult";
+        "harassment.targeted_abuse": "harassment.targeted_abuse";
+        "harassment.sexual_harassment": "harassment.sexual_harassment";
+        "harassment.doxxing": "harassment.doxxing";
+        "harassment.credible_threat": "harassment.credible_threat";
+        "hate.dehumanization": "hate.dehumanization";
+        "hate.slur": "hate.slur";
+        "hate.incitement": "hate.incitement";
+        "hate.protected_targeting": "hate.protected_targeting";
+        "violence.graphic": "violence.graphic";
+        "violence.threat": "violence.threat";
+        "violence.instruction": "violence.instruction";
+        "violence.celebration": "violence.celebration";
+        "sexual_content.nudity": "sexual_content.nudity";
+        "sexual_content.explicit_activity": "sexual_content.explicit_activity";
+        "sexual_content.non_consensual": "sexual_content.non_consensual";
+        "sexual_content.exploitation": "sexual_content.exploitation";
+        "child_safety.sexualization": "child_safety.sexualization";
+        "child_safety.grooming": "child_safety.grooming";
+        "child_safety.exploitation": "child_safety.exploitation";
+        "self_harm.promotion": "self_harm.promotion";
+        "self_harm.instruction": "self_harm.instruction";
+        "self_harm.imminent_risk": "self_harm.imminent_risk";
+        "privacy.personal_information": "privacy.personal_information";
+        "privacy.intimate_media": "privacy.intimate_media";
+        "privacy.location_exposure": "privacy.location_exposure";
+        "commerce.prohibited_item": "commerce.prohibited_item";
+        "commerce.counterfeit": "commerce.counterfeit";
+        "commerce.misleading_listing": "commerce.misleading_listing";
+        "commerce.unsafe_product": "commerce.unsafe_product";
+        "platform_abuse.ban_evasion": "platform_abuse.ban_evasion";
+        "platform_abuse.report_abuse": "platform_abuse.report_abuse";
+        "platform_abuse.automation_abuse": "platform_abuse.automation_abuse";
+        "other.policy_specific": "other.policy_specific";
+        "other.unclassifiable": "other.unclassifiable";
+    }>;
+    resourceIds: z.ZodArray<z.ZodString>;
+    severity: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>;
+    context: z.ZodOptional<z.ZodEnum<{
+        artistic: "artistic";
+        educational: "educational";
+        documentary: "documentary";
+        newsworthy: "newsworthy";
+        satire: "satire";
+        counter_speech: "counter_speech";
+        medical: "medical";
+        consensual: "consensual";
+        fictional: "fictional";
+    }>>;
+    scope: z.ZodEnum<{
+        application_local: "application_local";
+        oxy_network: "oxy_network";
+        identity_integrity: "identity_integrity";
+    }>;
+    attribution: z.ZodOptional<z.ZodEnum<{
+        author: "author";
+        reporter: "reporter";
+        reviewer: "reviewer";
+    }>>;
+    policyRuleIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export type DecisionFinding = z.infer<typeof DecisionFindingSchema>;
+/**
+ * A recommended action bound to what it applies to (Appendix B).
+ *
+ * §10.7's webhook example writes recommended actions as bare strings, the way
+ * §9.3 writes them for a single review. Appendix B — the reference Decision —
+ * writes them as objects. The object form wins for decisions: a decision that
+ * recommends removal without saying what to remove is not actionable, and an
+ * application that acts on it is guessing. The string form survives where the
+ * plan uses it, on a review.
+ *
+ * `targetResourceIds` is optional because some actions have no target —
+ * `escalate`, `no_global_effect` and `no_action` are about the case, not about
+ * a resource.
+ */
+export declare const DecisionRecommendedActionSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        remove_or_restrict: "remove_or_restrict";
+        allow_with_label: "allow_with_label";
+        remove: "remove";
+        hide: "hide";
+        label: "label";
+        age_gate: "age_gate";
+        reduce_distribution: "reduce_distribution";
+        freeze_transaction: "freeze_transaction";
+        suspend_user: "suspend_user";
+        request_changes: "request_changes";
+        allow: "allow";
+        restore: "restore";
+        no_action: "no_action";
+        request_more_context: "request_more_context";
+        hold: "hold";
+        local_manual_review: "local_manual_review";
+        keep_restricted_temporarily: "keep_restricted_temporarily";
+        escalate: "escalate";
+        no_global_effect: "no_global_effect";
+        specialist_queue: "specialist_queue";
+        legal_queue: "legal_queue";
+        safety_queue: "safety_queue";
+    }>;
+    targetResourceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export type DecisionRecommendedAction = z.infer<typeof DecisionRecommendedActionSchema>;
+/**
+ * The panel that produced the decision (Appendix B).
+ *
+ * The arithmetic is checked here because it is the auditable trace of "one
+ * qualified person, one vote": `agreement` must equal
+ * `winningVotes / decisiveVotes` (§9.5), and the counts must nest. If a
+ * weighting ever crept into the engine, `agreement` would stop matching the
+ * count of people, and this is where that shows up.
+ *
+ * `size` is not restricted to {3, 5, 7}. Those are §9.4's community panel
+ * sizes, but §9.4 also routes critical categories to specialist pools that do
+ * not use the standard jury at all, and an appeal panel is only bounded below.
+ */
+export declare const DecisionJurySchema: z.ZodObject<{
+    size: z.ZodNumber;
+    decisiveVotes: z.ZodNumber;
+    winningVotes: z.ZodNumber;
+    agreement: z.ZodNumber;
+    specialistPresent: z.ZodBoolean;
+}, z.core.$loose>;
+export type DecisionJury = z.infer<typeof DecisionJurySchema>;
+/**
+ * One immutable revision of a case's outcome (Appendix B).
+ *
+ * Every field except `supersedesDecisionId` is required, following §12.8, which
+ * marks `supersedes_decision_id` as the only nullable column on the decisions
+ * table. The DTO uses that column's name; §9.9's prose sketch writes the same
+ * link as `supersedes`.
+ */
+export declare const DecisionSchema: z.ZodObject<{
+    id: z.ZodString;
+    caseId: z.ZodString;
+    revision: z.ZodNumber;
+    status: z.ZodEnum<{
+        provisional: "provisional";
+        final: "final";
+        superseded: "superseded";
+        corrected: "corrected";
+    }>;
+    outcome: z.ZodEnum<{
+        violation: "violation";
+        no_violation: "no_violation";
+        insufficient_context: "insufficient_context";
+        content_unavailable: "content_unavailable";
+        inconclusive: "inconclusive";
+        duplicate: "duplicate";
+        escalated: "escalated";
+    }>;
+    contextSufficiency: z.ZodEnum<{
+        sufficient: "sufficient";
+        insufficient: "insufficient";
+    }>;
+    confidence: z.ZodNumber;
+    findings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            "integrity.spam": "integrity.spam";
+            "integrity.scam": "integrity.scam";
+            "integrity.fraud": "integrity.fraud";
+            "integrity.impersonation": "integrity.impersonation";
+            "integrity.coordinated_manipulation": "integrity.coordinated_manipulation";
+            "harassment.insult": "harassment.insult";
+            "harassment.targeted_abuse": "harassment.targeted_abuse";
+            "harassment.sexual_harassment": "harassment.sexual_harassment";
+            "harassment.doxxing": "harassment.doxxing";
+            "harassment.credible_threat": "harassment.credible_threat";
+            "hate.dehumanization": "hate.dehumanization";
+            "hate.slur": "hate.slur";
+            "hate.incitement": "hate.incitement";
+            "hate.protected_targeting": "hate.protected_targeting";
+            "violence.graphic": "violence.graphic";
+            "violence.threat": "violence.threat";
+            "violence.instruction": "violence.instruction";
+            "violence.celebration": "violence.celebration";
+            "sexual_content.nudity": "sexual_content.nudity";
+            "sexual_content.explicit_activity": "sexual_content.explicit_activity";
+            "sexual_content.non_consensual": "sexual_content.non_consensual";
+            "sexual_content.exploitation": "sexual_content.exploitation";
+            "child_safety.sexualization": "child_safety.sexualization";
+            "child_safety.grooming": "child_safety.grooming";
+            "child_safety.exploitation": "child_safety.exploitation";
+            "self_harm.promotion": "self_harm.promotion";
+            "self_harm.instruction": "self_harm.instruction";
+            "self_harm.imminent_risk": "self_harm.imminent_risk";
+            "privacy.personal_information": "privacy.personal_information";
+            "privacy.intimate_media": "privacy.intimate_media";
+            "privacy.location_exposure": "privacy.location_exposure";
+            "commerce.prohibited_item": "commerce.prohibited_item";
+            "commerce.counterfeit": "commerce.counterfeit";
+            "commerce.misleading_listing": "commerce.misleading_listing";
+            "commerce.unsafe_product": "commerce.unsafe_product";
+            "platform_abuse.ban_evasion": "platform_abuse.ban_evasion";
+            "platform_abuse.report_abuse": "platform_abuse.report_abuse";
+            "platform_abuse.automation_abuse": "platform_abuse.automation_abuse";
+            "other.policy_specific": "other.policy_specific";
+            "other.unclassifiable": "other.unclassifiable";
+        }>;
+        resourceIds: z.ZodArray<z.ZodString>;
+        severity: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+        context: z.ZodOptional<z.ZodEnum<{
+            artistic: "artistic";
+            educational: "educational";
+            documentary: "documentary";
+            newsworthy: "newsworthy";
+            satire: "satire";
+            counter_speech: "counter_speech";
+            medical: "medical";
+            consensual: "consensual";
+            fictional: "fictional";
+        }>>;
+        scope: z.ZodEnum<{
+            application_local: "application_local";
+            oxy_network: "oxy_network";
+            identity_integrity: "identity_integrity";
+        }>;
+        attribution: z.ZodOptional<z.ZodEnum<{
+            author: "author";
+            reporter: "reporter";
+            reviewer: "reviewer";
+        }>>;
+        policyRuleIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
+    recommendedActions: z.ZodArray<z.ZodObject<{
+        action: z.ZodEnum<{
+            remove_or_restrict: "remove_or_restrict";
+            allow_with_label: "allow_with_label";
+            remove: "remove";
+            hide: "hide";
+            label: "label";
+            age_gate: "age_gate";
+            reduce_distribution: "reduce_distribution";
+            freeze_transaction: "freeze_transaction";
+            suspend_user: "suspend_user";
+            request_changes: "request_changes";
+            allow: "allow";
+            restore: "restore";
+            no_action: "no_action";
+            request_more_context: "request_more_context";
+            hold: "hold";
+            local_manual_review: "local_manual_review";
+            keep_restricted_temporarily: "keep_restricted_temporarily";
+            escalate: "escalate";
+            no_global_effect: "no_global_effect";
+            specialist_queue: "specialist_queue";
+            legal_queue: "legal_queue";
+            safety_queue: "safety_queue";
+        }>;
+        targetResourceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
+    jury: z.ZodObject<{
+        size: z.ZodNumber;
+        decisiveVotes: z.ZodNumber;
+        winningVotes: z.ZodNumber;
+        agreement: z.ZodNumber;
+        specialistPresent: z.ZodBoolean;
+    }, z.core.$loose>;
+    policyVersions: z.ZodObject<{
+        taxonomy: z.ZodString;
+        application: z.ZodString;
+        oxyConduct: z.ZodString;
+    }, z.core.$loose>;
+    supersedesDecisionId: z.ZodOptional<z.ZodString>;
+    publishedAt: z.ZodISODateTime;
+}, z.core.$loose>;
+export type Decision = z.infer<typeof DecisionSchema>;
+//# sourceMappingURL=decisions.d.ts.map

package/dist/decisions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decisions.d.ts","sourceRoot":"","sources":["../src/decisions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,4BAA4B;AAC5B,eAAO,MAAM,iBAAiB,8DAA+D,CAAC;AAC9F,eAAO,MAAM,oBAAoB;;;;;EAA4B,CAAC;AAC9D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,iIAQpB,CAAC;AACX,eAAO,MAAM,qBAAqB;;;;;;;;EAA4B,CAAC;AAC/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAKxF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB;;;;;;iBAkC3B,CAAC;AACL,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwCvB,CAAC;AACL,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/decisions.js

@@ -0,0 +1,198 @@
+"use strict";
+/**
+ * Decisions (§9.6, §9.9, Appendix B).
+ *
+ * "A published decision is never edited, only superseded." No parse can see a
+ * second write, so schema-level immutability would be theatre — and a shallow
+ * `Object.freeze` on the parsed result would be worse than theatre, since it
+ * would leave `findings` mutable while looking like a guarantee. Immutability
+ * is enforced where it is real: the store never updates a published revision.
+ *
+ * What the schema CAN enforce is the shape of the supersession chain, and it
+ * does: revision 1 supersedes nothing, and every later revision names what it
+ * replaced. §9.9's worked example is exactly that, and a revision 2 that
+ * supersedes nothing would be an edit wearing a new number.
+ *
+ * Decisions travel outbound, to tenants and to the reviewer app, so they are
+ * `.loose()`: §10.11 requires unknown fields not to break clients, and passing
+ * them through rather than stripping them means a client that persists a
+ * decision keeps whatever a newer CrowdSource added. This is the opposite of
+ * the inbound rule in `case-envelope.ts`, for the opposite reason.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecisionSchema = exports.DecisionJurySchema = exports.DecisionRecommendedActionSchema = exports.DecisionFindingSchema = exports.DecisionOutcomeSchema = exports.DECISION_OUTCOMES = exports.DecisionStatusSchema = exports.DECISION_STATUSES = void 0;
+const zod_1 = require("zod");
+const primitives_1 = require("./primitives");
+const policies_1 = require("./policies");
+const resources_1 = require("./resources");
+const reviews_1 = require("./reviews");
+const taxonomy_1 = require("./taxonomy");
+/** §3.2 decision states. */
+exports.DECISION_STATUSES = ['provisional', 'final', 'superseded', 'corrected'];
+exports.DecisionStatusSchema = zod_1.z.enum(exports.DECISION_STATUSES);
+/**
+ * §9.6 outcomes.
+ *
+ * `inconclusive` is its own outcome and must never collapse into
+ * `no_violation`: a jury that reviewed the case and did not reach the threshold
+ * has said something different from a jury that agreed nothing was wrong. Both
+ * are here, distinctly, and no code in this package maps one to the other.
+ */
+exports.DECISION_OUTCOMES = [
+    'violation',
+    'no_violation',
+    'insufficient_context',
+    'inconclusive',
+    'content_unavailable',
+    'duplicate',
+    'escalated',
+];
+exports.DecisionOutcomeSchema = zod_1.z.enum(exports.DECISION_OUTCOMES);
+/**
+ * A confirmed finding (Appendix B).
+ *
+ * Carries two fields a `ReviewFinding` does not. `scope` says how far the
+ * finding reaches and is what §11.7.5 gates an Oxy Trust effect on;
+ * `attribution` names whose conduct it is. Neither belongs on an individual
+ * review: a reviewer classifies material, and it is the consensus process that
+ * decides the classification is confirmed and therefore attributable.
+ *
+ * `attribution` is optional because plenty of confirmed findings attribute
+ * nothing to anybody — material can violate a rule without any principal having
+ * behaved badly.
+ *
+ * `context` carries §6.2's exception through unchanged from the reviews that
+ * agreed on it. It is one of §9.4's six consensus dimensions, so a published
+ * finding that dropped it would be a decision nobody could reproduce from the
+ * ballots.
+ */
+exports.DecisionFindingSchema = zod_1.z.looseObject({
+    code: taxonomy_1.TaxonomyCodeSchema,
+    resourceIds: zod_1.z.array(resources_1.ResourceIdSchema).min(1).max(primitives_1.CONTRACT_LIMITS.RESOURCE_REFS_PER_FINDING_MAX),
+    severity: taxonomy_1.SeveritySchema,
+    context: taxonomy_1.FindingContextSchema.optional(),
+    scope: taxonomy_1.FindingScopeSchema,
+    attribution: taxonomy_1.FindingAttributionSchema.optional(),
+    policyRuleIds: zod_1.z.array(policies_1.PolicyRuleIdSchema).max(primitives_1.CONTRACT_LIMITS.POLICY_RULE_IDS_MAX).optional(),
+});
+/**
+ * A recommended action bound to what it applies to (Appendix B).
+ *
+ * §10.7's webhook example writes recommended actions as bare strings, the way
+ * §9.3 writes them for a single review. Appendix B — the reference Decision —
+ * writes them as objects. The object form wins for decisions: a decision that
+ * recommends removal without saying what to remove is not actionable, and an
+ * application that acts on it is guessing. The string form survives where the
+ * plan uses it, on a review.
+ *
+ * `targetResourceIds` is optional because some actions have no target —
+ * `escalate`, `no_global_effect` and `no_action` are about the case, not about
+ * a resource.
+ */
+exports.DecisionRecommendedActionSchema = zod_1.z.looseObject({
+    action: taxonomy_1.RecommendedActionSchema,
+    targetResourceIds: zod_1.z
+        .array(resources_1.ResourceIdSchema)
+        .max(primitives_1.CONTRACT_LIMITS.RESOURCE_REFS_PER_FINDING_MAX)
+        .optional(),
+});
+/** Floating point: `winningVotes / decisiveVotes` will not be exact. */
+const AGREEMENT_TOLERANCE = 1e-6;
+/**
+ * The panel that produced the decision (Appendix B).
+ *
+ * The arithmetic is checked here because it is the auditable trace of "one
+ * qualified person, one vote": `agreement` must equal
+ * `winningVotes / decisiveVotes` (§9.5), and the counts must nest. If a
+ * weighting ever crept into the engine, `agreement` would stop matching the
+ * count of people, and this is where that shows up.
+ *
+ * `size` is not restricted to {3, 5, 7}. Those are §9.4's community panel
+ * sizes, but §9.4 also routes critical categories to specialist pools that do
+ * not use the standard jury at all, and an appeal panel is only bounded below.
+ */
+exports.DecisionJurySchema = zod_1.z
+    .looseObject({
+    size: zod_1.z.number().int().positive().max(primitives_1.CONTRACT_LIMITS.JURY_SIZE_MAX),
+    /** Reviews that expressed a decisive opinion — the denominator of §9.5. */
+    decisiveVotes: zod_1.z.number().int().positive().max(primitives_1.CONTRACT_LIMITS.JURY_SIZE_MAX),
+    winningVotes: zod_1.z.number().int().nonnegative().max(primitives_1.CONTRACT_LIMITS.JURY_SIZE_MAX),
+    agreement: primitives_1.UnitIntervalSchema,
+    specialistPresent: zod_1.z.boolean(),
+})
+    .superRefine((jury, ctx) => {
+    if (jury.decisiveVotes > jury.size) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['decisiveVotes'],
+            message: 'decisiveVotes cannot exceed the panel size',
+        });
+        return;
+    }
+    if (jury.winningVotes > jury.decisiveVotes) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['winningVotes'],
+            message: 'winningVotes cannot exceed decisiveVotes',
+        });
+        return;
+    }
+    const expected = jury.winningVotes / jury.decisiveVotes;
+    if (Math.abs(jury.agreement - expected) > AGREEMENT_TOLERANCE) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['agreement'],
+            message: `agreement must equal winningVotes / decisiveVotes (${expected})`,
+        });
+    }
+});
+/**
+ * One immutable revision of a case's outcome (Appendix B).
+ *
+ * Every field except `supersedesDecisionId` is required, following §12.8, which
+ * marks `supersedes_decision_id` as the only nullable column on the decisions
+ * table. The DTO uses that column's name; §9.9's prose sketch writes the same
+ * link as `supersedes`.
+ */
+exports.DecisionSchema = zod_1.z
+    .looseObject({
+    id: primitives_1.IdentifierSchema,
+    caseId: primitives_1.IdentifierSchema,
+    revision: zod_1.z.number().int().positive(),
+    status: exports.DecisionStatusSchema,
+    outcome: exports.DecisionOutcomeSchema,
+    contextSufficiency: reviews_1.ContextSufficiencySchema,
+    confidence: primitives_1.UnitIntervalSchema,
+    findings: zod_1.z.array(exports.DecisionFindingSchema).max(primitives_1.CONTRACT_LIMITS.FINDINGS_MAX),
+    recommendedActions: zod_1.z
+        .array(exports.DecisionRecommendedActionSchema)
+        .max(primitives_1.CONTRACT_LIMITS.RECOMMENDED_ACTIONS_MAX),
+    jury: exports.DecisionJurySchema,
+    policyVersions: policies_1.DecisionPolicyVersionsSchema,
+    supersedesDecisionId: primitives_1.IdentifierSchema.optional(),
+    publishedAt: primitives_1.TimestampSchema,
+})
+    .superRefine((decision, ctx) => {
+    if (decision.revision === 1 && decision.supersedesDecisionId !== undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['supersedesDecisionId'],
+            message: 'the first revision of a case supersedes nothing',
+        });
+    }
+    if (decision.revision > 1 && decision.supersedesDecisionId === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['supersedesDecisionId'],
+            message: 'a revision after the first must name the decision it supersedes',
+        });
+    }
+    if (decision.outcome === 'violation' && decision.findings.length === 0) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['findings'],
+            message: 'a violation outcome requires at least one finding',
+        });
+    }
+});
+//# sourceMappingURL=decisions.js.map

package/dist/decisions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decisions.js","sourceRoot":"","sources":["../src/decisions.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Public entry point for `@oxyhq/crowdsource-contracts`.
+ *
+ * The contracts every CrowdSource surface agrees on: the backend, the reviewer
+ * and console clients, the published SDKs, and third-party integrators. One
+ * entry point because the package publishes one `exports` path — this is the
+ * package boundary, not a convenience barrel over an internal tree.
+ *
+ * Two version numbers live here and mean different things. `/v1` is the route
+ * prefix and is not this package's business. `CASE_ENVELOPE_SCHEMA_VERSION`
+ * travels inside the payload and is validated separately (§10.11). Additive
+ * changes bump neither.
+ *
+ * Where strictness lands, and why, since it is the one thing a reader will want
+ * to look up:
+ *
+ *   * **Inbound from a tenant or a reviewer — strict.** The Case Envelope tree,
+ *     the review submission, the recusal, the policy set, the resource schema
+ *     registration. A dropped field here is context a jury never sees or an
+ *     input nobody reviewed, and §10.11 makes the exception explicitly for
+ *     fields "the schema forbids for safety".
+ *   * **Outbound to a tenant — loose.** Decisions, webhook envelopes and event
+ *     payloads pass unknown fields through, so a newer CrowdSource never breaks
+ *     an older client and a receiver that persists `event.data` keeps all of it.
+ *   * **Internal, to Oxy Trust — strict.** The reputation event carries no
+ *     resource ids and no free text on purpose; an unrecognised field is how
+ *     content reaches a reputation ledger. The `.v1` in the event type is what
+ *     handles evolution there.
+ *
+ * Open bags (`metadata`, custom payloads, registered JSON Schemas) are the
+ * deliberate exception in both directions: open by definition, but flat or
+ * depth-bounded, scalar-typed, key-restricted and free of prototype-bearing
+ * names.
+ */
+export * from './primitives';
+export * from './taxonomy';
+export * from './policies';
+export * from './resources';
+export * from './case-envelope';
+export * from './reviews';
+export * from './decisions';
+export * from './webhooks';
+export * from './reputation-events';
+export * from './json-schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC"}