openpond-sdk 0.12.13 → 0.12.15

package/dist/types/packages/sdk/src/dataset-training-review-preparation.d.ts

@@ -0,0 +1,541 @@
+import { type LearningTextAsset } from "@openpond/evals/learning";
+import { type RewardBinding, type RewardRelease } from "@openpond/evals/rewards";
+import { type DatasetTrainingReviewRequest } from "./dataset-training-review-contracts.js";
+import { type TasksetPackage } from "./taskset-package-contracts.js";
+export declare function datasetTrainingReviewIdentity(teamId: string, actorId: string, operationId: string): string;
+/** Pure conversion, never authorization or admission. The host authorizes the
+ * exact source, retains its immutable bytes and sharing receipt, then commits
+ * new evidence with this graph. It must not expose the retained parent package
+ * or unrelated files merely because selected examples become workspace-shared. */
+export declare function prepareDatasetTrainingReview(input: {
+    request: DatasetTrainingReviewRequest;
+    actorId: string;
+    package: TasksetPackage;
+    now: string;
+    /** For ordinary packages the host derives a stable namespace from the
+     * authorized Dataset family, shared by all its published versions. */
+    familyNamespace?: string;
+    /** A selected saved Reward graph is required for an ordinary package. */
+    graph?: {
+        binding: RewardBinding;
+        rewards: RewardRelease[];
+        assets: LearningTextAsset[];
+    };
+}): {
+    id: string;
+    request: {
+        schemaVersion: "openpond.datasetTrainingReviewRequest.v1";
+        teamId: string;
+        operationId: string;
+        dataset: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        packageHash: string;
+        taskIds: string[] | null;
+        purpose: "reward_training" | "supervised_training";
+        rewardBindingRef: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        definition: {
+            name?: string | undefined;
+            instructions?: string | undefined;
+            inputSchema?: Record<string, import("zod").JSONType> | undefined;
+            outputSchema?: Record<string, import("zod").JSONType> | undefined;
+            requiredOutputs?: {
+                path: string;
+                mediaType: string;
+                schemaRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "host_private" | "policy" | "verifier";
+                } | null;
+                submissionMode?: "structured_json" | undefined;
+                maxBytes: number | null;
+                metadata: Record<string, unknown>;
+            }[] | undefined;
+        };
+        targetSource: "approved_parent" | "expected_output" | "none";
+        shareWithWorkspace: true;
+    };
+    source: {
+        schemaVersion: "openpond.learningSource.v1";
+        id: string;
+        revision: number;
+        name: string;
+        kind: "benchmark" | "direct" | "opentelemetry" | "provider" | "work";
+        taskDefinition: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        enabled: boolean;
+        allowedSplits: ("frozen_eval" | "test" | "train" | "validation")[];
+        mapping: {
+            schemaVersion: "openpond.taskSourceMapping.v1";
+            exampleId: string;
+            attemptId: string;
+            occurredAt: string;
+            input: string;
+            observedOutput: string | null;
+            expected: string | null;
+            evaluatorContext: string | null;
+            familyKey: string;
+            split: "frozen_eval" | "test" | "train" | "validation";
+        } | null;
+        adapterVersion: string | null;
+        reviewOrigin?: {
+            modelId: string;
+            packageHash: string;
+            taskset: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            batch: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            rewardBinding: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+        } | undefined;
+        datasetOrigin?: {
+            receiptId: string;
+            packageHash: string;
+            taskset: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+        } | undefined;
+        capturedOrigin?: {
+            receiptId: string;
+            ownerUserId: string;
+            modelId: string;
+            packageHash: string;
+            taskset: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+        } | undefined;
+        contentHash: string;
+    };
+    definition: {
+        schemaVersion: "openpond.taskDefinition.v1";
+        id: string;
+        revision: number;
+        name: string;
+        description: string;
+        instructions: string;
+        category: "coding" | "custom" | "question_answering" | "structured" | "tool_workflow";
+        familyNamespace: string;
+        inputSchema: Record<string, unknown>;
+        outputSchema: Record<string, unknown>;
+        requiredOutputs?: {
+            path: string;
+            mediaType: string;
+            schemaRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            } | null;
+            submissionMode?: "structured_json" | undefined;
+            maxBytes: number | null;
+            metadata: Record<string, unknown>;
+        }[] | undefined;
+        contextRequirements?: string[] | undefined;
+        rewardBinding: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        harness: {
+            id: string;
+            contentHash: string;
+        } | null;
+        execution: {
+            policy: {
+                policyVisibleFields: string[];
+                privilegedFields: string[];
+                hiddenGraderRefs: string[];
+                connectedAppScopes: string[];
+            };
+            environment: {
+                protocolVersion: "openpond.environment.v1";
+                kind: "agent" | "custom_program" | "text" | "work";
+                entrypoint: string;
+                stateful: boolean;
+                deterministicSeeds: boolean;
+                lifecycle: ("collect" | "create" | "destroy" | "reset" | "step")[];
+                networkPolicy: "declared_read_only" | "declared_scoped" | "none";
+                defaultTimeoutMs: number;
+            };
+            environmentRelease?: {
+                id: string;
+                contentHash: string;
+            } | undefined;
+            tools: {
+                name: string;
+                description: string;
+                inputSchema: Record<string, unknown>;
+                inputSchemaHash: string;
+                sideEffect: "read" | "write";
+                timeoutMs: number;
+            }[];
+            capabilities: {
+                id: string;
+                required: boolean;
+                scopes: string[];
+                portability: "host_adapter" | "hosted_only" | "local_only" | "portable";
+            }[];
+            verifierSetRelease?: {
+                id: string;
+                contentHash: string;
+            } | undefined;
+        };
+        contentHash: string;
+    };
+    binding: {
+        schemaVersion: "openpond.rewardBinding.v1";
+        id: string;
+        revision: number;
+        name?: string | undefined;
+        description?: string | undefined;
+        recipeRef?: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | undefined;
+        sources: {
+            graderId: string;
+            taskIds?: string[] | undefined;
+            reward: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            role: "evaluation" | "training";
+            normalization: {
+                kind: "identity";
+            } | {
+                kind: "linear";
+                minimum: number;
+                maximum: number;
+                direction: "higher" | "lower";
+            };
+            weight: number;
+            required: boolean;
+            hardGate: boolean;
+            privileged: boolean;
+            fixtureRefs: {
+                id: string;
+                contentHash: string;
+            }[];
+        }[];
+        aggregation: "weighted_mean";
+        unscorable: "exclude_optional_require_all_required";
+        contentHash: string;
+    };
+    rewards: {
+        schemaVersion: "openpond.rewardRelease.v1";
+        id: string;
+        revision: number;
+        name: string;
+        description: string;
+        feedbackKey?: string | undefined;
+        implementation: {
+            kind: "artifact" | "content" | "runtime_event" | "schema" | "state";
+            config: Record<string, unknown>;
+        } | {
+            kind: "model_judge";
+            rubricRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            };
+            calibrationStatus: "failed" | "passed" | "pending";
+            model?: {
+                providerId: string;
+                modelId: string;
+                revision: string | null;
+            } | undefined;
+            temperature?: number | undefined;
+        } | {
+            kind: "custom_verifier";
+            runtime?: "isolated_javascript" | "sandbox_process" | undefined;
+            verifierRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            };
+            exportName?: string | undefined;
+            timeoutMs: number;
+            networkPolicy: "none";
+        } | {
+            kind: "human";
+            rubricRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            };
+            reviewerRole: string;
+            form?: {
+                schemaVersion: "openpond.humanForm.v1";
+                mode: "individual" | "pairwise";
+                instructions: string;
+                criteria: ({
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    kind: "score";
+                    minimum: number;
+                    maximum: number;
+                    step: number;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    kind: "category";
+                    options: string[];
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    kind: "boolean";
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    kind: "text";
+                    minimumLength?: number | undefined;
+                    maximumLength: number;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    kind: "preference";
+                    requireStrength?: boolean | undefined;
+                    allowTie: boolean;
+                })[];
+            } | undefined;
+        } | {
+            kind: "learned_model";
+            modelVersion: {
+                id: string;
+                contentHash: string;
+            };
+            inputContract: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            };
+        };
+        rawScore: {
+            minimum: number;
+            maximum: number;
+        };
+        assets: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "host_private" | "policy" | "verifier";
+        }[];
+        fixtureSetRef?: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "host_private" | "policy" | "verifier";
+        } | undefined;
+        calibrationCheckRef?: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | undefined;
+        contentHash: string;
+    }[];
+    assets: {
+        schemaVersion: "openpond.learningTextAsset.v1";
+        id: string;
+        revision: 1;
+        asset: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "host_private" | "policy" | "verifier";
+        };
+        text: string;
+        contentHash: string;
+    }[];
+    evidence: {
+        schemaVersion: "openpond.taskEvidence.v1";
+        id: string;
+        revision: number;
+        source: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        submission: {
+            schemaVersion: "openpond.taskExample.v1";
+            sourceId: string;
+            idempotencyKey: string;
+            taskDefinition: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            exampleId: string;
+            attemptId: string;
+            occurredAt: string;
+            familyKey: string | null;
+            split: "frozen_eval" | "test" | "train" | "validation";
+            input: Record<string, import("zod").JSONType>;
+            policyVisibleContext?: Record<string, import("zod").JSONType> | undefined;
+            observedOutput: Record<string, import("zod").JSONType> | null;
+            expected: Record<string, import("zod").JSONType> | null;
+            evaluatorContext: Record<string, import("zod").JSONType> | null;
+            assets: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            }[];
+            requiredOutputs?: {
+                path: string;
+                mediaType: string;
+                schemaRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "host_private" | "policy" | "verifier";
+                } | null;
+                submissionMode?: "structured_json" | undefined;
+                maxBytes: number | null;
+                metadata: Record<string, unknown>;
+            }[] | undefined;
+            provenance: {
+                sourceRecordRef: string | null;
+                mappingHash: string | null;
+            };
+        };
+        supersedes: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        correctionFeedbackId: string | null;
+        receivedAt: string;
+        contentHash: string;
+    }[];
+    proposals: {
+        schemaVersion: "openpond.taskFeedbackRecord.v1";
+        id: string;
+        submission: {
+            schemaVersion: "openpond.taskFeedback.v1";
+            sourceId: string;
+            idempotencyKey: string;
+            exampleId: string;
+            attemptId: string;
+            expectedEvidenceHash: string | null;
+            occurredAt: string;
+            kind: "family_resolution" | "ground_truth_correction" | "input_correction" | "outcome" | "target_correction";
+            value: Record<string, import("zod").JSONType>;
+            note: string;
+        };
+        status: "applied" | "pending_example" | "pending_review" | "rejected" | "superseded";
+        evidence: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        createdAt: string;
+        revision: number;
+        submittedBy: {
+            id: string;
+            role: "editor" | "reviewer" | "source";
+            sourceId: string | null;
+        } | null;
+        review: {
+            actorId: string;
+            decision: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null;
+            note: string;
+            resolvedAt: string;
+        } | null;
+    }[];
+};
+//# sourceMappingURL=dataset-training-review-preparation.d.ts.map

