@remnic/core 9.65.7 → 9.66.0

package/dist/{chunk-VKCAHCBI.js → chunk-L4X4PJYK.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-7T4TOGMS.js";
 import {
   defineOperation
-} from "./chunk-RQE4TITU.js";
+} from "./chunk-IHGMRDEE.js";
 
 // src/external-wiki-access.ts
 import { z } from "zod";
@@ -26,4 +26,4 @@ var externalWikiSearchOperation = defineOperation({
 export {
   externalWikiSearchOperation
 };
-//# sourceMappingURL=chunk-VKCAHCBI.js.map
+//# sourceMappingURL=chunk-L4X4PJYK.js.map

package/dist/chunk-LB7WCZHY.js

@@ -0,0 +1,553 @@
+import {
+  evaluateActiveContextTransformPolicy
+} from "./chunk-MI2OTWV5.js";
+import {
+  ContextSummaryUnavailableError,
+  summarizeContextPure
+} from "./chunk-43HUVDTD.js";
+import {
+  DEFAULT_ACTIVE_CONTEXT_CAPS
+} from "./chunk-B32WYRXX.js";
+
+// src/active-context-transform.ts
+import { createHash } from "crypto";
+var ACTIVE_CONTEXT_ALGORITHM_VERSION = "active-context-transform/1";
+var ACTIVE_CONTEXT_SNAPSHOT_SCHEMA_VERSION = 1;
+var ACTIVE_CONTEXT_PLAN_SCHEMA_VERSION = 1;
+var ACTIVE_CONTEXT_RECEIPT_SCHEMA_VERSION = 1;
+var ACTIVE_CONTEXT_RECORD_SCHEMA_VERSION = 1;
+var PROTECTED_ROLES = { system: true, developer: true };
+function sha256Hex(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`);
+  return `{${entries.join(",")}}`;
+}
+function hashSnapshot(snapshot) {
+  return sha256Hex(
+    canonicalJson({
+      namespace: snapshot.namespace,
+      revision: snapshot.revision,
+      sessionKey: snapshot.sessionKey,
+      messages: snapshot.messages.map((m) => ({
+        contentHash: sha256Hex(m.content),
+        id: m.id,
+        ordinal: m.ordinal,
+        role: m.role
+      }))
+    })
+  );
+}
+var VALID_PHASES = { plan: true, prepare: true };
+var VALID_ROLES = {
+  system: true,
+  developer: true,
+  user: true,
+  assistant: true,
+  tool: true
+};
+function rejectedPlan(operation, errorCode, context, policy) {
+  const planId = `actx-rejected-${sha256Hex(`${operation}:${errorCode}:${policy.rationale}`).slice(0, 12)}`;
+  return {
+    schemaVersion: ACTIVE_CONTEXT_PLAN_SCHEMA_VERSION,
+    planId,
+    planHash: sha256Hex(canonicalJson({ planId, errorCode, operation })),
+    operation,
+    status: "rejected",
+    errorCode,
+    precondition: context ? {
+      principal: context.scope.principal,
+      sessionKey: context.scope.sessionKey,
+      namespace: context.scope.namespace,
+      adapterId: context.scope.adapterId,
+      snapshotRevision: context.snapshotRevision,
+      expiresAt: context.expiresAt
+    } : {
+      principal: "",
+      sessionKey: "",
+      namespace: "",
+      adapterId: "",
+      snapshotRevision: "",
+      expiresAt: ""
+    },
+    selectedMessageIds: [],
+    retainedMessageIds: [],
+    proposedRemovalIds: [],
+    preserve: { protectedMessageIds: [], minimumRetainedMessages: 0 },
+    inverse: { kind: "restore-source-message-ids", sourceMessageIds: [] },
+    retention: {
+      planId,
+      mode: "adapter-local",
+      expiresAt: "",
+      maxBytes: 0,
+      snapshotContentHash: context?.snapshotContentHash ?? ""
+    },
+    provenance: {
+      algorithmVersion: ACTIVE_CONTEXT_ALGORITHM_VERSION,
+      selectorHash: "",
+      snapshotContentHash: context?.snapshotContentHash ?? "",
+      generatedAt: context?.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    },
+    policy
+  };
+}
+var PlanReject = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+  code;
+};
+function buildContext(request, deps) {
+  const caps = deps.caps ?? {
+    ...DEFAULT_ACTIVE_CONTEXT_CAPS,
+    activeContextTransforms: true,
+    activeContextLlm: false
+  };
+  const scope = deps.resolvedScope;
+  if (!scope || !scope.sessionKey || !scope.namespace || !scope.principal || !scope.adapterId) {
+    throw new PlanReject("scope_mismatch");
+  }
+  if (request.snapshot.sessionKey !== scope.sessionKey) throw new PlanReject("scope_mismatch");
+  if (request.snapshot.namespace !== scope.namespace) throw new PlanReject("scope_mismatch");
+  const snapshot = request.snapshot;
+  if (snapshot.schemaVersion !== ACTIVE_CONTEXT_SNAPSHOT_SCHEMA_VERSION) {
+    throw new PlanReject("invalid_request");
+  }
+  if (!Array.isArray(snapshot.messages) || snapshot.messages.length === 0) {
+    throw new PlanReject("invalid_request");
+  }
+  const byId = /* @__PURE__ */ new Map();
+  let totalChars = 0;
+  for (const message of snapshot.messages) {
+    if (typeof message?.id !== "string" || message.id.length === 0 || typeof message.content !== "string" || VALID_ROLES[message.role] !== true) {
+      throw new PlanReject("invalid_request");
+    }
+    if (byId.has(message.id)) throw new PlanReject("invalid_request");
+    byId.set(message.id, message);
+    totalChars += message.content.length;
+  }
+  if (snapshot.messages.length > caps.activeContextMaxMessages) throw new PlanReject("invalid_request");
+  if (totalChars > caps.activeContextMaxSnapshotChars) throw new PlanReject("invalid_request");
+  const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+  const generatedAt = now.toISOString();
+  const expiresAt = new Date(now.getTime() + caps.activeContextPlanTtlMinutes * 6e4).toISOString();
+  return {
+    caps,
+    scope,
+    snapshotRevision: snapshot.revision,
+    byId,
+    ordered: [...snapshot.messages].sort((a, b) => a.ordinal - b.ordinal || a.id.localeCompare(b.id)),
+    snapshotContentHash: hashSnapshot(snapshot),
+    generatedAt,
+    expiresAt
+  };
+}
+function resolveSelection(request, context) {
+  const messageIds = request.selector?.messageIds;
+  const span = request.selector?.span;
+  const hasIds = Array.isArray(messageIds) && messageIds.length > 0;
+  if (hasIds === (span !== void 0)) throw new PlanReject("invalid_request");
+  if (hasIds && messageIds) {
+    const seen = /* @__PURE__ */ new Set();
+    const picked = [];
+    for (const id of messageIds) {
+      if (seen.has(id)) throw new PlanReject("invalid_request");
+      seen.add(id);
+      const message = context.byId.get(id);
+      if (!message) throw new PlanReject("invalid_request");
+      picked.push(message);
+    }
+    return picked.sort((a, b) => a.ordinal - b.ordinal || a.id.localeCompare(b.id));
+  }
+  if (!span) throw new PlanReject("invalid_request");
+  const { startMessageId, endMessageId } = span;
+  const start = context.byId.get(startMessageId);
+  const end = context.byId.get(endMessageId);
+  if (!start || !end) throw new PlanReject("invalid_request");
+  if (start.ordinal > end.ordinal) throw new PlanReject("invalid_request");
+  const inSpan = context.ordered.filter(
+    (m) => m.ordinal >= start.ordinal && m.ordinal <= end.ordinal
+    // closed and full
+  );
+  if (inSpan.length === 0) throw new PlanReject("invalid_request");
+  return inSpan;
+}
+function protectedIdSet(request, context) {
+  const protectedIds = /* @__PURE__ */ new Set();
+  for (const message of context.ordered) {
+    if (PROTECTED_ROLES[message.role] === true || message.protected === true) {
+      protectedIds.add(message.id);
+    }
+  }
+  for (const role of request.preserve?.roles ?? []) {
+    if (PROTECTED_ROLES[role] === true) continue;
+    for (const message of context.ordered) {
+      if (message.role === role) protectedIds.add(message.id);
+    }
+  }
+  for (const id of request.preserve?.messageIds ?? []) {
+    if (context.byId.has(id)) protectedIds.add(id);
+  }
+  return protectedIds;
+}
+function planActiveContextTransform(request, deps) {
+  const caps = deps.caps ?? { ...DEFAULT_ACTIVE_CONTEXT_CAPS, activeContextTransforms: true, activeContextLlm: false };
+  const policy = evaluateActiveContextTransformPolicy({
+    actionsEnabled: deps.actionsEnabled ?? caps.activeContextTransforms,
+    operation: request.operation
+  });
+  if (policy.decision === "deny") {
+    return rejectedPlan(request.operation, "feature_disabled", null, policy);
+  }
+  let context = null;
+  try {
+    if (request.schemaVersion !== ACTIVE_CONTEXT_SNAPSHOT_SCHEMA_VERSION) {
+      throw new PlanReject("invalid_request");
+    }
+    if (request.operation !== "SUMMARY" && request.operation !== "FILTER") {
+      throw new PlanReject("invalid_request");
+    }
+    if (VALID_PHASES[request.phase] !== true) throw new PlanReject("invalid_request");
+    context = buildContext(request, deps);
+    if (request.expectedRevision !== void 0 && request.expectedRevision !== request.snapshot.revision) {
+      throw new PlanReject("stale_context");
+    }
+    const selected = resolveSelection(request, context);
+    const protectedIds = protectedIdSet(request, context);
+    const removable = selected.filter((m) => !protectedIds.has(m.id));
+    if (removable.length === 0) {
+      throw new PlanReject("preserve_conflict");
+    }
+    const minimumRetained = Math.max(
+      1,
+      request.preserve?.minRetainedMessages ?? caps.activeContextMinRetainedMessages
+    );
+    const idList = (messages) => messages.map((m) => m.id);
+    const allIds = idList(context.ordered);
+    const selectorHash = sha256Hex(canonicalJson(request.selector ?? {}));
+    if (request.operation === "FILTER") {
+      return buildFilterPlan(request, deps, context, {
+        selected,
+        removable,
+        protectedIds,
+        minimumRetained,
+        allIds,
+        selectorHash,
+        policy
+      });
+    }
+    return buildSummaryPlan(request, deps, context, {
+      selected,
+      removable,
+      protectedIds,
+      minimumRetained,
+      allIds,
+      selectorHash,
+      policy
+    });
+  } catch (err) {
+    if (err instanceof PlanReject) {
+      return rejectedPlan(request.operation, err.code, context, policy);
+    }
+    throw err;
+  }
+}
+function finalizePlan(operation, context, bundle, proposedRemovalIds, extras) {
+  const retainedIds = bundle.allIds.filter((id) => !proposedRemovalIds.includes(id));
+  if (retainedIds.length < bundle.minimumRetained) {
+    throw new PlanReject("preserve_conflict");
+  }
+  const sourceMessageIds = bundle.removable.map((m) => m.id);
+  const precondition = {
+    principal: context.scope.principal,
+    sessionKey: context.scope.sessionKey,
+    namespace: context.scope.namespace,
+    adapterId: context.scope.adapterId,
+    snapshotRevision: context.snapshotRevision,
+    expiresAt: context.expiresAt
+  };
+  const provenance = {
+    algorithmVersion: ACTIVE_CONTEXT_ALGORITHM_VERSION,
+    selectorHash: bundle.selectorHash,
+    snapshotContentHash: context.snapshotContentHash,
+    ...extras.criterionHash ? { criterionHash: extras.criterionHash } : {},
+    ...extras.sourcePromptHash ? { sourcePromptHash: extras.sourcePromptHash } : {},
+    generatedAt: context.generatedAt
+  };
+  const planId = `actx-${sha256Hex(
+    canonicalJson({
+      adapterId: precondition.adapterId,
+      criterionHash: extras.criterionHash,
+      namespace: precondition.namespace,
+      operation,
+      principal: precondition.principal,
+      selectorHash: bundle.selectorHash,
+      sessionKey: precondition.sessionKey,
+      snapshotContentHash: context.snapshotContentHash
+    })
+  ).slice(0, 16)}`;
+  const planBody = {
+    operation,
+    planId,
+    precondition,
+    proposedRemovalIds,
+    replacementMessageId: extras.replacement?.messageId,
+    replacementSourceIds: extras.replacement?.sourceMessageIds,
+    retainedIds,
+    selectedIds: bundle.selected.map((m) => m.id)
+  };
+  const planHash = sha256Hex(canonicalJson(planBody));
+  return {
+    schemaVersion: ACTIVE_CONTEXT_PLAN_SCHEMA_VERSION,
+    planId,
+    planHash,
+    operation,
+    status: "ready",
+    precondition,
+    selectedMessageIds: planBody.selectedIds,
+    retainedMessageIds: retainedIds,
+    proposedRemovalIds,
+    ...extras.scoreRows ? { scoreRows: extras.scoreRows } : {},
+    ...extras.replacement ? { replacement: extras.replacement } : {},
+    preserve: {
+      protectedMessageIds: [...bundle.protectedIds],
+      minimumRetainedMessages: bundle.minimumRetained
+    },
+    inverse: {
+      kind: "restore-source-message-ids",
+      sourceMessageIds,
+      ...extras.replacement ? { removeReplacementMessageId: extras.replacement.messageId } : {},
+      expectedAppliedPlanHash: planHash
+    },
+    retention: {
+      planId,
+      mode: "adapter-local",
+      expiresAt: context.expiresAt,
+      maxBytes: context.caps.activeContextRetentionMaxBytes,
+      snapshotContentHash: context.snapshotContentHash
+    },
+    provenance,
+    policy: bundle.policy
+  };
+}
+function buildFilterPlan(request, deps, context, bundle) {
+  const filter = request.filter;
+  if (!filter || typeof filter.keepCriterion !== "string" || filter.keepCriterion.length === 0) {
+    throw new PlanReject("invalid_request");
+  }
+  const threshold = filter.threshold;
+  if (typeof threshold !== "number" || !Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
+    throw new PlanReject("invalid_request");
+  }
+  if (!deps.scoreMessage) {
+    throw new PlanReject("filter_unavailable");
+  }
+  const scoreRows = [];
+  const removalIds = [];
+  for (const message of bundle.removable) {
+    const score = deps.scoreMessage(message);
+    if (typeof score !== "number" || !Number.isFinite(score) || score < 0 || score > 1) {
+      throw new PlanReject("filter_unavailable");
+    }
+    const decision = score >= threshold ? "keep" : "drop";
+    scoreRows.push({ messageId: message.id, score, decision });
+    if (decision === "drop") removalIds.push(message.id);
+  }
+  return finalizePlan("FILTER", context, bundle, removalIds, {
+    scoreRows,
+    criterionHash: sha256Hex(filter.keepCriterion),
+    // hash, never the rule text
+    sourcePromptHash: request.sourcePromptHash
+  });
+}
+function buildSummaryPlan(request, deps, context, bundle) {
+  const requested = request.summary?.method ?? "deterministic";
+  const llmEnabled = context.caps.activeContextLlm;
+  let method;
+  let fallbackPolicy;
+  if (requested === "deterministic") {
+    method = "deterministic";
+    fallbackPolicy = "none";
+  } else if (requested === "llm") {
+    if (!llmEnabled) throw new PlanReject("unsupported");
+    method = "llm";
+    fallbackPolicy = "none";
+  } else {
+    method = llmEnabled && deps.summarize ? "llm" : "deterministic";
+    fallbackPolicy = method === "llm" ? "allowed" : "none";
+  }
+  const requestedTokens = request.summary?.targetTokens ?? context.caps.activeContextSummaryMaxTokens;
+  if (typeof requestedTokens !== "number" || !Number.isFinite(requestedTokens) || requestedTokens <= 0 || requestedTokens > context.caps.activeContextSummaryMaxTokens) {
+    throw new PlanReject("invalid_request");
+  }
+  const targetTokens = Math.floor(requestedTokens);
+  const replacementSeed = sha256Hex(
+    canonicalJson({
+      operation: "SUMMARY",
+      selectorHash: bundle.selectorHash,
+      snapshotContentHash: context.snapshotContentHash,
+      sessionKey: context.scope.sessionKey,
+      namespace: context.scope.namespace,
+      principal: context.scope.principal,
+      adapterId: context.scope.adapterId
+    })
+  );
+  const replacement = {
+    messageId: `actxr-${replacementSeed.slice(0, 16)}`,
+    sourceMessageIds: bundle.removable.map((m) => m.id),
+    method,
+    fallbackPolicy,
+    targetTokens
+  };
+  const plan = finalizePlan("SUMMARY", context, bundle, [...replacement.sourceMessageIds], {
+    replacement,
+    sourcePromptHash: request.sourcePromptHash
+  });
+  return plan;
+}
+async function prepareActiveContextTransform(plan, deps) {
+  if (plan.status !== "ready") {
+    return { status: "rejected", plan, errorCode: plan.errorCode ?? "invalid_request" };
+  }
+  const scope = deps.resolvedScope;
+  const p = plan.precondition;
+  if (!scope || scope.principal !== p.principal || scope.sessionKey !== p.sessionKey || scope.namespace !== p.namespace || scope.adapterId !== p.adapterId) {
+    return { status: "rejected", plan, errorCode: "scope_mismatch" };
+  }
+  const now = deps.now?.() ?? /* @__PURE__ */ new Date();
+  if (now.getTime() >= new Date(plan.retention.expiresAt).getTime()) {
+    return { status: "rejected", plan, errorCode: "stale_context" };
+  }
+  if (deps.snapshot.sessionKey !== p.sessionKey || deps.snapshot.namespace !== p.namespace) {
+    return { status: "rejected", plan, errorCode: "scope_mismatch" };
+  }
+  const fenceHash = hashSnapshot(deps.snapshot);
+  if (fenceHash !== plan.provenance.snapshotContentHash) {
+    return { status: "rejected", plan, errorCode: "plan_conflict" };
+  }
+  if (plan.operation === "FILTER") {
+    return { status: "ready", plan };
+  }
+  const replacement = plan.replacement;
+  if (!replacement) {
+    return { status: "failed", plan, errorCode: "invalid_request" };
+  }
+  const byId = new Map(deps.snapshot.messages.map((m) => [m.id, m]));
+  const sourceText = replacement.sourceMessageIds.map((id) => byId.get(id)).filter((m) => m !== void 0).sort((a, b) => a.ordinal - b.ordinal || a.id.localeCompare(b.id)).map((m) => m.content).join("\n\n");
+  const method = replacement.method === "deterministic" ? "deterministic" : replacement.fallbackPolicy === "allowed" ? "auto" : "llm";
+  try {
+    const result = await summarizeContextPure(sourceText, replacement.targetTokens, method, {
+      llm: deps.summarize,
+      deterministicMaxTokens: deps.caps?.activeContextSummaryMaxTokens ?? replacement.targetTokens
+    });
+    if (result.text.trim().length === 0) {
+      return { status: "failed", plan, errorCode: "summary_unavailable" };
+    }
+    return {
+      status: "ready",
+      plan,
+      replacement: {
+        messageId: replacement.messageId,
+        text: result.text,
+        contentHash: sha256Hex(result.text),
+        method: result.method,
+        ...result.modelUsed ? { modelUsed: result.modelUsed } : {},
+        fallback: result.fallback,
+        sourceMessageIds: replacement.sourceMessageIds
+      }
+    };
+  } catch (err) {
+    if (err instanceof ContextSummaryUnavailableError) {
+      return { status: "failed", plan, errorCode: "summary_unavailable" };
+    }
+    throw err;
+  }
+}
+async function recordActiveContextApplyReceipt(plan, receipt, trustedScope, recorder) {
+  const p = plan.precondition;
+  const scopeMatch = trustedScope.principal === p.principal && trustedScope.sessionKey === p.sessionKey && trustedScope.namespace === p.namespace && trustedScope.adapterId === p.adapterId && receipt.adapterId === trustedScope.adapterId;
+  if (!scopeMatch) throw new PlanReject("scope_mismatch");
+  if (receipt.planHash !== plan.planHash) throw new PlanReject("plan_conflict");
+  if (receipt.hostRevisionBefore === void 0 || receipt.hostRevisionBefore !== p.snapshotRevision) {
+    throw new PlanReject("stale_context");
+  }
+  const shapeOk = receipt.schemaVersion === ACTIVE_CONTEXT_RECEIPT_SCHEMA_VERSION && receipt.planId === plan.planId && (receipt.outcome === "applied" || receipt.outcome === "skipped" || receipt.outcome === "failed") && typeof receipt.appliedAt === "string" && !Number.isNaN(Date.parse(receipt.appliedAt));
+  if (!shapeOk) throw new PlanReject("invalid_receipt");
+  const event = {
+    recordKind: "context_transform",
+    schemaVersion: ACTIVE_CONTEXT_RECORD_SCHEMA_VERSION,
+    timestamp: receipt.appliedAt,
+    actionId: plan.planId,
+    action: plan.operation === "SUMMARY" ? "summarize_context" : "filter_context",
+    outcome: receipt.outcome,
+    status: receipt.outcome === "applied" ? "applied" : receipt.outcome === "failed" ? "rejected" : "validated",
+    subsystem: "active-context",
+    namespace: p.namespace,
+    sourceSessionKey: p.sessionKey,
+    planHash: plan.planHash,
+    snapshotRevision: p.snapshotRevision,
+    adapterId: receipt.adapterId,
+    algorithmVersion: plan.provenance.algorithmVersion,
+    selectedCount: plan.selectedMessageIds.length,
+    retainedCount: plan.retainedMessageIds.length,
+    proposedRemovalCount: plan.proposedRemovalIds.length,
+    receiptOutcome: receipt.outcome,
+    selectorHash: plan.provenance.selectorHash,
+    snapshotContentHash: plan.provenance.snapshotContentHash,
+    ...plan.provenance.criterionHash ? { criterionHash: plan.provenance.criterionHash } : {},
+    ...plan.provenance.sourcePromptHash ? { sourcePromptHash: plan.provenance.sourcePromptHash } : {},
+    policyDecision: plan.policy.decision,
+    policyRationale: plan.policy.rationale
+  };
+  let recorded = false;
+  try {
+    recorded = await recorder.append(event);
+  } catch {
+    recorded = false;
+  }
+  return { recorded, event: { ...event, telemetryRecorded: recorded } };
+}
+function buildContextTransformPlanEvent(plan, outcome) {
+  return {
+    recordKind: "context_transform",
+    schemaVersion: ACTIVE_CONTEXT_RECORD_SCHEMA_VERSION,
+    timestamp: plan.provenance.generatedAt,
+    actionId: plan.planId,
+    action: plan.operation === "SUMMARY" ? "summarize_context" : "filter_context",
+    outcome,
+    status: plan.status === "ready" ? "validated" : "rejected",
+    subsystem: "active-context",
+    namespace: plan.precondition.namespace,
+    sourceSessionKey: plan.precondition.sessionKey,
+    planHash: plan.planHash,
+    snapshotRevision: plan.precondition.snapshotRevision,
+    algorithmVersion: plan.provenance.algorithmVersion,
+    selectedCount: plan.selectedMessageIds.length,
+    retainedCount: plan.retainedMessageIds.length,
+    proposedRemovalCount: plan.proposedRemovalIds.length,
+    selectorHash: plan.provenance.selectorHash,
+    snapshotContentHash: plan.provenance.snapshotContentHash,
+    ...plan.provenance.criterionHash ? { criterionHash: plan.provenance.criterionHash } : {},
+    ...plan.provenance.sourcePromptHash ? { sourcePromptHash: plan.provenance.sourcePromptHash } : {},
+    policyDecision: plan.policy.decision,
+    policyRationale: plan.policy.rationale,
+    telemetryRecorded: true
+  };
+}
+
+export {
+  ACTIVE_CONTEXT_ALGORITHM_VERSION,
+  ACTIVE_CONTEXT_SNAPSHOT_SCHEMA_VERSION,
+  ACTIVE_CONTEXT_PLAN_SCHEMA_VERSION,
+  ACTIVE_CONTEXT_RECEIPT_SCHEMA_VERSION,
+  ACTIVE_CONTEXT_RECORD_SCHEMA_VERSION,
+  planActiveContextTransform,
+  prepareActiveContextTransform,
+  recordActiveContextApplyReceipt,
+  buildContextTransformPlanEvent
+};
+//# sourceMappingURL=chunk-LB7WCZHY.js.map