@zigil/agent-react 0.1.0

package/dist/context-draft.js

@@ -0,0 +1,722 @@
+// src/context-draft.ts
+import { useSyncExternalStore } from "react";
+
+// src/attention.tsx
+import {
+  createContext,
+  createElement,
+  useContext
+} from "react";
+var MAX_SERIALIZED_BYTES = 4 * 1024;
+var MAX_REQUIRED_FIELD_LENGTH = 128;
+var MAX_SELECTIONS = 12;
+var MAX_HISTORY = 40;
+var MAX_FOCUSED_HISTORY = 8;
+var MAX_HOVER_HISTORY = 2;
+var ATTENTION_ACTIVITY_ACTIONS = [
+  "focus",
+  "select",
+  "navigate",
+  "edit",
+  "execute",
+  "approve",
+  "dismiss",
+  "hover"
+];
+var AttentionContextReact = createContext(null);
+var AttentionContextSchema = standardSchema(
+  (value) => {
+    const issues = validateAttentionContext(value);
+    return issues.length > 0 ? issues : value;
+  }
+);
+function serializeAttention(context, privacy = "focused") {
+  const normalized = normalizeAttention(context, privacy);
+  assertClosedAttention(normalized);
+  let serialized = JSON.stringify(normalized);
+  if (byteLength(serialized) <= MAX_SERIALIZED_BYTES) return serialized;
+  warnOversizedAttention();
+  while (normalized.history?.some((event) => event.action === "hover")) {
+    const hoverIndex = normalized.history.findIndex(
+      (event) => event.action === "hover"
+    );
+    normalized.history.splice(hoverIndex, 1);
+    if (normalized.history.length === 0) delete normalized.history;
+    serialized = JSON.stringify(normalized);
+    if (byteLength(serialized) <= MAX_SERIALIZED_BYTES) return serialized;
+  }
+  while ((normalized.history?.length ?? 0) > 0) {
+    normalized.history?.shift();
+    if (normalized.history?.length === 0) delete normalized.history;
+    serialized = JSON.stringify(normalized);
+    if (byteLength(serialized) <= MAX_SERIALIZED_BYTES) return serialized;
+  }
+  delete normalized.hover;
+  serialized = JSON.stringify(normalized);
+  if (byteLength(serialized) <= MAX_SERIALIZED_BYTES) return serialized;
+  removeOptionalSelectionFields(normalized);
+  serialized = JSON.stringify(normalized);
+  if (byteLength(serialized) <= MAX_SERIALIZED_BYTES) return serialized;
+  const required = truncateRequiredFields(normalized);
+  serialized = JSON.stringify(required);
+  while (byteLength(serialized) > MAX_SERIALIZED_BYTES && (required.selections?.length ?? 0) > 0) {
+    required.selections?.pop();
+    if (required.selections?.length === 0) delete required.selections;
+    serialized = JSON.stringify(required);
+  }
+  return serialized;
+}
+function validateAttentionContext(value, path = []) {
+  if (!isRecord(value)) return [issue("Expected attention context", ...path)];
+  const issues = [];
+  if (!hasOnlyKeys(value, [
+    "application",
+    "route",
+    "workspace",
+    "selection",
+    "selections",
+    "hover",
+    "history"
+  ]))
+    issues.push(issue("Unexpected attention field", ...path));
+  if (typeof value.application !== "string")
+    issues.push(issue("Expected a string", ...path, "application"));
+  if (typeof value.route !== "string")
+    issues.push(issue("Expected a string", ...path, "route"));
+  if (value.workspace !== void 0)
+    issues.push(...validateWorkspace(value.workspace, [...path, "workspace"]));
+  if (value.selection !== void 0)
+    issues.push(...validateSelection(value.selection, [...path, "selection"]));
+  if (value.hover !== void 0)
+    issues.push(...validateSelection(value.hover, [...path, "hover"]));
+  if (value.selections !== void 0) {
+    if (!Array.isArray(value.selections))
+      issues.push(issue("Expected selections", ...path, "selections"));
+    else
+      value.selections.forEach(
+        (selection, index) => issues.push(
+          ...validateSelection(selection, [...path, "selections", index])
+        )
+      );
+  }
+  if (value.history !== void 0) {
+    if (!Array.isArray(value.history))
+      issues.push(issue("Expected activity history", ...path, "history"));
+    else
+      value.history.forEach(
+        (event, index) => issues.push(...validateActivity(event, [...path, "history", index]))
+      );
+  }
+  return issues;
+}
+function normalizeAttention(context, privacy) {
+  const workspace = context.workspace ? {
+    kind: context.workspace.kind,
+    id: context.workspace.id,
+    ...context.workspace.revision === void 0 ? {} : { revision: context.workspace.revision },
+    ...privacy === "minimal" || context.workspace.label === void 0 ? {} : { label: context.workspace.label }
+  } : void 0;
+  const primary = context.selection ? normalizeSelection(context.selection, privacy !== "minimal") : void 0;
+  if (privacy === "minimal") {
+    return {
+      application: context.application,
+      route: context.route,
+      ...workspace ? { workspace } : {},
+      ...primary ? { selection: primary } : {}
+    };
+  }
+  const selections = normalizeSelections(context.selections, primary);
+  const history = normalizeHistory(
+    context.history,
+    privacy === "focused" ? MAX_FOCUSED_HISTORY : MAX_HISTORY,
+    privacy === "expanded"
+  );
+  return {
+    application: context.application,
+    route: context.route,
+    ...workspace ? { workspace } : {},
+    ...primary ? { selection: primary } : {},
+    ...selections.length > 0 ? { selections } : {},
+    ...privacy === "expanded" && context.hover ? { hover: normalizeSelection(context.hover, true) } : {},
+    ...history.length > 0 ? { history } : {}
+  };
+}
+function normalizeSelections(selections, primary) {
+  const ordered = primary ? [
+    primary,
+    ...(selections ?? []).map((item) => normalizeSelection(item, true))
+  ] : (selections ?? []).map((item) => normalizeSelection(item, true));
+  const seen = /* @__PURE__ */ new Set();
+  return ordered.filter((item) => {
+    const key = selectionKey(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).slice(0, MAX_SELECTIONS);
+}
+function normalizeHistory(history, limit, includeHover) {
+  const semantic = [];
+  const hovers = [];
+  for (const event of history ?? []) {
+    const normalized = normalizeEvent(event);
+    if (normalized.action !== "hover") semantic.push(normalized);
+    else if (includeHover) {
+      const previous = hovers.at(-1);
+      if (previous && selectionKey(previous.target) === selectionKey(normalized.target))
+        hovers[hovers.length - 1] = normalized;
+      else hovers.push(normalized);
+    }
+  }
+  const retainedSemantic = semantic.slice(-limit);
+  const remaining = Math.max(0, limit - retainedSemantic.length);
+  const hoverLimit = Math.min(MAX_HOVER_HISTORY, remaining);
+  const retainedHover = hoverLimit > 0 ? hovers.slice(-hoverLimit) : [];
+  return [...retainedSemantic, ...retainedHover].sort(
+    (left, right) => left.timestamp - right.timestamp
+  );
+}
+function normalizeEvent(event) {
+  return {
+    action: event.action,
+    target: normalizeSelection(event.target, true),
+    timestamp: event.timestamp,
+    ...event.summary === void 0 ? {} : { summary: event.summary },
+    ...event.detail === void 0 ? {} : { detail: sortRecord(event.detail) }
+  };
+}
+function normalizeSelection(selection, includeOptional) {
+  return {
+    kind: selection.kind,
+    id: selection.id,
+    ...includeOptional && selection.label !== void 0 ? { label: selection.label } : {},
+    ...includeOptional && selection.detail !== void 0 ? { detail: sortRecord(selection.detail) } : {}
+  };
+}
+function removeOptionalSelectionFields(context) {
+  const selections = [
+    context.selection,
+    ...context.selections ?? [],
+    context.hover
+  ].filter((selection) => Boolean(selection));
+  for (const selection of selections.reverse()) {
+    for (const key of Object.keys(selection.detail ?? {}).reverse()) {
+      if (!selection.detail) break;
+      delete selection.detail[key];
+      if (Object.keys(selection.detail).length === 0) delete selection.detail;
+    }
+    delete selection.label;
+  }
+  if (context.workspace) delete context.workspace.label;
+}
+function truncateRequiredFields(context) {
+  return {
+    application: truncateText(context.application),
+    route: truncateText(context.route),
+    ...context.workspace ? {
+      workspace: {
+        kind: truncateText(context.workspace.kind),
+        id: truncateText(context.workspace.id),
+        ...context.workspace.revision === void 0 ? {} : { revision: context.workspace.revision }
+      }
+    } : {},
+    ...context.selection ? {
+      selection: {
+        kind: truncateText(context.selection.kind),
+        id: truncateText(context.selection.id)
+      }
+    } : {},
+    ...context.selections ? {
+      selections: context.selections.slice(0, MAX_SELECTIONS).map((item) => ({
+        kind: truncateText(item.kind),
+        id: truncateText(item.id)
+      }))
+    } : {}
+  };
+}
+function validateWorkspace(value, path) {
+  if (!isRecord(value)) return [issue("Expected a workspace", ...path)];
+  const issues = [];
+  if (!hasOnlyKeys(value, ["kind", "id", "label", "revision"]))
+    issues.push(issue("Unexpected workspace field", ...path));
+  for (const key of ["kind", "id"])
+    if (typeof value[key] !== "string")
+      issues.push(issue("Expected a string", ...path, key));
+  if (value.label !== void 0 && typeof value.label !== "string")
+    issues.push(issue("Expected a string", ...path, "label"));
+  if (value.revision !== void 0 && (typeof value.revision !== "number" || !Number.isFinite(value.revision)))
+    issues.push(issue("Expected a finite revision", ...path, "revision"));
+  return issues;
+}
+function validateSelection(value, path) {
+  if (!isRecord(value)) return [issue("Expected a selection", ...path)];
+  const issues = [];
+  if (!hasOnlyKeys(value, ["kind", "id", "label", "detail"]))
+    issues.push(issue("Unexpected selection field", ...path));
+  for (const key of ["kind", "id"])
+    if (typeof value[key] !== "string")
+      issues.push(issue("Expected a string", ...path, key));
+  if (value.label !== void 0 && typeof value.label !== "string")
+    issues.push(issue("Expected a string", ...path, "label"));
+  issues.push(...validateStringRecord(value.detail, [...path, "detail"]));
+  return issues;
+}
+function validateActivity(value, path) {
+  if (!isRecord(value)) return [issue("Expected activity", ...path)];
+  const issues = [];
+  if (!hasOnlyKeys(value, ["action", "target", "timestamp", "summary", "detail"]))
+    issues.push(issue("Unexpected activity field", ...path));
+  if (typeof value.action !== "string" || !ATTENTION_ACTIVITY_ACTIONS.includes(
+    value.action
+  ))
+    issues.push(issue("Expected an action", ...path, "action"));
+  if (typeof value.timestamp !== "number" || !Number.isFinite(value.timestamp))
+    issues.push(issue("Expected a finite timestamp", ...path, "timestamp"));
+  if (value.summary !== void 0 && typeof value.summary !== "string")
+    issues.push(issue("Expected a string", ...path, "summary"));
+  issues.push(...validateSelection(value.target, [...path, "target"]));
+  issues.push(...validateStringRecord(value.detail, [...path, "detail"]));
+  return issues;
+}
+function validateStringRecord(value, path) {
+  if (value === void 0) return [];
+  if (!isRecord(value) || !Object.values(value).every((item) => typeof item === "string"))
+    return [issue("Expected string details", ...path)];
+  return [];
+}
+function assertClosedAttention(value) {
+  const issues = validateAttentionContext(value);
+  if (issues.length > 0)
+    throw new Error(`Invalid attention serialization: ${issues[0]?.message}`);
+}
+function standardSchema(validate) {
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "sigil-agent",
+      validate(value) {
+        const result = validate(value);
+        return Array.isArray(result) ? { issues: result } : { value: result };
+      }
+    }
+  };
+}
+function issue(message, ...path) {
+  return { message, path };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, allowed) {
+  const keys = new Set(allowed);
+  return Object.keys(value).every((key) => keys.has(key));
+}
+function sortRecord(record) {
+  return Object.fromEntries(
+    Object.entries(record).sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+function selectionKey(selection) {
+  return `${selection.kind}\0${selection.id}`;
+}
+function truncateText(value) {
+  return value.length <= MAX_REQUIRED_FIELD_LENGTH ? value : `${value.slice(0, MAX_REQUIRED_FIELD_LENGTH - 1)}\u2026`;
+}
+function byteLength(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function warnOversizedAttention() {
+  const isDevelopment = import.meta.env?.DEV === true;
+  if (isDevelopment)
+    console.warn(
+      "Agent attention exceeded 4 KB; optional context was removed before sending."
+    );
+}
+
+// src/context-draft.ts
+var listeners = /* @__PURE__ */ new Set();
+var drafts = /* @__PURE__ */ new Map();
+var activeDraftScope = "default";
+var MAX_ATTACHMENTS = 6;
+var MAX_ATTACHMENT_TEXT_LENGTH = 192;
+var MAX_CONTEXT_DRAFT_BYTES = 8 * 1024;
+var ContextAttachmentSchema = standardSchema2(
+  (value) => {
+    const issues = validateAttachment(value);
+    return issues.length > 0 ? issues : value;
+  }
+);
+var ContextDraftPayloadSchema = standardSchema2(
+  (value) => {
+    const issues = validateDraftPayload(value);
+    return issues.length > 0 ? issues : value;
+  }
+);
+function attentionSelectionKey(selection) {
+  return `selection:${selection.kind}:${selection.id}`;
+}
+function attentionHistoryKey(event) {
+  return `history:${event.timestamp}:${event.action}:${event.target.kind}:${event.target.id}`;
+}
+function getContextDraftScope() {
+  return activeDraftScope;
+}
+function getAttentionExclusions() {
+  return getDraftState().exclusions;
+}
+function getTurnContextAttachments() {
+  return getDraftState().attachments;
+}
+function setContextDraftScope(scopeId) {
+  const normalized = scopeId.trim();
+  if (!normalized) throw new Error("Context draft scope must be non-empty");
+  if (activeDraftScope === normalized) return;
+  activeDraftScope = normalized;
+  getDraftState();
+  emitChange();
+}
+function addContextAttachment(attachment) {
+  const validated = validateAttachment(attachment);
+  if (validated.length > 0)
+    throw new Error(`Invalid context attachment: ${validated[0]?.message}`);
+  const normalized = normalizeAttachment(attachment, "expanded");
+  const state = getDraftState();
+  state.attachments = [
+    ...state.attachments.filter((item) => item.id !== normalized.id),
+    normalized
+  ].slice(-MAX_ATTACHMENTS);
+  emitChange();
+}
+function addTurnContextAttachment(selection, retention = "turn") {
+  addContextAttachment({
+    id: attentionSelectionKey(selection),
+    source: "application-selection",
+    inclusion: "user-added",
+    resource: { kind: selection.kind, id: selection.id },
+    label: truncateAttachmentText(selection.label ?? selection.id),
+    ...selection.detail ? {
+      summary: truncateAttachmentText(
+        Object.entries(selection.detail).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}: ${value}`).join(" \xB7 ")
+      )
+    } : {},
+    retention
+  });
+}
+function removeTurnContextAttachment(id) {
+  const state = getDraftState();
+  const next = state.attachments.filter((item) => item.id !== id);
+  if (next.length === state.attachments.length) return;
+  state.attachments = next;
+  emitChange();
+}
+function moveTurnContextAttachment(id, direction) {
+  const state = getDraftState();
+  const index = state.attachments.findIndex((item) => item.id === id);
+  const target = index + direction;
+  if (index < 0 || target < 0 || target >= state.attachments.length) return;
+  const next = [...state.attachments];
+  [next[index], next[target]] = [next[target], next[index]];
+  state.attachments = next;
+  emitChange();
+}
+function setTurnContextAttachmentRetention(id, retention) {
+  let changed = false;
+  const state = getDraftState();
+  state.attachments = state.attachments.map((item) => {
+    if (item.id !== id || item.retention === retention) return item;
+    changed = true;
+    return { ...item, retention };
+  });
+  if (changed) emitChange();
+}
+function clearTurnContextAttachments() {
+  const state = getDraftState();
+  const next = state.attachments.filter((item) => item.retention === "session");
+  if (next.length === state.attachments.length) return;
+  state.attachments = next;
+  emitChange();
+}
+function clearContextDraft() {
+  const state = getDraftState();
+  if (state.exclusions.length === 0 && state.attachments.length === 0) return;
+  state.exclusions = [];
+  state.attachments = [];
+  emitChange();
+}
+function resetContextDraftForTests() {
+  drafts.clear();
+  activeDraftScope = "default";
+  emitChange();
+}
+function setAttentionItemExcluded(key, excluded) {
+  const state = getDraftState();
+  const next = new Set(state.exclusions);
+  if (excluded) next.add(key);
+  else next.delete(key);
+  state.exclusions = [...next].sort();
+  emitChange();
+}
+function clearAttentionExclusions() {
+  const state = getDraftState();
+  if (state.exclusions.length === 0) return;
+  state.exclusions = [];
+  emitChange();
+}
+function useAttentionExclusions() {
+  return useSyncExternalStore(
+    subscribeContextDraft,
+    getAttentionExclusions,
+    getAttentionExclusions
+  );
+}
+function useTurnContextAttachments() {
+  return useSyncExternalStore(
+    subscribeContextDraft,
+    getTurnContextAttachments,
+    getTurnContextAttachments
+  );
+}
+function serializeAttentionDraft(context, privacy, excludedKeys = getAttentionExclusions(), contextAttachments = getTurnContextAttachments()) {
+  const attention = context ? JSON.parse(
+    serializeAttention(
+      applyAttentionExclusions(context, excludedKeys),
+      privacy
+    )
+  ) : {};
+  const normalizedAttachments = contextAttachments.slice(0, MAX_ATTACHMENTS).map((attachment) => normalizeAttachment(attachment, privacy));
+  const serialized = fitContextPayload(attention, normalizedAttachments);
+  const parsed = JSON.parse(serialized);
+  const issues = validateDraftPayload(parsed);
+  if (issues.length > 0)
+    throw new Error(
+      `Invalid context draft serialization: ${issues[0]?.message}`
+    );
+  return serialized;
+}
+function createAttentionContextPreview(context, privacy, excludedKeys = getAttentionExclusions(), contextAttachments = getTurnContextAttachments()) {
+  const serialized = serializeAttentionDraft(
+    context,
+    privacy,
+    excludedKeys,
+    contextAttachments
+  );
+  const normalized = JSON.parse(serialized);
+  const selections = normalized.selections?.length ? normalized.selections : normalized.selection ? [normalized.selection] : [];
+  const history = normalized.history ?? [];
+  const normalizedAttachments = normalized.attachments ?? [];
+  const truncatedAttachmentCount = Math.max(
+    0,
+    contextAttachments.length - normalizedAttachments.length
+  );
+  const byteLength3 = new TextEncoder().encode(serialized).byteLength;
+  const parts = [
+    `${selections.length} selection${selections.length === 1 ? "" : "s"}`,
+    `${normalizedAttachments.length} attachment${normalizedAttachments.length === 1 ? "" : "s"}`,
+    `${history.length} recent action${history.length === 1 ? "" : "s"}`
+  ];
+  return {
+    attachmentCount: normalizedAttachments.length,
+    attachments: normalizedAttachments,
+    byteLength: byteLength3,
+    estimatedTokens: Math.ceil(byteLength3 / 4),
+    formatted: JSON.stringify(normalized, null, 2),
+    history,
+    selectionCount: selections.length,
+    selections,
+    serialized,
+    summary: parts.join(" \xB7 "),
+    truncatedAttachmentCount
+  };
+}
+function applyAttentionExclusions(context, excludedKeys) {
+  if (excludedKeys.length === 0) return context;
+  const excluded = new Set(excludedKeys);
+  const selectionCandidates = deduplicateSelections([
+    ...context.selection ? [context.selection] : [],
+    ...context.selections ?? []
+  ]);
+  const selections = selectionCandidates.filter(
+    (selection) => !excluded.has(attentionSelectionKey(selection))
+  );
+  const excludedTargets = new Set(
+    selectionCandidates.filter((selection) => excluded.has(attentionSelectionKey(selection))).map((selection) => `${selection.kind}\0${selection.id}`)
+  );
+  const history = (context.history ?? []).filter(
+    (event) => !excluded.has(attentionHistoryKey(event)) && !excludedTargets.has(`${event.target.kind}\0${event.target.id}`)
+  );
+  const hover = context.hover && !excluded.has(attentionSelectionKey(context.hover)) && !excludedTargets.has(`${context.hover.kind}\0${context.hover.id}`) ? context.hover : void 0;
+  return {
+    ...context,
+    selection: selections[0],
+    selections: selections.length > 0 ? selections : void 0,
+    history: history.length > 0 ? history : void 0,
+    hover
+  };
+}
+function deduplicateSelections(selections) {
+  const seen = /* @__PURE__ */ new Set();
+  return selections.filter((selection) => {
+    const key = `${selection.kind}\0${selection.id}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function subscribeContextDraft(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function emitChange() {
+  listeners.forEach((listener) => listener());
+}
+function getDraftState() {
+  let state = drafts.get(activeDraftScope);
+  if (!state) {
+    state = { attachments: [], exclusions: [] };
+    drafts.set(activeDraftScope, state);
+  }
+  return state;
+}
+function normalizeAttachment(attachment, privacy) {
+  return {
+    id: truncateAttachmentText(attachment.id),
+    source: attachment.source,
+    inclusion: attachment.inclusion,
+    resource: {
+      kind: truncateAttachmentText(attachment.resource.kind),
+      id: truncateAttachmentText(attachment.resource.id)
+    },
+    label: privacy === "minimal" ? truncateAttachmentText(attachment.resource.id) : truncateAttachmentText(attachment.label),
+    ...privacy === "minimal" || attachment.summary === void 0 ? {} : { summary: truncateAttachmentText(attachment.summary) },
+    retention: attachment.retention
+  };
+}
+function fitContextPayload(attention, contextAttachments) {
+  const included = contextAttachments.map((attachment) => ({ ...attachment }));
+  let serialized = serializeContextPayload(attention, included);
+  if (byteLength2(serialized) <= MAX_CONTEXT_DRAFT_BYTES) return serialized;
+  for (let index = included.length - 1; index >= 0; index -= 1) {
+    if (included[index]?.summary === void 0) continue;
+    delete included[index].summary;
+    serialized = serializeContextPayload(attention, included);
+    if (byteLength2(serialized) <= MAX_CONTEXT_DRAFT_BYTES) return serialized;
+  }
+  while (included.length > 0) {
+    included.pop();
+    serialized = serializeContextPayload(attention, included);
+    if (byteLength2(serialized) <= MAX_CONTEXT_DRAFT_BYTES) return serialized;
+  }
+  return serialized;
+}
+function serializeContextPayload(attention, included) {
+  return JSON.stringify({
+    ...attention,
+    ...included.length > 0 ? { attachments: included } : {}
+  });
+}
+function validateDraftPayload(value) {
+  if (!isRecord2(value)) return [issue2("Expected a context draft payload")];
+  const { attachments, ...attention } = value;
+  const issues = [];
+  if (Object.keys(attention).length > 0)
+    issues.push(...validateAttentionContext(attention));
+  if (attachments !== void 0) {
+    if (!Array.isArray(attachments))
+      issues.push(issue2("Expected attachments", "attachments"));
+    else
+      attachments.forEach(
+        (attachment, index) => issues.push(...validateAttachment(attachment, ["attachments", index]))
+      );
+  }
+  return issues;
+}
+function validateAttachment(value, path = []) {
+  if (!isRecord2(value)) return [issue2("Expected an attachment", ...path)];
+  const issues = [];
+  if (!hasOnlyKeys2(value, [
+    "id",
+    "source",
+    "inclusion",
+    "resource",
+    "label",
+    "summary",
+    "retention"
+  ]))
+    issues.push(issue2("Unexpected attachment field", ...path));
+  for (const key of ["id", "label"])
+    if (typeof value[key] !== "string")
+      issues.push(issue2("Expected a string", ...path, key));
+  if (value.summary !== void 0 && typeof value.summary !== "string")
+    issues.push(issue2("Expected a string", ...path, "summary"));
+  if (value.source !== "application-selection" && value.source !== "semantic-fork" && value.source !== "agent-requested")
+    issues.push(issue2("Expected a supported source", ...path, "source"));
+  if (value.inclusion !== "user-added" && value.inclusion !== "automatic" && value.inclusion !== "agent-requested")
+    issues.push(issue2("Expected a supported inclusion", ...path, "inclusion"));
+  if (value.retention !== "turn" && value.retention !== "session")
+    issues.push(
+      issue2("Expected turn or session retention", ...path, "retention")
+    );
+  if (!isRecord2(value.resource))
+    issues.push(issue2("Expected a resource", ...path, "resource"));
+  else {
+    if (!hasOnlyKeys2(value.resource, ["kind", "id"]))
+      issues.push(issue2("Unexpected resource field", ...path, "resource"));
+    for (const key of ["kind", "id"])
+      if (typeof value.resource[key] !== "string")
+        issues.push(issue2("Expected a string", ...path, "resource", key));
+  }
+  return issues;
+}
+function standardSchema2(validate) {
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "sigil-agent",
+      validate(value) {
+        const result = validate(value);
+        return Array.isArray(result) ? { issues: result } : { value: result };
+      }
+    }
+  };
+}
+function issue2(message, ...path) {
+  return { message, path };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys2(value, allowed) {
+  const keys = new Set(allowed);
+  return Object.keys(value).every((key) => keys.has(key));
+}
+function truncateAttachmentText(value) {
+  return value.length <= MAX_ATTACHMENT_TEXT_LENGTH ? value : `${value.slice(0, MAX_ATTACHMENT_TEXT_LENGTH - 1)}\u2026`;
+}
+function byteLength2(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+export {
+  ContextAttachmentSchema,
+  ContextDraftPayloadSchema,
+  addContextAttachment,
+  addTurnContextAttachment,
+  applyAttentionExclusions,
+  attentionHistoryKey,
+  attentionSelectionKey,
+  clearAttentionExclusions,
+  clearContextDraft,
+  clearTurnContextAttachments,
+  createAttentionContextPreview,
+  getAttentionExclusions,
+  getContextDraftScope,
+  getTurnContextAttachments,
+  moveTurnContextAttachment,
+  removeTurnContextAttachment,
+  resetContextDraftForTests,
+  serializeAttentionDraft,
+  setAttentionItemExcluded,
+  setContextDraftScope,
+  setTurnContextAttachmentRetention,
+  useAttentionExclusions,
+  useTurnContextAttachments
+};
+//# sourceMappingURL=context-draft.js.map