package/dist/types/packages/sdk/src/dataset-training-review-preparation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-training-review-preparation.d.ts","sourceRoot":"","sources":["../../../../../src/dataset-training-review-preparation.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAA4C,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE3H,OAAO,EAAsC,KAAK,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AAC/H,OAAO,EAAuF,KAAK,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAE1J,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,UAEjG;AAED;;;kFAGkF;AAClF,wBAAgB,4BAA4B,CAAC,KAAK,EAAE;IAClD,OAAO,EAAE,4BAA4B,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,cAAc,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ;0EACsE;IACtE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,KAAK,CAAC,EAAE;QAAE,OAAO,EAAE,aAAa,CAAC;QAAC,OAAO,EAAE,aAAa,EAAE,CAAC;QAAC,MAAM,EAAE,iBAAiB,EAAE,CAAA;KAAE,CAAC;CAC3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqHA"}

package/dist/types/packages/sdk/src/dataset-training-review-source.d.ts

@@ -0,0 +1,41 @@
+import { type TasksetPackage } from "./taskset-package-contracts.js";
+/** Pure inspection after the caller obtains an authorized immutable package.
+ * This is not execution admission or authorization to share it. */
+export declare function inspectDatasetTrainingReviewPackage(raw: TasksetPackage): {
+    schemaVersion: "openpond.datasetTrainingReviewSource.v1";
+    dataset: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    };
+    packageHash: string;
+    taskCount: number;
+    definition: {
+        name?: string | undefined;
+        instructions?: string | undefined;
+        inputSchema?: Record<string, import("zod").JSONType> | undefined;
+        outputSchema?: Record<string, import("zod").JSONType> | undefined;
+        requiredOutputs?: {
+            path: string;
+            mediaType: string;
+            schemaRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            } | null;
+            submissionMode?: "structured_json" | undefined;
+            maxBytes: number | null;
+            metadata: Record<string, unknown>;
+        }[] | undefined;
+    };
+    rewardBinding: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    } | null;
+    hasParentTargets: boolean;
+};
+//# sourceMappingURL=dataset-training-review-source.d.ts.map

