@hraness/message-like-me 0.8.3 → 0.8.5

package/dist/ensoul-source-v1.js

@@ -8,10 +8,10 @@ import {
   buildEnsoulMessagesSourcePacketV1,
   ensoulSubjectMessages,
   ensoulSubjectReactions
-} from "./cli-x1qncxm7.js";
-import"./cli-qqafdvz9.js";
-import"./cli-kw20gkk3.js";
-import"./cli-ththzwja.js";
+} from "./index-7dfvy41v.js";
+import"./index-qqafdvz9.js";
+import"./index-kw20gkk3.js";
+import"./index-y1aec88m.js";
 export {
   ensoulSubjectReactions,
   ensoulSubjectMessages,

package/dist/{cli-x1qncxm7.js → index-7dfvy41v.js}

@@ -1,17 +1,14 @@
 // @bun
 import {
   MESSAGE_BUNDLE_V1_SCHEMA_IDENTITY
-} from "./cli-qqafdvz9.js";
+} from "./index-qqafdvz9.js";
 import {
   MESSAGE_BUNDLE_V2_SCHEMA_IDENTITY
-} from "./cli-kw20gkk3.js";
+} from "./index-kw20gkk3.js";
 import {
   canonicalJson,
   sha256
-} from "./cli-ththzwja.js";
-
-// src/metrics.ts
-import { createHash } from "crypto";
+} from "./index-y1aec88m.js";
 
 // src/types.ts
 var CORPUS_SCHEMA_VERSION = 2;
@@ -39,26 +36,12 @@ var MAX_STUDY_MESSAGES_PER_DIRECTION = 64;
 var DEFAULT_MAX_STUDY_PACKET_BODY_BYTES = 256 * 1024;
 var MAX_STUDY_PACKET_BODY_BYTES = 1024 * 1024;
 var MAX_GAP_SECONDS = 30 * 24 * 60 * 60;
-function digest(namespace, parts) {
-  const hash = createHash("sha256");
-  hash.update(`message-like-me\x00${namespace}\x00`, "utf8");
-  for (const part of parts)
-    hash.update(`${part.length}:`, "utf8").update(part, "utf8");
-  return hash.digest("hex");
-}
 function round(value, places = 6) {
   if (!Number.isFinite(value))
     return 0;
   const scale = 10 ** places;
   return Math.round((value + Number.EPSILON) * scale) / scale;
 }
