openpond-sdk 0.12.2 → 0.12.4

package/dist/{chunk-7AZDNZP6.js → chunk-GAIDBPFY.js}

@@ -11,23 +11,161 @@ import {
   TasksetPreferenceComparisonBindingSchema,
   TasksetPurposeSchema,
   TasksetSourceRefSchema
-} from "./chunk-FHCSDXIA.js";
+} from "./chunk-MO4HAJZG.js";
+import {
+  ModelTasksetDraftPreparationSchema
+} from "./chunk-TK3DXH7A.js";
 import {
   ChatModelRefSchema
-} from "./chunk-KAE7AMYE.js";
+} from "./chunk-H3367ISL.js";
 import {
   VersionedReleaseRefSchema,
   contentHash
-} from "./chunk-COPVBJPL.js";
+} from "./chunk-H3JZ3P5T.js";
 
-// src/taskset-authored-contracts.ts
+// src/taskset-draft-document.ts
 import { z } from "zod";
 import { TasksetMetricPolicySchema } from "@openpond/evals/metrics";
 var IdSchema = z.string().trim().min(1).max(240);
 var TimestampSchema = z.string().trim().min(1);
 var HashSchema = z.string().trim().min(8).max(256);
+var CodeIdentifierSchema = z.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
 var MetadataSchema = z.record(z.string(), z.unknown()).default({});