package/dist/types/packages/sdk/src/dataset-training-review-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-training-review-source.d.ts","sourceRoot":"","sources":["../../../../../src/dataset-training-review-source.ts"],"names":[],"mappings":"AAEA,OAAO,EAA6D,KAAK,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEhI;mEACmE;AACnE,wBAAgB,mCAAmC,CAAC,GAAG,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBtE"}

package/dist/types/packages/sdk/src/dataset-training-review.d.ts

@@ -0,0 +1,79 @@
+import { type DatasetTrainingReviewRequest } from "./dataset-training-review-contracts.js";
+export * from "./dataset-training-review-contracts.js";
+export declare function parseAndVerifyDatasetTrainingReviewReceipt(raw: unknown, input: DatasetTrainingReviewRequest, actorId?: string): Promise<{
+    schemaVersion: "openpond.datasetTrainingReviewReceipt.v1";
+    id: string;
+    teamId: string;
+    actorId: string;
+    operationId: string;
+    requestHash: string;
+    dataset: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    };
+    packageHash: string;
+    purpose: "reward_training" | "supervised_training";
+    shareWithWorkspace: true;
+    source: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    };
+    definition: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    };
+    evidence: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    }[];
+    proposals: {
+        id: string;
+        revision: number;
+    }[];
+    createdAt: string;
+    contentHash: string;
+}>;
+export declare function createDatasetTrainingReviewClient(request: (path: string, init?: RequestInit) => Promise<unknown>): {
+    reviewDataset(input: DatasetTrainingReviewRequest): Promise<{
+        schemaVersion: "openpond.datasetTrainingReviewReceipt.v1";
+        id: string;
+        teamId: string;
+        actorId: string;
+        operationId: string;
+        requestHash: string;
+        dataset: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        packageHash: string;
+        purpose: "reward_training" | "supervised_training";
+        shareWithWorkspace: true;
+        source: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        definition: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        evidence: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        }[];
+        proposals: {
+            id: string;
+            revision: number;
+        }[];
+        createdAt: string;
+        contentHash: string;
+    }>;
+};
+//# sourceMappingURL=dataset-training-review.d.ts.map

