openpond-sdk 0.11.3 → 0.11.5

package/dist/chunk-QUOW6URQ.js

@@ -1,591 +0,0 @@
-// ../harness/dist/common.js
-import { z } from "zod";
-
-// ../harness/dist/sha256.js
-var INITIAL_STATE = new Uint32Array([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]);
-var ROUND_CONSTANTS = new Uint32Array([
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-]);
-function sha256Hex(value) {
-  const bytes = typeof value === "string" ? new TextEncoder().encode(value) : value;
-  const paddedLength = Math.ceil((bytes.byteLength + 9) / 64) * 64;
-  const padded = new Uint8Array(paddedLength);
-  padded.set(bytes);
-  padded[bytes.byteLength] = 128;
-  const bitLength = bytes.byteLength * 8;
-  const view = new DataView(padded.buffer);
-  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296), false);
-  view.setUint32(paddedLength - 4, bitLength >>> 0, false);
-  const state = new Uint32Array(INITIAL_STATE);
-  const words = new Uint32Array(64);
-  for (let offset = 0; offset < paddedLength; offset += 64) {
-    for (let index = 0; index < 16; index += 1) {
-      words[index] = view.getUint32(offset + index * 4, false);
-    }
-    for (let index = 16; index < 64; index += 1) {
-      const previous = words[index - 15];
-      const recent = words[index - 2];
-      const sigma0 = rotateRight(previous, 7) ^ rotateRight(previous, 18) ^ previous >>> 3;
-      const sigma1 = rotateRight(recent, 17) ^ rotateRight(recent, 19) ^ recent >>> 10;
-      words[index] = words[index - 16] + sigma0 + words[index - 7] + sigma1 >>> 0;
-    }
-    let a = state[0];
-    let b = state[1];
-    let c = state[2];
-    let d = state[3];
-    let e = state[4];
-    let f = state[5];
-    let g = state[6];
-    let h = state[7];
-    for (let index = 0; index < 64; index += 1) {
-      const choice = e & f ^ ~e & g;
-      const majority = a & b ^ a & c ^ b & c;
-      const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
-      const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
-      const first = h + sum1 + choice + ROUND_CONSTANTS[index] + words[index] >>> 0;
-      const second = sum0 + majority >>> 0;
-      h = g;
-      g = f;
-      f = e;
-      e = d + first >>> 0;
-      d = c;
-      c = b;
-      b = a;
-      a = first + second >>> 0;
-    }
-    state[0] = state[0] + a >>> 0;
-    state[1] = state[1] + b >>> 0;
-    state[2] = state[2] + c >>> 0;
-    state[3] = state[3] + d >>> 0;
-    state[4] = state[4] + e >>> 0;
-    state[5] = state[5] + f >>> 0;
-    state[6] = state[6] + g >>> 0;
-    state[7] = state[7] + h >>> 0;
-  }
-  return Array.from(state, (word) => word.toString(16).padStart(8, "0")).join("");
-}
-function rotateRight(value, bits) {
-  return value >>> bits | value << 32 - bits;
-}
-
-// ../harness/dist/common.js
-var MAX_PORTABLE_PATH_BYTES = 2e3;
-var MAX_PORTABLE_ASSET_BYTES = 25e7;
-var ReleaseIdSchema = z.string().trim().min(1).max(240);
-var ReleaseHashSchema = z.string().regex(/^[a-f0-9]{64}$/);
-var ReleaseTimestampSchema = z.string().datetime({ offset: true });
-var MetadataSchema = z.record(z.string(), z.unknown()).default({});
-var ImmutableReleaseRefSchema = z.object({
-  id: ReleaseIdSchema,
-  contentHash: ReleaseHashSchema
-}).strict();
-var VersionedReleaseRefSchema = ImmutableReleaseRefSchema.extend({
-  revision: z.number().int().positive()
-}).strict();
-var ImmutableAssetRefSchema = z.object({
-  id: ReleaseIdSchema,
-  path: z.string().trim().min(1).max(MAX_PORTABLE_PATH_BYTES).refine(safeRelativePath),
-  contentHash: ReleaseHashSchema,
-  sizeBytes: z.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES),
-  mediaType: z.string().trim().min(1).max(200),
-  visibility: z.enum(["policy", "verifier", "host_private"])
-}).strict();
-var ImmutableArtifactRefSchema = z.object({
-  id: ReleaseIdSchema,
-  contentHash: ReleaseHashSchema,
-  mediaType: z.string().trim().min(1).max(200).nullable().default(null),
-  sizeBytes: z.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES).nullable().default(null)
-}).strict();
-var FailureClassSchema = z.enum([
-  "policy_failure",
-  "grader_failure",
-  "environment_failure",
-  "infrastructure_failure",
-  "timeout",
-  "cancelled"
-]);
-function canonicalJson(value) {
-  return `${JSON.stringify(sortValue(value), null, 2)}
-`;
-}
-function sha256(value) {
-  return sha256Hex(value);
-}
-function contentHash(value) {
-  return sha256(canonicalJson(value));
-}
-function assertContentHash(value, label) {
-  const { contentHash: actual, ...hashable } = value;
-  const expected = contentHash(hashable);
-  if (actual !== expected)
-    throw new Error(`${label} contentHash is ${actual}; expected ${expected}.`);
-}
-function safeRelativePath(value) {
-  const normalized = value.replaceAll("\\", "/");
-  if (!normalized || normalized.startsWith("/") || normalized.includes("\0"))
-    return false;
-  return !normalized.split("/").some((part) => !part || part === "." || part === "..");
-}
-function sortValue(value) {
-  if (Array.isArray(value))
-    return value.map(sortValue);
-  if (!value || typeof value !== "object")
-    return value;
-  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortValue(child)]));
-}
-
-// ../harness/dist/refiner-profiles.js
-import { z as z2 } from "zod";
-var RefinerProposalRouteSchema = z2.enum(["memory", "prompt", "skill", "agent"]);
-var RefinerExternalRouteSchema = z2.enum(["runtime", "product", "taskset", "training"]);
-var RefinerReviewInstructionSchema = z2.object({
-  id: z2.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
-  text: z2.string().trim().min(1).max(1e4)
-}).strict();
-var RefinerReviewProfileSchema = z2.object({
-  schemaVersion: z2.literal("openpond.refinerReviewProfile.v1"),
-  id: z2.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
-  version: z2.string().trim().min(1).max(120),
-  name: z2.string().trim().min(1).max(200),
-  objective: z2.string().trim().min(1).max(1e4),
-  instructions: z2.array(RefinerReviewInstructionSchema).max(100),
-  allowedProposalRoutes: z2.array(RefinerProposalRouteSchema).max(4),
-  allowedExternalRoutes: z2.array(RefinerExternalRouteSchema).max(4)
-}).strict().superRefine((profile, context) => {
-  const instructionIds = profile.instructions.map((instruction) => instruction.id);
-  if (new Set(instructionIds).size !== instructionIds.length) {
-    context.addIssue({ code: "custom", message: "instruction IDs must be unique", path: ["instructions"] });
-  }
-  if (new Set(profile.allowedProposalRoutes).size !== profile.allowedProposalRoutes.length) {
-    context.addIssue({ code: "custom", message: "proposal routes must be unique", path: ["allowedProposalRoutes"] });
-  }
-  if (new Set(profile.allowedExternalRoutes).size !== profile.allowedExternalRoutes.length) {
-    context.addIssue({ code: "custom", message: "external routes must be unique", path: ["allowedExternalRoutes"] });
-  }
-});
-var DEFAULT_REFINER_REVIEW_PROFILE = {
-  schemaVersion: "openpond.refinerReviewProfile.v1",
-  id: "openpond.default",
-  version: "1",
-  name: "OpenPond default review",
-  objective: "Find the smallest reusable change that improves future work without learning task-specific facts.",
-  instructions: [],
-  allowedProposalRoutes: ["memory", "prompt", "skill", "agent"],
-  allowedExternalRoutes: ["runtime", "product", "taskset", "training"]
-};
-var RefinerReleaseSchema = z2.object({
-  schemaVersion: z2.literal("openpond.refinerRelease.v1"),
-  id: z2.string().trim().min(1).max(240),
-  coreVersion: z2.string().trim().min(1).max(120),
-  coreHash: ReleaseHashSchema,
-  profile: RefinerReviewProfileSchema,
-  profileHash: ReleaseHashSchema,
-  composedPromptHash: ReleaseHashSchema,
-  createdAt: ReleaseTimestampSchema,
-  contentHash: ReleaseHashSchema
-}).strict();
-var RefinerBindingSchema = z2.object({
-  schemaVersion: z2.literal("openpond.refinerBinding.v1"),
-  channel: z2.literal("active"),
-  revision: z2.number().int().nonnegative(),
-  release: ImmutableReleaseRefSchema,
-  updatedAt: ReleaseTimestampSchema
-}).strict();
-var RefinerTransitionReceiptSchema = z2.object({
-  schemaVersion: z2.literal("openpond.refinerTransitionReceipt.v1"),
-  id: z2.string().trim().min(1).max(240),
-  operation: z2.enum(["initialize", "update", "activate", "rollback"]),
-  bindingChanged: z2.boolean(),
-  previousRelease: ImmutableReleaseRefSchema.nullable(),
-  nextRelease: ImmutableReleaseRefSchema,
-  actor: z2.string().trim().min(1).max(240),
-  reason: z2.string().trim().min(1).max(1e4),
-  authoringSkillHash: ReleaseHashSchema.nullable(),
-  validation: z2.object({ valid: z2.boolean(), messages: z2.array(z2.string().max(2e3)).max(100) }).strict(),
-  createdAt: ReleaseTimestampSchema,
-  contentHash: ReleaseHashSchema
-}).strict();
-function defineReviewProfile(profile) {
-  return RefinerReviewProfileSchema.parse(profile);
-}
-function createRefinerRelease(input) {
-  const profile = RefinerReviewProfileSchema.parse(input.profile);
-  const createdAt = input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  const coreHash = contentHash({ coreVersion: input.coreVersion, corePrompt: input.corePrompt });
-  const profileHash = contentHash(profile);
-  const composedPromptHash = contentHash({ coreHash, profile });
-  const releaseWithoutHash = {
-    schemaVersion: "openpond.refinerRelease.v1",
-    id: `refiner-${composedPromptHash.slice(0, 24)}`,
-    coreVersion: input.coreVersion,
-    coreHash,
-    profile,
-    profileHash,
-    composedPromptHash,
-    createdAt
-  };
-  return RefinerReleaseSchema.parse({
-    ...releaseWithoutHash,
-    contentHash: contentHash(releaseWithoutHash)
-  });
-}
-function refinerProfilePrompt(profile) {
-  const parsed = RefinerReviewProfileSchema.parse(profile);
-  return [
-    `Review profile: ${parsed.name} (${parsed.id}@${parsed.version})`,
-    `Objective: ${parsed.objective}`,
-    `Allowed Harness proposal routes: ${parsed.allowedProposalRoutes.join(", ")}.`,
-    `Allowed external routes: ${parsed.allowedExternalRoutes.join(", ")}.`,
-    ...parsed.instructions.map((instruction) => `[${instruction.id}] ${instruction.text}`)
-  ].join("\n");
-}
-function serializeReviewProfile(profile) {
-  return canonicalJson(RefinerReviewProfileSchema.parse(profile));
-}
-
-// ../harness/dist/refiner.js
-import { z as z3 } from "zod";
-var RefinerNoActionDecisionSchema = z3.object({
-  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v1"),
-  decision: z3.literal("no_action"),
-  reason: z3.string().trim().min(1).max(1e4)
-}).strip();
-var RefinerExternalRouteDecisionSchema = z3.object({
-  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v1"),
-  decision: z3.literal("route"),
-  route: z3.enum(["runtime", "product", "taskset", "training"]),
-  summary: z3.string().trim().min(1).max(2e3),
-  expectedOutcome: z3.string().trim().min(1).max(1e4),
-  reason: z3.string().trim().min(1).max(1e4)
-}).strip();
-var RefinerProposalDecisionSchema = z3.object({
-  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v1"),
-  decision: z3.literal("propose"),
-  route: z3.enum(["memory", "prompt", "skill", "agent"]),
-  operation: z3.enum(["create", "update", "delete"]),
-  target: z3.string().trim().min(1).max(2e3),
-  summary: z3.string().trim().min(1).max(2e3),
-  createContent: z3.string().min(1).max(2e4).nullable(),
-  find: z3.string().min(1).max(8e3).nullable(),
-  replace: z3.string().max(8e3).nullable(),
-  expectedOutcome: z3.string().trim().min(1).max(1e4),
-  reason: z3.string().trim().min(1).max(1e4)
-}).strip().superRefine((decision, context) => {
-  if (decision.operation === "create" && (decision.createContent === null || decision.find !== null || decision.replace !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "create proposals require createContent and null find/replace",
-      path: ["createContent"]
-    });
-  }
-  if (decision.operation === "update" && (decision.createContent !== null || decision.find === null || decision.replace === null)) {
-    context.addIssue({
-      code: "custom",
-      message: "update proposals require one exact find/replace edit and null createContent",
-      path: ["find"]
-    });
-  }
-  if (decision.operation === "delete" && (decision.createContent !== null || decision.find !== null || decision.replace !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "delete proposals require null createContent/find/replace",
-      path: ["createContent"]
-    });
-  }
-});
-var LocalHarnessRefinerDecisionSchema = z3.discriminatedUnion("decision", [
-  RefinerNoActionDecisionSchema,
-  RefinerExternalRouteDecisionSchema,
-  RefinerProposalDecisionSchema
-]);
-var LocalHarnessRefinerDecisionV1Schema = LocalHarnessRefinerDecisionSchema;
-var HarnessRefinerEvidenceBasisSchema = z3.object({
-  kind: z3.enum(["single_deterministic", "recurrent_independent"]),
-  supportingEvidenceIds: z3.array(z3.string().trim().min(1).max(2e3)).min(1).max(100),
-  counterevidence: z3.array(z3.string().trim().min(1).max(2e3)).max(20)
-}).strict().superRefine((basis, context) => {
-  if (new Set(basis.supportingEvidenceIds).size !== basis.supportingEvidenceIds.length) {
-    context.addIssue({
-      code: "custom",
-      message: "supporting evidence IDs must be unique",
-      path: ["supportingEvidenceIds"]
-    });
-  }
-  if (basis.kind === "recurrent_independent" && basis.supportingEvidenceIds.length < 2) {
-    context.addIssue({
-      code: "custom",
-      message: "recurrent independent evidence requires at least two supplied incidents",
-      path: ["supportingEvidenceIds"]
-    });
-  }
-});
-var RefinerNoActionDecisionV2Schema = z3.object({
-  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v2"),
-  decision: z3.literal("no_action"),
-  reason: z3.string().trim().min(1).max(1e4)
-}).strict();
-var RefinerExternalRouteDecisionV2Schema = z3.object({
-  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v2"),
-  decision: z3.literal("route"),
-  route: z3.enum(["runtime", "product", "taskset", "training"]),
-  summary: z3.string().trim().min(1).max(2e3),
-  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
-  expectedOutcome: z3.string().trim().min(1).max(1e4),
-  reason: z3.string().trim().min(1).max(1e4)
-}).strict();
-var RefinerProposalDecisionV2Schema = z3.object({
-  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v2"),
-  decision: z3.literal("propose"),
-  route: z3.enum(["memory", "prompt", "skill", "agent"]),
-  operation: z3.enum(["create", "update", "delete"]),
-  target: z3.string().trim().min(1).max(2e3),
-  summary: z3.string().trim().min(1).max(2e3),
-  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
-  createContent: z3.string().min(1).max(2e4).nullable(),
-  find: z3.string().min(1).max(8e3).nullable(),
-  replace: z3.string().max(8e3).nullable(),
-  expectedOutcome: z3.string().trim().min(1).max(1e4),
-  reason: z3.string().trim().min(1).max(1e4)
-}).strict().superRefine((decision, context) => {
-  if (decision.operation === "create" && (decision.createContent === null || decision.find !== null || decision.replace !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "create proposals require createContent and null find/replace",
-      path: ["createContent"]
-    });
-  }
-  if (decision.operation === "update" && (decision.createContent !== null || decision.find === null || decision.replace === null)) {
-    context.addIssue({
-      code: "custom",
-      message: "update proposals require one exact find/replace edit and null createContent",
-      path: ["find"]
-    });
-  }
-  if (decision.operation === "delete" && (decision.createContent !== null || decision.find !== null || decision.replace !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "delete proposals require null createContent/find/replace",
-      path: ["createContent"]
-    });
-  }
-});
-var LocalHarnessRefinerDecisionV2Schema = z3.discriminatedUnion("decision", [
-  RefinerNoActionDecisionV2Schema,
-  RefinerExternalRouteDecisionV2Schema,
-  RefinerProposalDecisionV2Schema
-]);
-var LocalHarnessRefinerDecisionAnySchema = z3.union([
-  LocalHarnessRefinerDecisionV1Schema,
-  LocalHarnessRefinerDecisionV2Schema
-]);
-var HarnessRefinerCapabilitiesSchema = z3.object({
-  memory: z3.boolean(),
-  prompt: z3.boolean(),
-  skill: z3.boolean(),
-  agent: z3.boolean()
-}).strict();
-var SourceKindSchema = z3.enum(["memory", "instruction", "skill", "agent"]);
-var RefinerSourceFileSchema = z3.object({
-  path: z3.string().trim().min(1).max(2e3),
-  kind: SourceKindSchema,
-  content: z3.string().max(6e4),
-  loaded: z3.boolean()
-}).strict();
-var RefinerSourceCatalogEntrySchema = z3.object({
-  path: z3.string().trim().min(1).max(2e3),
-  kind: SourceKindSchema,
-  loaded: z3.boolean()
-}).strict();
-var LocalHarnessRefinerEvidenceSchema = z3.object({
-  capabilities: HarnessRefinerCapabilitiesSchema,
-  trigger: z3.record(z3.string(), z3.unknown()),
-  observations: z3.array(z3.record(z3.string(), z3.unknown())).max(20),
-  admissibleEvidenceIds: z3.array(z3.string().trim().min(1).max(2e3)).max(1e4),
-  reviewPacket: z3.object({
-    currentTurn: z3.object({
-      id: z3.string().trim().min(1).max(2e3),
-      status: z3.string().trim().min(1).max(100).nullable(),
-      error: z3.string().max(2100).nullable(),
-      prompt: z3.string().max(8100).nullable(),
-      assistantOutput: z3.string().max(8100).nullable(),
-      assistantOutputLinkCount: z3.number().int().nonnegative()
-    }).strict(),
-    priorConversation: z3.array(z3.object({
-      turnId: z3.string().trim().min(1).max(2e3),
-      status: z3.string().trim().min(1).max(100).nullable(),
-      prompt: z3.string().max(3100).nullable(),
-      assistantOutput: z3.string().max(3100).nullable()
-    }).strict()).max(3),
-    timeline: z3.array(z3.record(z3.string(), z3.unknown())).max(60),
-    artifacts: z3.array(z3.record(z3.string(), z3.unknown())).max(30),
-    artifactDiagnostics: z3.array(z3.record(z3.string(), z3.unknown())).max(20),
-    executionProfile: z3.object({
-      modelRequestCount: z3.number().int().nonnegative(),
-      failedModelRequestCount: z3.number().int().nonnegative(),
-      promptTokens: z3.number().int().nonnegative(),
-      completionTokens: z3.number().int().nonnegative(),
-      totalTokens: z3.number().int().nonnegative(),
-      toolFailureCount: z3.number().int().nonnegative(),
-      retryCount: z3.number().int().nonnegative(),
-      recoveryCount: z3.number().int().nonnegative()
-    }).strict(),
-    priorIncidents: z3.array(z3.record(z3.string(), z3.unknown())).max(3),
-    truncation: z3.object({
-      timelineEventCount: z3.number().int().nonnegative(),
-      includedTimelineEventCount: z3.number().int().nonnegative(),
-      timelineTruncated: z3.boolean()
-    }).strict()
-  }).strict(),
-  runtimeActivation: z3.object({
-    admittedRelease: ImmutableReleaseRefSchema,
-    currentRelease: ImmutableReleaseRefSchema,
-    rebasedOntoCurrent: z3.boolean(),
-    admittedSourceFiles: z3.array(RefinerSourceFileSchema).max(100),
-    admittedSourceCatalog: z3.array(RefinerSourceCatalogEntrySchema).max(1e3)
-  }).strict(),
-  sourceFiles: z3.array(RefinerSourceFileSchema).max(100),
-  sourceCatalog: z3.array(RefinerSourceCatalogEntrySchema).max(1e3),
-  additionalEvidence: z3.unknown().nullable().optional()
-}).strict();
-var REFINER_CORE_VERSION = "openpond.refinerCore.v2";
-var OverlayRefSchema = z3.object({
-  id: z3.string().trim().min(1).max(240),
-  revision: z3.number().int().nonnegative(),
-  contentHash: ReleaseHashSchema
-}).strict();
-var HostedHarnessRefinerRequestSchema = z3.object({
-  schemaVersion: z3.literal("openpond.hostedHarnessRefinerRequest.v2"),
-  requestId: z3.string().trim().min(1).max(240),
-  idempotencyKey: z3.string().trim().min(1).max(240),
-  evidenceHash: ReleaseHashSchema,
-  harness: z3.object({
-    admittedRelease: ImmutableReleaseRefSchema,
-    currentRelease: ImmutableReleaseRefSchema,
-    overlay: OverlayRefSchema,
-    workspace: z3.object({
-      id: z3.string().trim().min(1).max(240),
-      revision: z3.number().int().nonnegative(),
-      sourceRevision: ReleaseHashSchema,
-      channelRevision: z3.number().int().nonnegative()
-    }).strict(),
-    capabilities: HarnessRefinerCapabilitiesSchema
-  }).strict(),
-  evidence: LocalHarnessRefinerEvidenceSchema
-}).strict();
-var HostedHarnessRefinerUsageSchema = z3.object({
-  promptTokens: z3.number().int().nonnegative(),
-  completionTokens: z3.number().int().nonnegative(),
-  totalTokens: z3.number().int().nonnegative()
-}).strict();
-var HostedHarnessRefinerResponseSchema = z3.object({
-  schemaVersion: z3.literal("openpond.hostedHarnessRefinerResponse.v2"),
-  requestId: z3.string().trim().min(1).max(240),
-  evidenceHash: ReleaseHashSchema,
-  admittedRelease: ImmutableReleaseRefSchema,
-  currentRelease: ImmutableReleaseRefSchema,
-  decision: LocalHarnessRefinerDecisionV2Schema,
-  serviceRevision: z3.string().trim().min(1).max(240),
-  usage: HostedHarnessRefinerUsageSchema
-}).strict();
-
-export {
-  ReleaseIdSchema,
-  ReleaseHashSchema,
-  ReleaseTimestampSchema,
-  MetadataSchema,
-  ImmutableReleaseRefSchema,
-  VersionedReleaseRefSchema,
-  ImmutableAssetRefSchema,
-  ImmutableArtifactRefSchema,
-  FailureClassSchema,
-  canonicalJson,
-  sha256,
-  contentHash,
-  assertContentHash,
-  RefinerReviewInstructionSchema,
-  RefinerReviewProfileSchema,
-  DEFAULT_REFINER_REVIEW_PROFILE,
-  RefinerReleaseSchema,
-  RefinerBindingSchema,
-  RefinerTransitionReceiptSchema,
-  defineReviewProfile,
-  createRefinerRelease,
-  refinerProfilePrompt,
-  serializeReviewProfile,
-  HarnessRefinerEvidenceBasisSchema,
-  HarnessRefinerCapabilitiesSchema,
-  REFINER_CORE_VERSION
-};
-//# sourceMappingURL=chunk-QUOW6URQ.js.map