-var NullableIdSchema = IdSchema.nullable();
+function safeRelativeFilePath(value) {
+  const normalized = value.trim().replaceAll("\\", "/");
+  if (!normalized || normalized.startsWith("/") || normalized === "." || normalized === "..") {
+    return false;
+  }
+  return !normalized.split("/").some(
+    (segment) => !segment || segment === "." || segment === ".."
+  );
+}
+var TaskDataDraftSchema = TaskDataRecordSchema.extend({
+  sourceRefs: z.array(IdSchema).max(100).default([])
+});
+var TasksetDraftStatusSchema = z.enum([
+  "draft",
+  "validating",
+  "needs_review",
+  "published"
+]);
+var TasksetDraftReviewPolicySchema = z.object({
+  enabled: z.boolean(),
+  candidateCount: z.number().int().min(2).max(4),
+  minimumSamples: z.number().int().min(1).max(1e4).default(100),
+  allowTies: z.boolean(),
+  allowRejectAll: z.boolean(),
+  rubric: z.string().trim().max(5e4),
+  criteria: z.array(z.object({
+    id: IdSchema,
+    label: z.string().trim().min(1).max(500),
+    description: z.string().trim().max(1e4),
+    weight: z.number().nonnegative().max(1e3)
+  })).max(100)
+});
+var TasksetDraftOutputContractSchema = z.object({
+  mode: z.enum(["text", "structured_json", "artifacts"]),
+  jsonSchema: z.record(z.string(), z.unknown()).nullable(),
+  renderer: z.object({
+    module: z.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Renderer modules must use a safe relative path."),
+    exportName: CodeIdentifierSchema,
+    configRef: z.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Renderer configuration must use a safe relative path.").nullable().default(null)
+  }).nullable()
+}).superRefine((output, context) => {
+  if (output.mode === "structured_json" && !output.jsonSchema) {
+    context.addIssue({
+      code: "custom",
+      message: "Structured JSON output requires a JSON Schema.",
+      path: ["jsonSchema"]
+    });
+  }
+  if (output.mode === "text" && output.renderer) {
+    context.addIssue({
+      code: "custom",
+      message: "Text output cannot configure an artifact renderer.",
+      path: ["renderer"]
+    });
+  }
+});
+var TasksetDraftSchema = z.object({
+  schemaVersion: z.literal("openpond.tasksetDraft.v1"),
+  id: IdSchema,
+  revision: z.number().int().positive(),
+  profileId: IdSchema,
+  modelScope: z.object({
+    modelId: IdSchema,
+    expectedModelRevision: z.number().int().positive(),
+    source: ModelTasksetDraftPreparationSchema.optional()
+  }).strict().nullable().default(null),
+  name: z.string().trim().max(500),
+  objective: z.string().trim().max(2e4),
+  purpose: TasksetPurposeSchema.default("general"),
+  benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),
+  preferenceComparison: TasksetPreferenceComparisonBindingSchema.nullable().default(null),
+  status: TasksetDraftStatusSchema,
+  sourceRefs: z.array(TasksetSourceRefSchema).max(1e5).default([]),
+  datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),
+  policy: TaskPolicyBoundarySchema,
+  environment: TasksetEnvironmentContractSchema,
+  output: TasksetDraftOutputContractSchema.default({
+    mode: "text",
+    jsonSchema: null,
+    renderer: null
+  }),
+  capabilities: TasksetCapabilityManifestSchema,
+  metrics: TasksetMetricPolicySchema,
+  review: TasksetDraftReviewPolicySchema,
+  tasks: z.array(TaskDataDraftSchema).max(1e6).default([]),
+  graders: z.array(GraderSpecSchema).max(1e3).default([]),
+  graderFixtures: z.array(GraderFixtureSchema).max(1e5).default([]),
+  learningSignals: LearningSignalInventorySchema,
+  publishedTasksetRef: z.object({
+    id: IdSchema,
+    revision: z.number().int().positive(),
+    contentHash: HashSchema
+  }).nullable(),
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema,
+  metadata: MetadataSchema
+}).superRefine((draft, context) => {
+  if (draft.purpose === "benchmark" && !draft.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Benchmark drafts require an immutable benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (draft.purpose !== "benchmark" && draft.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Only benchmark drafts may carry a benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (draft.datasetArtifact && draft.tasks.length > 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Artifact-backed drafts may not duplicate canonical rows inline.",
+      path: ["tasks"]
+    });
+  }
+  if (draft.status === "published" && !draft.publishedTasksetRef) {
+    context.addIssue({
+      code: "custom",
+      message: "Published drafts require an immutable Taskset reference.",
+      path: ["publishedTasksetRef"]
+    });
+  }
+});
+
+// src/taskset-authored-contracts.ts
+import { z as z2 } from "zod";
+import { TasksetMetricPolicySchema as TasksetMetricPolicySchema2 } from "@openpond/evals/metrics";
+var IdSchema2 = z2.string().trim().min(1).max(240);
+var TimestampSchema2 = z2.string().trim().min(1);
+var HashSchema2 = z2.string().trim().min(8).max(256);
+var MetadataSchema2 = z2.record(z2.string(), z2.unknown()).default({});
+var NullableIdSchema = IdSchema2.nullable();
 var TASKSET_WORK_TOOL_NAMES = [
   "work_capabilities",
   "work_environment",
@@ -42,7 +180,7 @@ var TASKSET_WORK_TOOL_NAMES = [
   "work_save_output",
   "work_stop"
 ];
-var TasksetStatusSchema = z.enum([
+var TasksetStatusSchema = z2.enum([
   "draft",
   "awaiting_disclosure_approval",
   "awaiting_materialization_approval",
@@ -55,51 +193,51 @@ var TasksetStatusSchema = z.enum([
   "failed",
   "archived"
 ]);
-var DatasetBuildIntentSchema = z.enum([
+var DatasetBuildIntentSchema = z2.enum([
   "demonstrations",
   "preferences",
   "verifiable_reward",
   "rubric",
   "discovery"
 ]);
-var DatasetEvidenceTextSchema = z.string().trim().max(1e5);
-var DatasetBuildSpecificationSchema = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("demonstrations"),
+var DatasetEvidenceTextSchema = z2.string().trim().max(1e5);
+var DatasetBuildSpecificationSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("demonstrations"),
     behavior: DatasetEvidenceTextSchema,
-    examples: z.array(z.object({
-      id: IdSchema,
+    examples: z2.array(z2.object({
+      id: IdSchema2,
       prompt: DatasetEvidenceTextSchema,
       response: DatasetEvidenceTextSchema
     })).max(1e3).default([])
   }),
-  z.object({
-    kind: z.literal("preferences"),
+  z2.object({
+    kind: z2.literal("preferences"),
     preference: DatasetEvidenceTextSchema,
-    pairs: z.array(z.object({
-      id: IdSchema,
+    pairs: z2.array(z2.object({
+      id: IdSchema2,
       prompt: DatasetEvidenceTextSchema,
       chosen: DatasetEvidenceTextSchema,
       rejected: DatasetEvidenceTextSchema,
       rationale: DatasetEvidenceTextSchema
     })).max(1e3).default([])
   }),
-  z.object({
-    kind: z.literal("verifiable_reward"),
+  z2.object({
+    kind: z2.literal("verifiable_reward"),
     task: DatasetEvidenceTextSchema,
-    rules: z.array(z.object({
-      id: IdSchema,
-      points: z.number().finite(),
+    rules: z2.array(z2.object({
+      id: IdSchema2,
+      points: z2.number().finite(),
       condition: DatasetEvidenceTextSchema
     })).max(1e3).default([]),
-    otherwisePoints: z.number().finite().default(0)
+    otherwisePoints: z2.number().finite().default(0)
   }),
-  z.object({
-    kind: z.literal("rubric"),
+  z2.object({
+    kind: z2.literal("rubric"),
     task: DatasetEvidenceTextSchema,
-    criteria: z.array(z.object({
-      id: IdSchema,
-      label: z.string().trim().max(500),
+    criteria: z2.array(z2.object({
+      id: IdSchema2,
+      label: z2.string().trim().max(500),
       description: DatasetEvidenceTextSchema
     })).max(1e3).default([]),
     positiveExample: DatasetEvidenceTextSchema,
@@ -107,21 +245,21 @@ var DatasetBuildSpecificationSchema = z.discriminatedUnion("kind", [
     boundaryExample: DatasetEvidenceTextSchema
   })
 ]);
-var GeneratedTaskFileSchema = z.object({
-  path: z.string().trim().min(1).max(1e3),
-  role: z.enum(["environment", "verifier", "fixture"]),
-  content: z.string().max(25e4)
+var GeneratedTaskFileSchema = z2.object({
+  path: z2.string().trim().min(1).max(1e3),
+  role: z2.enum(["environment", "verifier", "fixture"]),
+  content: z2.string().max(25e4)
 });
-var TrainingPathRecommendationSchema = z.object({
-  primaryMethod: z.enum(["sft", "dpo", "grpo", "ppo", "sdft", "opsd", "sdpo"]),
-  bootstrap: z.object({
-    method: z.literal("sft"),
-    purpose: z.literal("trajectory_bootstrap"),
-    demonstrationRefs: z.array(IdSchema).min(1).max(1e5),
-    limitations: z.array(z.string().trim().min(1).max(5e3)).min(1).max(100)
+var TrainingPathRecommendationSchema = z2.object({
+  primaryMethod: z2.enum(["sft", "dpo", "grpo", "ppo", "sdft", "opsd", "sdpo"]),
+  bootstrap: z2.object({
+    method: z2.literal("sft"),
+    purpose: z2.literal("trajectory_bootstrap"),
+    demonstrationRefs: z2.array(IdSchema2).min(1).max(1e5),
+    limitations: z2.array(z2.string().trim().min(1).max(5e3)).min(1).max(100)
   }).nullable()
 });
-var TrainingMethodReadinessReasonCodeSchema = z.enum([
+var TrainingMethodReadinessReasonCodeSchema = z2.enum([
   "taskset_not_ready",
   "demonstrations_missing",
   "preference_pairs_missing",
@@ -132,81 +270,81 @@ var TrainingMethodReadinessReasonCodeSchema = z.enum([
   "value_model_required",
   "frozen_eval_missing"
 ]);
-var TrainingMethodReadinessSchema = z.object({
-  method: z.enum(["sft", "dpo", "grpo", "ppo"]),
-  status: z.enum(["recommended", "compatible", "needs_dataset_work"]),
-  reasonCodes: z.array(TrainingMethodReadinessReasonCodeSchema).default([]),
-  reasons: z.array(z.string().trim().min(1).max(5e3)).default([])
+var TrainingMethodReadinessSchema = z2.object({
+  method: z2.enum(["sft", "dpo", "grpo", "ppo"]),
+  status: z2.enum(["recommended", "compatible", "needs_dataset_work"]),
+  reasonCodes: z2.array(TrainingMethodReadinessReasonCodeSchema).default([]),
+  reasons: z2.array(z2.string().trim().min(1).max(5e3)).default([])
 });
-var TasksetReadinessFindingSchema = z.object({
-  code: IdSchema,
-  message: z.string().trim().min(1).max(5e3),
-  path: z.string().trim().max(2e3).nullable()
+var TasksetReadinessFindingSchema = z2.object({
+  code: IdSchema2,
+  message: z2.string().trim().min(1).max(5e3),
+  path: z2.string().trim().max(2e3).nullable()
 });
-var TasksetReadinessReportSchema = z.object({
-  schemaVersion: z.literal("openpond.tasksetReadiness.v1"),
-  tasksetId: IdSchema,
-  tasksetHash: HashSchema,
-  ready: z.boolean(),
-  recommendedMethod: z.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"]),
+var TasksetReadinessReportSchema = z2.object({
+  schemaVersion: z2.literal("openpond.tasksetReadiness.v1"),
+  tasksetId: IdSchema2,
+  tasksetHash: HashSchema2,
+  ready: z2.boolean(),
+  recommendedMethod: z2.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"]),
   trainingPath: TrainingPathRecommendationSchema.nullable().default(null),
-  methodReadiness: z.array(TrainingMethodReadinessSchema).default([]),
-  compatibleDestinationClasses: z.array(
-    z.enum(["export", "custom", "hosted_managed"])
+  methodReadiness: z2.array(TrainingMethodReadinessSchema).default([]),
+  compatibleDestinationClasses: z2.array(
+    z2.enum(["export", "custom", "hosted_managed"])
   ),
-  blockers: z.array(TasksetReadinessFindingSchema).default([]),
-  advisories: z.array(TasksetReadinessFindingSchema).default([]),
-  warnings: z.array(z.string().trim().min(1).max(5e3)).default([]),
-  generatedAt: TimestampSchema
+  blockers: z2.array(TasksetReadinessFindingSchema).default([]),
+  advisories: z2.array(TasksetReadinessFindingSchema).default([]),
+  warnings: z2.array(z2.string().trim().min(1).max(5e3)).default([]),
+  generatedAt: TimestampSchema2
 });
-var AuthoringRepairSchema = z.object({ attempt: z.number().int().positive(), summary: z.string().trim().min(1).max(5e3), createdAt: TimestampSchema });
-var AuthoringProvenanceSchema = z.object({
-  schemaVersion: z.literal("openpond.taskAuthoringProvenance.v1"),
+var AuthoringRepairSchema = z2.object({ attempt: z2.number().int().positive(), summary: z2.string().trim().min(1).max(5e3), createdAt: TimestampSchema2 });
+var AuthoringProvenanceSchema = z2.object({
+  schemaVersion: z2.literal("openpond.taskAuthoringProvenance.v1"),
   model: ChatModelRefSchema.nullable(),
-  modelConfig: MetadataSchema,
-  skillHash: HashSchema,
-  promptTemplateVersion: z.string().trim().min(1).max(200),
+  modelConfig: MetadataSchema2,
+  skillHash: HashSchema2,
+  promptTemplateVersion: z2.string().trim().min(1).max(200),
   buildIntent: DatasetBuildIntentSchema.default("demonstrations"),
   buildSpecification: DatasetBuildSpecificationSchema.nullable().default(null),
-  evidenceHashes: z.array(HashSchema).max(1e5),
-  tasksetSdkVersion: z.string().trim().min(1).max(100),
-  sourceCommit: z.string().trim().min(1).max(256).nullable(),
-  repairHistory: z.array(AuthoringRepairSchema).max(1e3),
-  createdAt: TimestampSchema
+  evidenceHashes: z2.array(HashSchema2).max(1e5),
+  tasksetSdkVersion: z2.string().trim().min(1).max(100),
+  sourceCommit: z2.string().trim().min(1).max(256).nullable(),
+  repairHistory: z2.array(AuthoringRepairSchema).max(1e3),
+  createdAt: TimestampSchema2
 });
-var TasksetSchema = z.object({
-  schemaVersion: z.literal("openpond.taskset.v1"),
-  id: IdSchema,
-  revision: z.number().int().positive().default(1),
-  profileId: IdSchema,
+var TasksetSchema = z2.object({
+  schemaVersion: z2.literal("openpond.taskset.v1"),
+  id: IdSchema2,
+  revision: z2.number().int().positive().default(1),
+  profileId: IdSchema2,
   profileRelease: VersionedReleaseRefSchema.nullable().optional(),
   createImproveRunId: NullableIdSchema.default(null),
-  name: z.string().trim().min(1).max(500),
+  name: z2.string().trim().min(1).max(500),
   // Portable tasks may carry all instructions in their individual inputs.
   // Preserve an absent package prompt; draft publication validates its objective.
-  objective: z.string().trim().max(2e4),
+  objective: z2.string().trim().max(2e4),
   purpose: TasksetPurposeSchema.default("general"),
   benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),
   preferenceComparison: TasksetPreferenceComparisonBindingSchema.nullable().default(null),
   status: TasksetStatusSchema,
-  sourceRefs: z.array(TasksetSourceRefSchema).min(1).max(1e5),
+  sourceRefs: z2.array(TasksetSourceRefSchema).min(1).max(1e5),
   datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),
   policy: TaskPolicyBoundarySchema,
   environment: TasksetEnvironmentContractSchema,
   capabilities: TasksetCapabilityManifestSchema,
-  metrics: TasksetMetricPolicySchema.optional(),
-  tasks: z.array(TaskDataRecordSchema).max(1e6),
-  graders: z.array(GraderSpecSchema).max(1e3),
+  metrics: TasksetMetricPolicySchema2.optional(),
+  tasks: z2.array(TaskDataRecordSchema).max(1e6),
+  graders: z2.array(GraderSpecSchema).max(1e3),
   // Imported releases are inspectable before local calibration. Admission
   // requires real fixtures separately in validateTaskset.
-  graderFixtures: z.array(GraderFixtureSchema).max(1e5),
+  graderFixtures: z2.array(GraderFixtureSchema).max(1e5),
   learningSignals: LearningSignalInventorySchema,
   authoringProvenance: AuthoringProvenanceSchema,
   readiness: TasksetReadinessReportSchema.nullable(),
-  contentHash: HashSchema,
-  createdAt: TimestampSchema,
-  updatedAt: TimestampSchema,
-  metadata: MetadataSchema
+  contentHash: HashSchema2,
+  createdAt: TimestampSchema2,
+  updatedAt: TimestampSchema2,
+  metadata: MetadataSchema2
 }).superRefine((taskset, context) => {
   if (taskset.purpose === "benchmark" && !taskset.benchmark) {
     context.addIssue({
@@ -241,6 +379,123 @@ function isTrainingSourceRef(source) {
   return source.schemaVersion === "openpond.trainingSource.v1";
 }
 
+// src/taskset-draft-authoring.ts
+var TasksetDraftPublishError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(issues.map((issue) => issue.message).join("\n"));
+    this.name = "TasksetDraftPublishError";
+    this.issues = issues;
+  }
+};
+function createTasksetDraft(input) {
+  const timestamp = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const id = input.id?.trim() || `taskset-draft-${globalThis.crypto.randomUUID()}`;
+  return TasksetDraftSchema.parse({
+    schemaVersion: "openpond.tasksetDraft.v1",
+    id,
+    revision: 1,
+    profileId: input.profileId,
+    modelScope: input.modelScope ?? null,
+    name: input.name?.trim() ?? "",
+    objective: "",
+    purpose: "general",
+    benchmark: null,
+    preferenceComparison: null,
+    status: "draft",
+    sourceRefs: [],
+    datasetArtifact: null,
+    policy: {
+      policyVisibleFields: ["input"],
+      privilegedFields: ["expectedOutput"],
+      hiddenGraderRefs: [],
+      connectedAppScopes: []
+    },
+    environment: {
+      protocolVersion: "openpond.taskEnvironment.v1",
+      kind: "chat",
+      entrypoint: "openpond-chat-v1",
+      stateful: false,
+      deterministicSeeds: true,
+      toolNames: [],
+      lifecycle: ["create", "reset", "step", "grade", "cleanup"],
+      defaultTimeoutMs: 12e4,
+      networkPolicy: "none",
+      resources: [],
+      metadata: {}
+    },
+    output: {
+      mode: "text",
+      jsonSchema: null,
+      renderer: null
+    },
+    capabilities: {
+      schemaVersion: "openpond.tasksetCapabilities.v1",
+      taskKind: "chat",
+      supportedSignals: [
+        "demonstration",
+        "preference",
+        "correction",
+        "feedback",
+        "reward",
+        "label"
+      ],
+      compatibleMethods: ["none"],
+      rewardKinds: ["none"],
+      requiresTools: false,
+      requiresState: false,
+      requiresPrivilegedGrading: true,
+      environmentPlacements: ["local", "remote", "colocated"],
+      exportable: true,
+      portabilityBlockers: []
+    },
+    metrics: {
+      schemaVersion: "openpond.tasksetMetricPolicy.v1",
+      primaryMetric: "score",
+      aggregation: "mean_score",
+      missingReward: "zero",
+      customAggregator: null
+    },
+    review: {
+      enabled: false,
+      candidateCount: 2,
+      minimumSamples: 100,
+      allowTies: true,
+      allowRejectAll: true,
+      rubric: "",
+      criteria: []
+    },
+    tasks: [],
+    graders: [],
+    graderFixtures: [],
+    learningSignals: {
+      demonstrations: [],
+      preferences: [],
+      corrections: [],
+      feedback: [],
+      rewards: [],
+      labels: []
+    },
+    publishedTasksetRef: null,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    metadata: {}
+  });
+}
+function draftPublishIssues(draft) {
+  const issues = [];
+  if (!draft.name.trim()) issues.push({ code: "name_missing", message: "Name is required.", path: "name" });
+  if (!draft.objective.trim()) issues.push({ code: "objective_missing", message: "Objective is required.", path: "objective" });
+  if (!draft.datasetArtifact && draft.tasks.length === 0) issues.push({ code: "tasks_missing", message: "Add at least one task or Dataset artifact.", path: "tasks" });
+  const sourceIds = new Set(draft.sourceRefs.map((source) => source.id));
+  for (const task of draft.tasks) {
+    for (const sourceId of task.sourceRefs) {
+      if (!sourceIds.has(sourceId)) issues.push({ code: "task_source_missing", message: `Task ${task.id} references missing source ${sourceId}.`, path: `tasks.${task.id}.sourceRefs` });
+    }
+  }
+  return issues;
+}
+
 // src/taskset-authored-validation.ts
 function validateTaskset(input, options = {}) {
   const parsed = TasksetSchema.safeParse(input);
@@ -617,6 +872,11 @@ function validateCapabilities(capabilities, issues, taskset) {
 }
 
 export {
+  TaskDataDraftSchema,
+  TasksetDraftStatusSchema,
+  TasksetDraftReviewPolicySchema,
+  TasksetDraftOutputContractSchema,
+  TasksetDraftSchema,
   TASKSET_WORK_TOOL_NAMES,
   TasksetStatusSchema,
   DatasetBuildIntentSchema,
@@ -631,8 +891,11 @@ export {
   AuthoringProvenanceSchema,
   TasksetSchema,
   isTrainingSourceRef,
+  TasksetDraftPublishError,
+  createTasksetDraft,
+  draftPublishIssues,
   validateTaskset,
   computeTasksetHash,
   validatePortability
 };
-//# sourceMappingURL=chunk-7AZDNZP6.js.map
+//# sourceMappingURL=chunk-GAIDBPFY.js.map