package/dist/types/packages/sdk/src/dataset-training-review.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-training-review.d.ts","sourceRoot":"","sources":["../../../../../src/dataset-training-review.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AAEpF,cAAc,wCAAwC,CAAC;AAEvD,wBAAsB,0CAA0C,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,4BAA4B,EAAE,OAAO,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgBnI;AAED,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC;IAEvG,aAAa,QAAQ,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO1D"}

package/dist/types/packages/sdk/src/decision-experiment-authoring.d.ts

@@ -0,0 +1,11 @@
+import { type ExperimentStartingModel } from "./experiment-starting-model.js";
+/** Names the exact saved classifier without exposing it as a generic chat
+ * alias. Train and score are both authored through the same decision form. */
+export declare function experimentStartingModelFromDecisionVersion(raw: unknown, expected: {
+    teamId?: string;
+    ownerUserId?: string;
+    label: string;
+}): Promise<Extract<ExperimentStartingModel, {
+    source: "decision";
+}>>;
+//# sourceMappingURL=decision-experiment-authoring.d.ts.map

package/dist/types/packages/sdk/src/decision-experiment-authoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision-experiment-authoring.d.ts","sourceRoot":"","sources":["../../../../../src/decision-experiment-authoring.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiC,KAAK,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAI7G;8EAC8E;AAC9E,wBAAsB,0CAA0C,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE;IACvF,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;CACtD,GAAG,OAAO,CAAC,OAAO,CAAC,uBAAuB,EAAE;IAAE,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC,CAAC,CAUpE"}