-function boundedGap(value, fallback, label) {
-  const result = value ?? fallback;
-  if (!Number.isSafeInteger(result) || result < 1 || result > MAX_GAP_SECONDS) {
-    throw new Error(`${label} must be an integer from 1 through ${MAX_GAP_SECONDS}`);
-  }
-  return result;
-}
 function boundedStudyInteger(value, fallback, maximum, label) {
   const result = value ?? fallback;
   if (!Number.isSafeInteger(result) || result < 1 || result > maximum) {
@@ -103,349 +86,9 @@ function orderedMessages(messages) {
   rows.sort((left, right) => left.milliseconds - right.milliseconds || left.message.sourceRowId - right.message.sourceRowId || left.message.id.localeCompare(right.message.id, "en-US"));
   return Object.freeze(rows);
 }
-function timelineEligible(message) {
-  return message.retractedAt === null && (message.kind === "text" || message.kind === "attachment" || message.kind === "reaction");
-}
-function responseEligible(message) {
-  return message.retractedAt === null && (message.kind === "text" || message.kind === "attachment");
-}
-function secondsBetween(left, right) {
-  return Math.max(0, (right.milliseconds - left.milliseconds) / 1000);
-}
-function sessionsFor(messages, corpusRevision, contactId, gapSeconds) {
-  const eligible = messages.filter(({ message }) => timelineEligible(message));
-  if (eligible.length === 0)
-    return Object.freeze([]);
-  const groups = [];
-  for (const row of eligible) {
-    const current = groups.at(-1);
-    const prior = current?.at(-1);
-    if (current === undefined || prior === undefined || secondsBetween(prior, row) > gapSeconds) {
-      groups.push([row]);
-    } else
-      current.push(row);
-  }
-  return Object.freeze(groups.map((group, index) => {
-    const first = group[0];
-    const last = group.at(-1);
-    const incomingCount = group.filter(({ message }) => message.direction === "incoming").length;
-    const outgoingCount = group.length - incomingCount;
-    return Object.freeze({
-      id: digest("session", [corpusRevision, contactId, String(index), ...group.map(({ message }) => message.id)]),
-      startedAt: first.message.sentAt,
-      endedAt: last.message.sentAt,
-      durationSeconds: round((last.milliseconds - first.milliseconds) / 1000, 3),
-      messageCount: group.length,
-      incomingCount,
-      outgoingCount,
-      startedBy: first.message.direction,
-      endedBy: last.message.direction
-    });
-  }));
-}
-function blocksFor(messages, burstGapSeconds) {
-  const eligible = messages.filter(({ message }) => responseEligible(message));
-  const blocks = [];
-  for (const row of eligible) {
-    const current = blocks.at(-1);
-    const prior = current?.messages.at(-1);
-    if (current === undefined || prior === undefined || current.direction !== row.message.direction || secondsBetween(prior, row) > burstGapSeconds) {
-      blocks.push({ direction: row.message.direction, messages: [row] });
-    } else
-      current.messages.push(row);
-  }
-  return Object.freeze(blocks.map((block) => Object.freeze({
-    direction: block.direction,
-    messages: Object.freeze(block.messages)
-  })));
-}
-function burstsFor(messages, sessions, corpusRevision, contactId, burstGapSeconds) {
-  const result = [];
-  for (const session of sessions) {
-    const started = Date.parse(session.startedAt);
-    const ended = Date.parse(session.endedAt);
-    const sessionRows = messages.filter((row) => row.milliseconds >= started && row.milliseconds <= ended && responseEligible(row.message));
-    for (const block of blocksFor(sessionRows, burstGapSeconds)) {
-      const first = block.messages[0];
-      const last = block.messages.at(-1);
-      const messageIds = Object.freeze(block.messages.map(({ message }) => message.id));
-      const textBodies = bodies(block.messages);
-      result.push(Object.freeze({
-        metric: Object.freeze({
-          id: digest("burst", [corpusRevision, contactId, session.id, ...messageIds]),
-          sessionId: session.id,
-          startedAt: first.message.sentAt,
-          endedAt: last.message.sentAt,
-          durationSeconds: round((last.milliseconds - first.milliseconds) / 1000, 3),
-          direction: block.direction,
-          messageIds,
-          messageCount: block.messages.length,
-          textMessageCount: textBodies.length,
-          characters: textBodies.reduce((total, body) => total + characterCount(body), 0)
-        }),
-        messages: block.messages
-      }));
-    }
-  }
-  return Object.freeze(result);
-}
-function bodies(rows) {
-  return rows.flatMap(({ message }) => message.retractedAt === null && message.kind === "text" && message.body !== null ? [message.body] : []);
-}
 function characterCount(value) {
   return Array.from(value).length;
 }
-function questionCount(value) {
-  return value.match(/[?\uFF1F]/gu)?.length ?? 0;
-}
-function containsMultiItemBody(value) {
-  const lines = value.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
-  if (lines.length >= 2)
-    return true;
-  return /(?:^|\n)\s*(?:[-*\u2022]|[0-9]{1,2}[.)])\s+/u.test(value) || (value.match(/;/gu)?.length ?? 0) >= 2;
-}
-function responseTags(incoming, outgoing, latencySeconds, incomingQuestions, outgoingCharacters, explicitReplyCount, replyUnavailableCount) {
-  const tags = new Set;
-  tags.add(outgoing.length === 1 ? "single-message-response" : "multi-message-response");
-  if (incoming.length > 1)
-    tags.add("multi-incoming");
-  if (incomingQuestions > 1)
-    tags.add("multi-question");
-  if (incoming.length > 1 || incomingQuestions > 1 || bodies(incoming).some(containsMultiItemBody))
-    tags.add("multi-item-context");
-  if (explicitReplyCount > 0)
-    tags.add("explicit-reply");
-  if (replyUnavailableCount > 0)
-    tags.add("reply-unavailable");
-  if (latencySeconds <= 60)
-    tags.add("fast-response");
-  else if (latencySeconds >= 60 * 60)
-    tags.add("delayed-response");
-  if (outgoingCharacters <= 40)
-    tags.add("short-response");
-  else if (outgoingCharacters >= 280)
-    tags.add("long-response");
-  if (bodies(outgoing).some((body) => body.includes(`
-`)))
-    tags.add("multiline-response");
-  return Object.freeze([...tags].sort((left, right) => left.localeCompare(right, "en-US")));
-}
-function responsesFor(bursts, corpusRevision, contactId) {
-  const result = [];
-  const bySession = new Map;
-  for (const burst of bursts) {
-    const values = bySession.get(burst.metric.sessionId) ?? [];
-    values.push(burst);
-    bySession.set(burst.metric.sessionId, values);
-  }
-  for (const sessionBursts of bySession.values()) {
-    for (let index = 0;index + 1 < sessionBursts.length; index += 1) {
-      const incoming = sessionBursts[index];
-      const outgoing = sessionBursts[index + 1];
-      if (incoming.metric.direction !== "incoming" || outgoing.metric.direction !== "outgoing")
-        continue;
-      const incomingBodies = bodies(incoming.messages);
-      const outgoingBodies = bodies(outgoing.messages);
-      const incomingCharacters = incomingBodies.reduce((total, body) => total + characterCount(body), 0);
-      const outgoingCharacters = outgoingBodies.reduce((total, body) => total + characterCount(body), 0);
-      const incomingQuestions = incomingBodies.reduce((total, body) => total + questionCount(body), 0);
-      const explicitReplyCount = outgoing.messages.filter(({ message }) => message.replyState === "explicit").length;
-      const replyEligibleCount = outgoing.messages.filter(({ message }) => message.replyState !== "unavailable").length;
-      const replyUnavailableCount = outgoing.messages.length - replyEligibleCount;
-      const lastIncoming = incoming.messages.at(-1);
-      const firstOutgoing = outgoing.messages[0];
-      const latencySeconds = round(secondsBetween(lastIncoming, firstOutgoing), 3);
-      const incomingIds = Object.freeze(incoming.messages.map(({ message }) => message.id));
-      const outgoingIds = Object.freeze(outgoing.messages.map(({ message }) => message.id));
-      result.push(Object.freeze({
-        id: digest("response", [corpusRevision, contactId, ...incomingIds, "->", ...outgoingIds]),
-        startedAt: incoming.messages[0].message.sentAt,
-        incomingMessageIds: incomingIds,
-        outgoingMessageIds: outgoingIds,
-        incomingCount: incoming.messages.length,
-        outgoingCount: outgoing.messages.length,
-        incomingCharacters,
-        outgoingCharacters,
-        incomingQuestions,
-        latencySeconds,
-        explicitReplyCount,
-        replyEligibleCount,
-        replyUnavailableCount,
-        tags: responseTags(incoming.messages, outgoing.messages, latencySeconds, incomingQuestions, outgoingCharacters, explicitReplyCount, replyUnavailableCount)
-      }));
-    }
-  }
-  return Object.freeze(result);
-}
-function quantile(values, proportion) {
-  if (values.length === 0)
-    return null;
-  const sorted = [...values].sort((left, right) => left - right);
-  if (sorted.length === 1)
-    return sorted[0];
-  const position = (sorted.length - 1) * proportion;
-  const lower = Math.floor(position);
-  const upper = Math.ceil(position);
-  const low = sorted[lower];
-  const high = sorted[upper];
-  return round(low + (high - low) * (position - lower), 6);
-}
-function numericDistribution(values) {
-  const total = values.reduce((sum, value) => sum + value, 0);
-  return Object.freeze({
-    total,
-    mean: values.length === 0 ? 0 : round(total / values.length),
-    median: quantile(values, 0.5) ?? 0,
-    p90: quantile(values, 0.9) ?? 0
-  });
-}
-function wordCount(value) {
-  return value.match(/[\p{L}\p{N}]+(?:['\u2019][\p{L}\p{N}]+)*/gu)?.length ?? 0;
-}
-function firstLetterIsLowercase(value) {
-  const letter = value.match(/\p{L}/u)?.[0];
-  return letter !== undefined && letter.toLocaleLowerCase() === letter && letter.toLocaleUpperCase() !== letter;
-}
-function ratio(count, total) {
-  return total === 0 ? 0 : round(count / total);
-}
-function surfaceMetrics(messages) {
-  const outgoing = messages.flatMap(({ message }) => message.retractedAt === null && message.direction === "outgoing" && message.kind === "text" && message.body !== null ? [message.body] : []);
-  const characters = outgoing.map(characterCount);
-  const words = outgoing.map(wordCount);
-  return Object.freeze({
-    outgoingTextMessages: outgoing.length,
-    characters: numericDistribution(characters),
-    words: numericDistribution(words),
-    lowercaseStartsRatio: ratio(outgoing.filter(firstLetterIsLowercase).length, outgoing.length),
-    terminalPunctuationRatio: ratio(outgoing.filter((body) => /[.!?\u2026\u3002\uFF01\uFF1F]$/u.test(body.trimEnd())).length, outgoing.length),
-    questionRatio: ratio(outgoing.filter((body) => /[?\uFF1F]/u.test(body)).length, outgoing.length),
-    exclamationRatio: ratio(outgoing.filter((body) => /[!\uFF01]/u.test(body)).length, outgoing.length),
-    emojiMessageRatio: ratio(outgoing.filter((body) => /\p{Extended_Pictographic}/u.test(body)).length, outgoing.length),
-    multilineRatio: ratio(outgoing.filter((body) => /\r?\n/u.test(body)).length, outgoing.length)
-  });
-}
-function tempoMetrics(messages, responses) {
-  const latencies = responses.map((response) => response.latencySeconds);
-  const bundles = responses.map((response) => response.outgoingCount);
-  const outgoingText = messages.filter(({ message }) => message.retractedAt === null && message.direction === "outgoing" && message.kind === "text" && message.body !== null);
-  const replyEligible = outgoingText.filter(({ message }) => message.replyState !== "unavailable");
-  const explicitReplies = replyEligible.filter(({ message }) => message.replyState === "explicit").length;
-  const replyUnavailable = outgoingText.length - replyEligible.length;
-  return Object.freeze({
-    responseEpisodes: responses.length,
-    responseLatencySeconds: Object.freeze({
-      median: quantile(latencies, 0.5),
-      p25: quantile(latencies, 0.25),
-      p75: quantile(latencies, 0.75),
-      p90: quantile(latencies, 0.9)
-    }),
-    outgoingMessagesPerResponse: Object.freeze({
-      mean: bundles.length === 0 ? 0 : round(bundles.reduce((sum, value) => sum + value, 0) / bundles.length),
-      median: quantile(bundles, 0.5) ?? 0,
-      p90: quantile(bundles, 0.9) ?? 0,
-      singleRatio: ratio(bundles.filter((value) => value === 1).length, bundles.length),
-      multiRatio: ratio(bundles.filter((value) => value > 1).length, bundles.length)
-    }),
-    explicitReplyMessages: explicitReplies,
-    explicitReplyEligibleMessages: replyEligible.length,
-    explicitReplyUnavailableMessages: replyUnavailable,
-    explicitReplyRatio: replyEligible.length === 0 ? null : ratio(explicitReplies, replyEligible.length),
-    multiIncomingEpisodes: responses.filter((response) => response.incomingCount > 1).length,
-    multiQuestionEpisodes: responses.filter((response) => response.incomingQuestions > 1).length
-  });
-}
-function reactionMetrics(messages, facts) {
-  const legacy = messages.filter(({ message }) => message.kind === "reaction" && message.retractedAt === null).map(({ message }) => ({
-    id: message.id,
-    externalId: message.sourceGuid,
-    targetExternalId: message.replyToSourceGuid ?? message.sourceGuid,
-    conversationId: message.conversationId,
-    direction: message.direction,
-    body: "unknown",
-    reactedAt: message.sentAt,
-    state: "active"
-  }));
-  const merged = new Map(legacy.map((fact) => [fact.id, fact]));
-  for (const fact of facts ?? [])
-    merged.set(fact.id, fact);
-  const source = [...merged.values()];
-  const ids = new Set;
-  const reactions = source.filter((fact, index) => {
-    if (typeof fact.id !== "string" || fact.id.length === 0 || ids.has(fact.id) || fact.direction !== null && fact.direction !== "incoming" && fact.direction !== "outgoing" || typeof fact.body !== "string" || fact.state !== "active" && fact.state !== "removed")
-      throw new Error(`reactionFacts[${index}] is invalid`);
-    if (fact.reactedAt !== null)
-      canonicalTimestamp(fact.reactedAt, `reactionFacts[${index}].reactedAt`);
-    ids.add(fact.id);
-    return fact.state === "active";
-  });
-  const outgoing = reactions.filter(({ direction }) => direction === "outgoing").length;
-  const incoming = reactions.filter(({ direction }) => direction === "incoming").length;
-  const unknownDirection = reactions.length - outgoing - incoming;
-  const outgoingActions = messages.filter(({ message }) => message.kind !== "reaction" && message.direction === "outgoing" && timelineEligible(message)).length + outgoing;
-  return Object.freeze({
-    total: reactions.length,
-    incoming,
-    outgoing,
-    unknownDirection,
-    dated: reactions.filter(({ reactedAt }) => reactedAt !== null).length,
-    undated: reactions.filter(({ reactedAt }) => reactedAt === null).length,
-    outgoingReactionRatio: ratio(outgoing, outgoingActions)
-  });
-}
-function analyzeContact(messages, corpusRevision, contactId, options = {}) {
-  if (typeof corpusRevision !== "string" || !/^[a-f0-9]{64}$/u.test(corpusRevision)) {
-    throw new Error("corpusRevision must be a lowercase SHA-256 digest");
-  }
-  if (typeof contactId !== "string" || contactId.length < 1 || contactId.length > 256) {
-    throw new Error("contactId must be bounded non-empty text");
-  }
-  const sessionGapSeconds = boundedGap(options.sessionGapSeconds, DEFAULT_SESSION_GAP_SECONDS, "sessionGapSeconds");
-  const burstGapSeconds = boundedGap(options.burstGapSeconds, DEFAULT_BURST_GAP_SECONDS, "burstGapSeconds");
-  if (burstGapSeconds > sessionGapSeconds) {
-    throw new Error("burstGapSeconds cannot exceed sessionGapSeconds");
-  }
-  const ordered = orderedMessages(messages);
-  const byConversation = new Map;
-  for (const row of ordered) {
-    const rows = byConversation.get(row.message.conversationId) ?? [];
-    rows.push(row);
-    byConversation.set(row.message.conversationId, rows);
-  }
-  const sessions = [];
-  const burstRecords = [];
-  const responses = [];
-  for (const conversationId of [...byConversation.keys()].sort((left, right) => left.localeCompare(right, "en-US"))) {
-    const rows = Object.freeze(byConversation.get(conversationId));
-    const conversationSessions = sessionsFor(rows, corpusRevision, contactId, sessionGapSeconds);
-    const conversationBursts = burstsFor(rows, conversationSessions, corpusRevision, contactId, burstGapSeconds);
-    sessions.push(...conversationSessions);
-    burstRecords.push(...conversationBursts);
-    responses.push(...responsesFor(conversationBursts, corpusRevision, contactId));
-  }
-  sessions.sort((left, right) => left.startedAt.localeCompare(right.startedAt, "en-US") || left.id.localeCompare(right.id, "en-US"));
-  burstRecords.sort((left, right) => left.metric.startedAt.localeCompare(right.metric.startedAt, "en-US") || left.metric.id.localeCompare(right.metric.id, "en-US"));
-  responses.sort((left, right) => left.startedAt.localeCompare(right.startedAt, "en-US") || left.id.localeCompare(right.id, "en-US"));
-  return Object.freeze({
-    schemaVersion: METRICS_SCHEMA_VERSION,
-    corpusRevision,
-    contactId,
-    firstMessageAt: ordered[0]?.message.sentAt ?? null,
-    lastMessageAt: ordered.at(-1)?.message.sentAt ?? null,
-    messageCount: ordered.length,
-    incomingCount: ordered.filter(({ message }) => message.direction === "incoming").length,
-    outgoingCount: ordered.filter(({ message }) => message.direction === "outgoing").length,
-    textMessageCount: ordered.filter(({ message }) => message.retractedAt === null && message.kind === "text" && message.body !== null).length,
-    sessionGapSeconds,
-    burstGapSeconds,
-    sessions: Object.freeze(sessions),
-    bursts: Object.freeze(burstRecords.map(({ metric }) => metric)),
-    responses: Object.freeze(responses),
-    tempo: tempoMetrics(ordered, responses),
-    reactions: reactionMetrics(ordered, options.reactionFacts),
-    surface: surfaceMetrics(ordered)
-  });
-}
 function studyMessages(response, byId, maximumTextBytes, maximumMessagesPerDirection) {
   const resolveRows = (ids, expectedDirection) => {
     const rows2 = [];
@@ -753,107 +396,6 @@ function buildStudyPacket(messages, metrics, options = {}) {
     })
   });
 }
-function buildEvaluationPackets(messages, metrics, options) {
-  const limit = options.limit ?? 8;
-  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 25) {
-    throw new Error("evaluation limit must be an integer from 1 through 25");
-  }
-  const maximumTextBytes = boundedStudyInteger(options.maxTextBytesPerMessage, DEFAULT_MAX_STUDY_TEXT_BYTES, MAX_STUDY_TEXT_BYTES, "maxTextBytesPerMessage");
-  const maximumMessagesPerDirection = boundedStudyInteger(options.maxMessagesPerDirectionPerCase, DEFAULT_MAX_STUDY_MESSAGES_PER_DIRECTION, MAX_STUDY_MESSAGES_PER_DIRECTION, "maxMessagesPerDirectionPerCase");
-  const maximumBodyBytes = boundedStudyInteger(options.maxTotalBodyBytes, DEFAULT_MAX_STUDY_PACKET_BODY_BYTES, MAX_STUDY_PACKET_BODY_BYTES, "maxTotalBodyBytes");
-  const generatedAt = options.generatedAt ?? new Date().toISOString();
-  canonicalTimestamp(generatedAt, "generatedAt");
-  const evidenceRevision = options.evidenceRevision ?? metrics.corpusRevision;
-  if (!/^[a-f0-9]{64}$/u.test(evidenceRevision)) {
-    throw new Error("evidenceRevision must be a lowercase SHA-256 digest");
-  }
-  const after = optionalCanonicalTimestamp(options.after, "after");
-  const before = optionalCanonicalTimestamp(options.before, "before");
-  if (after.value === null || after.milliseconds === null)
-    throw new Error("after is required");
-  if (before.milliseconds !== null && after.milliseconds >= before.milliseconds)
-    throw new Error("after must be earlier than before");
-  const afterMilliseconds = after.milliseconds;
-  const beforeMilliseconds = before.milliseconds;
-  const ordered = orderedMessages(messages).filter(({ milliseconds }) => milliseconds >= afterMilliseconds && (beforeMilliseconds === null || milliseconds < beforeMilliseconds));
-  const candidateSet = candidatesFor(ordered, metrics, maximumTextBytes, maximumMessagesPerDirection);
-  const chronological = [...candidateSet.candidates].sort((left, right) => left.milliseconds - right.milliseconds || left.example.id.localeCompare(right.example.id, "en-US"));
-  const selected = [];
-  let emittedBodyBytes = 0;
-  for (const candidate of chronological) {
-    if (selected.length >= limit)
-      break;
-    if (candidate.bodyBytes > maximumBodyBytes - emittedBodyBytes)
-      continue;
-    selected.push(candidate);
-    emittedBodyBytes += candidate.bodyBytes;
-  }
-  const caseIds = selected.map(({ example }) => example.id);
-  const evaluationId = digest("evaluation", [
-    metrics.corpusRevision,
-    evidenceRevision,
-    metrics.contactId,
-    after.value,
-    before.value ?? "",
-    ...caseIds
-  ]);
-  const promptCases = Object.freeze(selected.map(({ example }) => Object.freeze({
-    id: example.id,
-    startedAt: example.startedAt,
-    incoming: Object.freeze(example.messages.filter(({ direction }) => direction === "incoming"))
-  })));
-  const referenceCases = Object.freeze(selected.map(({ example }) => {
-    const outgoing = Object.freeze(example.messages.filter(({ direction }) => direction === "outgoing"));
-    return Object.freeze({
-      id: example.id,
-      startedAt: example.startedAt,
-      outgoing,
-      shape: Object.freeze({
-        bubbles: outgoing.length,
-        characters: outgoing.reduce((total, message) => total + characterCount(message.body), 0),
-        words: outgoing.reduce((total, message) => total + wordCount(message.body), 0),
-        explicitReplyMessages: outgoing.filter(({ explicitReply }) => explicitReply === true).length,
-        explicitReplyEligibleMessages: outgoing.filter(({ explicitReply }) => explicitReply !== null).length,
-        explicitReplyUnavailableMessages: outgoing.filter(({ explicitReply }) => explicitReply === null).length
-      })
-    });
-  }));
-  const promptMessages = promptCases.flatMap(({ incoming }) => incoming);
-  const evidenceWindow = Object.freeze({ after: after.value, before: before.value });
-  const shared = {
-    schemaVersion: EVALUATION_PACKET_SCHEMA_VERSION,
-    evaluationId,
-    generatedAt,
-    corpusRevision: metrics.corpusRevision,
-    evidenceRevision,
-    contactId: metrics.contactId,
-    evidenceWindow
-  };
-  return Object.freeze({
-    prompt: Object.freeze({
-      ...shared,
-      cases: promptCases,
-      selection: Object.freeze({
-        algorithm: "temporal-held-out-responses-v1",
-        requestedLimit: limit,
-        eligibleCandidates: candidateSet.candidates.length,
-        emitted: promptCases.length
-      }),
-      budget: Object.freeze({
-        maxTextBytesPerMessage: maximumTextBytes,
-        maxMessagesPerDirectionPerCase: maximumMessagesPerDirection,
-        maxTotalBodyBytes: maximumBodyBytes,
-        emittedBodyBytes: promptMessages.reduce((total, message) => total + message.emittedBodyBytes, 0),
-        truncatedMessages: promptMessages.filter(({ bodyTruncated }) => bodyTruncated).length
-      })
-    }),
-    reference: Object.freeze({
-      ...shared,
-      cases: referenceCases,
-      notice: "Open only after the candidate drafts for every case are fixed."
-    })
-  });
-}
 
 // src/ensoul-source-v1.ts
 var ENSOUL_SOURCE_PACKET_V1_SCHEMA_IDENTITY = "ensoul.source-packet.v1";
@@ -1075,4 +617,4 @@ function buildEnsoulMessagesSourcePacketV1(messages, metrics, options) {
   });
 }
 
