openpond 0.0.69 → 0.1.1

package/dist/chunks/chunk-R3C3MNSI.js

@@ -0,0 +1,140 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  external_exports
+} from "./chunk-FQS2QL5F.js";
+
+// ../../packages/continual-support/dist/schema.js
+var Id = external_exports.string().trim().min(1).max(240);
+var Hash = external_exports.string().regex(/^[a-f0-9]{64}$/);
+var Timestamp = external_exports.string().datetime({ offset: true });
+var ImmutableRef = external_exports.object({ id: Id, contentHash: Hash }).strict();
+var VersionedRef = ImmutableRef.extend({ revision: external_exports.number().int().positive() }).strict();
+var ChatModelRef = external_exports.object({ providerId: Id, modelId: external_exports.string().trim().min(1).max(300) }).strict();
+var ContinualBenchPanelRoleSchema = external_exports.enum(["correction", "sibling_verification", "cumulative_known", "development", "retained", "frozen_final", "training_eligible"]);
+var ContinualBenchIssueCaseSchema = external_exports.object({
+  taskId: Id,
+  taskContentHash: Hash,
+  panelRole: ContinualBenchPanelRoleSchema,
+  passLabel: Id.nullable(),
+  optimizerEligible: external_exports.boolean(),
+  criticalInvariantIds: external_exports.array(Id).max(100).default([])
+}).strict().superRefine((entry, context) => {
+  if (entry.optimizerEligible !== (entry.panelRole === "correction"))
+    context.addIssue({ code: "custom", path: ["optimizerEligible"], message: "Only correction cases may be optimizer eligible." });
+});
+var ContinualBenchIssuePacketSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.continualBenchIssuePacket.v1"),
+  id: Id,
+  revision: external_exports.number().int().positive(),
+  contentHash: Hash,
+  familyId: Id,
+  familyLabel: external_exports.string().trim().min(1).max(500),
+  severity: external_exports.enum(["low", "medium", "high", "critical"]),
+  cases: external_exports.array(ContinualBenchIssueCaseSchema).min(2).max(1e4),
+  duplicateEvidence: ImmutableRef,
+  leakageEvidence: ImmutableRef,
+  priorExposureEvidence: ImmutableRef,
+  observedAt: Timestamp,
+  reviewedAt: Timestamp,
+  queuedAt: Timestamp.nullable(),
+  runAt: Timestamp.nullable(),
+  createdBy: Id,
+  createdAt: Timestamp
+}).strict().superRefine((packet, context) => {
+  if (!packet.cases.some((entry) => entry.panelRole === "correction"))
+    context.addIssue({ code: "custom", path: ["cases"], message: "An issue packet requires a correction case." });
+  if (!packet.cases.some((entry) => entry.panelRole === "sibling_verification"))
+    context.addIssue({ code: "custom", path: ["cases"], message: "An issue packet requires a sibling-verification case." });
+  if (new Set(packet.cases.map((entry) => entry.taskId)).size !== packet.cases.length)
+    context.addIssue({ code: "custom", path: ["cases"], message: "Issue-packet task ids must be unique." });
+});
+var ContinualBenchPanelReleaseSchema = external_exports.object({
+  id: Id,
+  role: ContinualBenchPanelRoleSchema,
+  passLabel: Id.nullable(),
+  taskset: VersionedRef,
+  familyIds: external_exports.array(Id).min(1).max(1e5),
+  taskCount: external_exports.number().int().positive().max(1e6),
+  sealedAt: Timestamp
+}).strict().superRefine((panel, context) => {
+  const requiresPass = panel.role === "correction" || panel.role === "sibling_verification" || panel.role === "cumulative_known";
+  if (requiresPass !== (panel.passLabel !== null))
+    context.addIssue({ code: "custom", path: ["passLabel"], message: requiresPass ? "This panel role requires a pass label." : "This panel role is series-wide and cannot carry a pass label." });
+});
+var ContinualBenchPolicyIdentitySchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({ kind: external_exports.literal("base_model"), id: Id, revision: external_exports.string().trim().min(1).max(500), contentHash: Hash }).strict(),
+  external_exports.object({ kind: external_exports.literal("model_version"), id: Id, contentHash: Hash }).strict(),
+  external_exports.object({ kind: external_exports.literal("external_reference"), id: Id, model: ChatModelRef, providerRevision: external_exports.string().trim().min(1).max(500), contentHash: Hash }).strict()
+]);
+var ContinualBenchScheduleEntrySchema = external_exports.object({
+  scheduleEntryId: Id,
+  ordinal: external_exports.number().int().nonnegative(),
+  label: Id,
+  role: external_exports.enum(["seed", "daily_residual", "rank_candidate", "weekly_rollup", "full_refresh"]),
+  parentRule: external_exports.enum(["base_model", "previous_release", "seed_release", "accepted_daily_head", "accepted_seed"]),
+  trainableRank: external_exports.number().int().positive().max(1024),
+  correctionPanelIds: external_exports.array(Id).min(1).max(1e3),
+  optimizerGroupsPerTask: external_exports.number().int().positive().max(1e3),
+  trajectoriesPerGroup: external_exports.number().int().min(4).max(1e3)
+}).strict();
+var ContinualBenchCurrencyThresholdsSchema = external_exports.object({
+  revision: external_exports.number().int().positive(),
+  requireAllAttemptsTerminal: external_exports.literal(true),
+  criticalCorrectionPassRate: external_exports.number().min(0).max(1),
+  siblingPassRate: external_exports.number().min(0).max(1),
+  behavioralRetentionRate: external_exports.number().min(0).max(1),
+  maximumRetainedRegressionPoints: external_exports.number().min(0).max(100),
+  blockCriticalPriorRegression: external_exports.boolean(),
+  authorizedClaims: external_exports.array(external_exports.enum(["systems_complete", "correction_absorbed", "issue_generalized", "continually_current", "frontier_pareto_result"])).min(1).max(5)
+}).strict();
+var ContinualBenchmarkProtocolReleaseSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.continualBenchmarkProtocol.v1"),
+  id: Id,
+  revision: external_exports.number().int().positive(),
+  contentHash: Hash,
+  ownerId: Id,
+  createdAt: Timestamp,
+  sealedAt: Timestamp,
+  creationReceipt: ImmutableRef,
+  predecessorSeries: external_exports.object({ id: Id, revision: external_exports.number().int().positive(), contentHash: Hash }).strict().nullable(),
+  scenarioPack: ImmutableRef,
+  issueFamilyLedger: ImmutableRef,
+  issuePacketRelease: ImmutableRef,
+  panels: external_exports.array(ContinualBenchPanelReleaseSchema).min(6).max(1e4),
+  grader: ImmutableRef,
+  judge: external_exports.object({ release: ImmutableRef, rubricRelease: ImmutableRef, calibrationRelease: ImmutableRef, model: ChatModelRef }).strict().nullable(),
+  policies: external_exports.object({ base: ContinualBenchPolicyIdentitySchema, master: ContinualBenchPolicyIdentitySchema.nullable(), externalReferences: external_exports.array(ContinualBenchPolicyIdentitySchema).min(1).max(20) }).strict(),
+  invariants: external_exports.object({
+    systemPromptHash: Hash,
+    toolSchema: ImmutableRef,
+    application: ImmutableRef,
+    harness: ImmutableRef,
+    runtime: ImmutableRef,
+    workerImage: ImmutableRef,
+    autoRefiner: external_exports.object({ enabled: external_exports.boolean(), release: ImmutableRef.nullable() }).strict()
+  }).strict(),
+  schedule: external_exports.array(ContinualBenchScheduleEntrySchema).min(1).max(1e3),
+  evaluation: external_exports.object({ seeds: external_exports.array(external_exports.number().int()).min(3).max(100), repetitions: external_exports.number().int().min(3).max(20), powerRule: ImmutableRef, pairedBootstrapSamples: external_exports.number().int().min(1e3).max(1e6), confidenceLevel: external_exports.literal(0.95) }).strict(),
+  resources: external_exports.object({ maximumTrainingGpuSeconds: external_exports.number().int().positive(), maximumEvaluationGpuSeconds: external_exports.number().int().positive(), maximumProviderSpendUsd: external_exports.number().positive(), maximumTotalSpendUsd: external_exports.number().positive(), maximumConcurrentGroups: external_exports.number().int().positive().max(1e3) }).strict(),
+  currencyThresholds: ContinualBenchCurrencyThresholdsSchema
+}).strict().superRefine((protocol, context) => {
+  const panelIds = protocol.panels.map((panel) => panel.id);
+  if (new Set(panelIds).size !== panelIds.length)
+    context.addIssue({ code: "custom", path: ["panels"], message: "Protocol panel ids must be unique." });
+  for (const role of ["development", "retained", "frozen_final", "training_eligible"]) {
+    if (protocol.panels.filter((panel) => panel.role === role).length !== 1)
+      context.addIssue({ code: "custom", path: ["panels"], message: `A protocol requires exactly one ${role} panel.` });
+  }
+  const ordered = [...protocol.schedule].sort((left, right) => left.ordinal - right.ordinal);
+  if (ordered.some((entry, index) => entry.ordinal !== index))
+    context.addIssue({ code: "custom", path: ["schedule"], message: "Protocol schedule ordinals must be contiguous from zero." });
+  const known = new Set(panelIds);
+  if (protocol.schedule.some((entry) => entry.correctionPanelIds.some((id) => !known.has(id))))
+    context.addIssue({ code: "custom", path: ["schedule"], message: "Every scheduled correction panel must belong to the protocol." });
+});
+
+export {
+  ContinualBenchPanelRoleSchema,
+  ContinualBenchIssuePacketSchema,
+  ContinualBenchmarkProtocolReleaseSchema
+};

package/dist/chunks/{cli-HIXVXM72.js → cli-6PFRZ2WV.js}

@@ -3,12 +3,13 @@ import {
   resolveWebLaunchMessages,
   runOpenPondAppServerCli,
   runOpenPondServerCli
-} from "./chunk-QTN6HXOR.js";
+} from "./chunk-KWDOAJJI.js";
 import "./chunk-5TKZBMQM.js";
-import "./chunk-NPNIL6SQ.js";
-import "./chunk-FEOLMLYU.js";
-import "./chunk-MMRJNSWY.js";
-import "./chunk-BLFIIAWZ.js";
+import "./chunk-DJL4TJYG.js";
+import "./chunk-EFET7LB7.js";
+import "./chunk-6G6MDZLM.js";
+import "./chunk-NTK22KJD.js";
+import "./chunk-R3C3MNSI.js";
 import "./chunk-X7ZG4TSW.js";
 import "./chunk-JTHL5XJ2.js";
 import "./chunk-FQS2QL5F.js";