-export { CORPUS_SCHEMA_VERSION, METRICS_SCHEMA_VERSION, PROFILE_SCHEMA_VERSION, LEGACY_PROFILE_SCHEMA_VERSION, STUDY_PACKET_SCHEMA_VERSION, EVALUATION_PACKET_SCHEMA_VERSION, CONTACTS_SCHEMA_VERSION, MESSAGE_BUNDLE_SCHEMA_VERSION, MESSAGE_BUNDLE_SCHEMA_VERSIONS, analyzeContact, buildStudyPacket, buildEvaluationPackets, ENSOUL_SOURCE_PACKET_V1_SCHEMA_IDENTITY, ENSOUL_MESSAGES_SOURCE_V1_ADAPTER_ID, ENSOUL_DIGEST_CANONICALIZATION, DEFAULT_ENSOUL_MESSAGES_EXAMPLE_LIMIT, MAX_ENSOUL_MESSAGES_EXAMPLE_LIMIT, ensoulSubjectMessages, ensoulSubjectReactions, buildEnsoulMessagesSourcePacketV1 };
+export { CORPUS_SCHEMA_VERSION, METRICS_SCHEMA_VERSION, PROFILE_SCHEMA_VERSION, LEGACY_PROFILE_SCHEMA_VERSION, STUDY_PACKET_SCHEMA_VERSION, EVALUATION_PACKET_SCHEMA_VERSION, CONTACTS_SCHEMA_VERSION, MESSAGE_BUNDLE_SCHEMA_VERSION, MESSAGE_BUNDLE_SCHEMA_VERSIONS, ENSOUL_SOURCE_PACKET_V1_SCHEMA_IDENTITY, ENSOUL_MESSAGES_SOURCE_V1_ADAPTER_ID, ENSOUL_DIGEST_CANONICALIZATION, DEFAULT_ENSOUL_MESSAGES_EXAMPLE_LIMIT, MAX_ENSOUL_MESSAGES_EXAMPLE_LIMIT, ensoulSubjectMessages, ensoulSubjectReactions, buildEnsoulMessagesSourcePacketV1 };

package/dist/{cli-ththzwja.js → index-y1aec88m.js}

@@ -12,9 +12,5 @@ function canonicalJson(value) {
 function sha256(value) {
   return createHash("sha256").update(value).digest("hex");
 }
-function prettyJson(value) {
-  return `${JSON.stringify(value, null, 2)}
-`;
-}
 
-export { canonicalJson, sha256, prettyJson };
+export { canonicalJson, sha256 };

package/dist/index.js

@@ -17,13 +17,13 @@ import {
   buildEnsoulMessagesSourcePacketV1,
   ensoulSubjectMessages,
   ensoulSubjectReactions
-} from "./cli-x1qncxm7.js";
-import"./cli-qqafdvz9.js";
-import"./cli-kw20gkk3.js";
+} from "./index-7dfvy41v.js";
+import"./index-qqafdvz9.js";
+import"./index-kw20gkk3.js";
 import {
   canonicalJson,
   sha256
-} from "./cli-ththzwja.js";
+} from "./index-y1aec88m.js";
 export {
   sha256,
   ensoulSubjectReactions,