@sixb/core 0.1.20 → 0.1.21

package/dist/{chunk-n33z5bjw.js → chunk-918wwnaa.js}

@@ -6,18 +6,18 @@ import {
   createSixbError2,
   toSixbFailure2,
   parseSixbFailure2
-} from "./chunk-8mx7qw3y.js";
+} from "./chunk-dvd2fp9q.js";
 import {
   paginate,
   InMemoryAuthStorage2,
   principalsEqual2
-} from "./chunk-vpq4shxz.js";
+} from "./chunk-nn5xnx3s.js";
 import {
   ObjectReadLimitExceededError2,
   snapshotObjectReadExecutionLimits2,
   assertObjectReadFacetCount2,
   assertObjectReadOutputWithinLimit2
-} from "./chunk-d0bqz29d.js";
+} from "./chunk-6vb4st8k.js";
 import {
   assertObjectReaderProject2
 } from "./chunk-v4jbb3rs.js";
@@ -25,7 +25,7 @@ import {
   queryScalarKindForSchema,
   resolvePropertyQueryCapabilities2,
   resolveQuerySchema
-} from "./chunk-hvsb78a1.js";
+} from "./chunk-8frc8a4j.js";
 import {
   AgentStorageError2,
   transitionAgentThreadSandbox2,
@@ -40,7 +40,7 @@ import {
   assertAgentContextCheckpointAnchors2,
   assertAgentContextCheckpointReplayState2,
   agentContextCheckpointMatchesCreateInput2
-} from "./chunk-s54c868q.js";
+} from "./chunk-3qct2mdc.js";
 import {
   InMemoryAiUsageStorage2,
   buildAiAccountingOverview,
@@ -82,12 +82,30 @@ import {
 } from "./chunk-h89wz928.js";
 import {
   DurableFileUploadSessions2
-} from "./chunk-9w055r5b.js";
+} from "./chunk-d09e3rax.js";
+import {
+  actionSubjectsEqual,
+  normalizeRecordActionRunInput2,
+  resolveActionRunEffects2,
+  StorageTransactionError2,
+  ACTIVITY_MAX_VISIT_MS2,
+  validateActivityAppend2,
+  planActivityAppend2,
+  activityCalendarDays2,
+  activityDay,
+  artifactStorageErrors2,
+  cloneFileDownloadGrantRecord,
+  canRequeuePipelineRunAfterEnqueueFailure2,
+  canRequeueSyncRunAfterEnqueueFailure2,
+  createTransactionStorageProxy2,
+  throwNestedStorageTransaction2
+} from "./chunk-tbc1ngpd.js";
 import {
   ExecutionStorageError2,
   prepareExecutionRecord2,
-  cloneExecutionRecord
-} from "./chunk-tw03bsmb.js";
+  cloneExecutionRecord,
+  compareExecutionCreation2
+} from "./chunk-eptrvnby.js";
 import {
   sha256Canonical2,
   createEventId2,
@@ -186,7 +204,7 @@ import {
   assertProjectionMissingTarget2,
   requireTelemetryProjectionRun2,
   assertProjectionRunDurableExecution2
-} from "./chunk-9ybhtmg4.js";
+} from "./chunk-vvxtn22d.js";
 import {
   SyncRunError2,
   assertSyncRunExecution2
@@ -199,7 +217,7 @@ import {
   WorkflowRunError2,
   assertWorkflowRunExecution2,
   assertWorkflowAgentNodeRunExecution2
-} from "./chunk-rrzt8jdy.js";
+} from "./chunk-9j4jw7as.js";
 import {
   ShareGrantStorageError2,
   normalizeShareGrantCreate2,
@@ -222,17 +240,6 @@ import {
   ConnectorConnectionStorageError2,
   CONNECTOR_CONNECTION_RUN_FAILURE_CODES2
 } from "./chunk-2c4j899j.js";
-import {
-  actionSubjectsEqual,
-  normalizeRecordActionRunInput2,
-  resolveActionRunEffects2,
-  StorageTransactionError2,
-  cloneFileDownloadGrantRecord,
-  canRequeuePipelineRunAfterEnqueueFailure2,
-  canRequeueSyncRunAfterEnqueueFailure2,
-  createTransactionStorageProxy2,
-  throwNestedStorageTransaction2
-} from "./chunk-s16apyk9.js";
 import {
   ActionRunError2
 } from "./chunk-y0c4e6ex.js";
@@ -245,7 +252,7 @@ import {
 } from "./chunk-96yw3pwd.js";
 import {
   AGENT_RUN_FAILURE_CODES2
-} from "./chunk-hkc3jct7.js";
+} from "./chunk-c06hmxyy.js";
 import {
   compareDecimalValues2
 } from "./chunk-3bh94gbw.js";
@@ -327,6 +334,15 @@ class InMemoryActionRunStorage2 {
       return record ? cloneActionRunRecord(record) : null;
     });
   }
+  async getByExecutionIds(params) {
+    return this.runRootOperation(() => {
+      const byExecution = new Map([...this.rows.values()].filter((record) => record.projectId === params.projectId).map((record) => [record.executionId, record]));
+      return [...new Set(params.executionIds)].flatMap((executionId) => {
+        const record = byExecution.get(executionId);
+        return record ? [cloneActionRunRecord(record)] : [];
+      });
+    });
+  }
   async list(input) {
     return this.runRootOperation(() => {
       if (input.actionIds?.length === 0) {
@@ -416,6 +432,12 @@ class InMemoryAgentThreadStore {
     const record = this.state.threads.get(key(params.projectId, params.id));
     return record ? clone(record) : null;
   }
+  async getByIds(params) {
+    return [...new Set(params.ids)].flatMap((id) => {
+      const record = this.state.threads.get(key(params.projectId, id));
+      return record ? [clone(record)] : [];
+    });
+  }
   async list(input) {
     const order = input.order ?? "desc";
     const statuses = input.statuses ? new Set(input.statuses) : null;
@@ -2338,6 +2360,383 @@ class InMemoryFileUploadSessionPersistence {
 // src/storage/in-memory/index.ts
 import { AsyncLocalStorage } from "async_hooks";
 
+// src/storage/activity/in-memory.ts
+class InMemoryActivityStorage {
+  sources = new Map;
+  visits = new Map;
+  pageViews = [];
+  interactions = [];
+  async append(input) {
+    validateActivityAppend2(input);
+    const sourceKey = JSON.stringify([input.projectId, input.actor.type, input.sessionId]);
+    const stored = [...this.pageViews, ...this.interactions].filter((event) => event.projectId === input.projectId && this.isFromSession(event, input) && input.events.some((candidate) => candidate.id === event.id));
+    const plan = planActivityAppend2(input, this.source(sourceKey, input.projectId), stored);
+    if (plan.status !== "append") {
+      return { status: plan.status === "duplicate" ? "accepted" : "throttled", accepted: 0 };
+    }
+    const visitKey = JSON.stringify([input.projectId, plan.state.visitId]);
+    const lastSeenAt = new Date(plan.state.lastSeenAt);
+    if (plan.newVisit) {
+      if (this.visits.has(visitKey)) {
+        throw new Error("[Sixb] Activity visit id already exists.");
+      }
+      this.visits.set(visitKey, {
+        projectId: input.projectId,
+        id: plan.state.visitId,
+        actor: structuredClone(input.actor),
+        sessionId: input.sessionId,
+        attribution: plan.newVisit.attribution,
+        startedAt: lastSeenAt,
+        lastSeenAt,
+        pageViews: plan.pageViews.length,
+        interactions: plan.interactions.length
+      });
+    } else {
+      const visit = this.requireVisit(input.projectId, plan.state.visitId);
+      visit.lastSeenAt = lastSeenAt;
+      visit.pageViews += plan.pageViews.length;
+      visit.interactions += plan.interactions.length;
+    }
+    const { visitStartedAt: _startedAt, ...source } = plan.state;
+    this.sources.set(sourceKey, source);
+    for (const pageView of plan.pageViews) {
+      this.pageViews.push({ ...pageView, projectId: input.projectId });
+    }
+    for (const interaction of plan.interactions) {
+      this.interactions.push({ ...interaction, projectId: input.projectId });
+    }
+    return { status: "accepted", accepted: plan.accepted };
+  }
+  async list(input) {
+    const visits = this.overlapping(input).filter((visit) => isBefore(visit.lastSeenAt, visit.id, input.before)).sort(byLastSeenDescending((visit) => visit.id));
+    return {
+      visits: visits.slice(0, input.limit).map(toVisit),
+      hasMore: visits.length > input.limit
+    };
+  }
+  async users(input) {
+    const byUser = new Map;
+    for (const visit of this.overlapping(input)) {
+      if (visit.actor.type !== "user") {
+        continue;
+      }
+      const user = byUser.get(visit.actor.userId) ?? {
+        lastSeenAt: visit.lastSeenAt,
+        visits: 0,
+        pageViews: 0
+      };
+      if (visit.lastSeenAt > user.lastSeenAt) {
+        user.lastSeenAt = visit.lastSeenAt;
+      }
+      user.visits += 1;
+      user.pageViews += this.pageViewsInPeriod(visit, input).length;
+      byUser.set(visit.actor.userId, user);
+    }
+    const users = [...byUser].map(([userId, user]) => ({ userId, ...user })).filter((user) => isBefore(user.lastSeenAt, user.userId, input.before)).sort(byLastSeenDescending((user) => user.userId));
+    return {
+      users: users.slice(0, input.limit).map((user) => ({ ...user })),
+      hasMore: users.length > input.limit
+    };
+  }
+  async summarize(input) {
+    const visits = this.overlapping(input);
+    const userIds = visits.flatMap((visit) => visit.actor.type === "user" ? [visit.actor.userId] : []);
+    return {
+      users: new Set(userIds).size,
+      visits: visits.length,
+      sharedVisits: visits.filter((visit) => visit.actor.type === "share").length,
+      pageViews: visits.reduce((total, visit) => total + this.pageViewsInPeriod(visit, input).length, 0)
+    };
+  }
+  async calendar(input) {
+    const visits = this.overlapping(input);
+    const pageViewsByDay = new Map;
+    for (const visit of visits) {
+      for (const pageView of this.pageViewsInPeriod(visit, input)) {
+        const day = activityDay(pageView.receivedAt);
+        pageViewsByDay.set(day, (pageViewsByDay.get(day) ?? 0) + 1);
+      }
+    }
+    return activityCalendarDays2(input, visits, pageViewsByDay);
+  }
+  async read(input) {
+    const visit = this.visits.get(JSON.stringify([input.projectId, input.id]));
+    if (!visit) {
+      return null;
+    }
+    const ofVisit = (event) => event.projectId === visit.projectId && event.visitId === visit.id;
+    const events = [...this.pageViews.filter(ofVisit), ...this.interactions.filter(ofVisit)].sort((left, right) => left.sequence - right.sequence);
+    const pageViews = [];
+    const interactions = [];
+    for (const event of events.slice(0, input.limit)) {
+      const { id, visitId, sequence, route } = event;
+      const pageView = { id, visitId, sequence, route, receivedAt: new Date(event.receivedAt) };
+      if ("name" in event) {
+        interactions.push({ ...pageView, name: event.name });
+      } else {
+        pageViews.push(pageView);
+      }
+    }
+    return {
+      visit: toVisit(visit),
+      sessionId: visit.sessionId,
+      pageViews,
+      interactions,
+      hasMore: events.length > input.limit
+    };
+  }
+  async sessionVisits(input) {
+    const sessionIds = new Set(input.sessionIds);
+    const bySession = new Map;
+    for (const visit of this.visits.values()) {
+      if (visit.projectId !== input.projectId || visit.actor.type !== "user" || visit.actor.userId !== input.userId || !sessionIds.has(visit.sessionId)) {
+        continue;
+      }
+      const visits = bySession.get(visit.sessionId) ?? [];
+      visits.push(visit);
+      bySession.set(visit.sessionId, visits);
+    }
+    return [...bySession].map(([sessionId, visits]) => ({
+      sessionId,
+      visits: visits.length,
+      latest: visits.sort(byStartDescending).slice(0, input.limit).map(toVisit)
+    }));
+  }
+  snapshot() {
+    return structuredClone({
+      sources: this.sources,
+      visits: this.visits,
+      pageViews: this.pageViews,
+      interactions: this.interactions
+    });
+  }
+  restore(snapshot) {
+    const restored = structuredClone(snapshot);
+    this.sources = restored.sources;
+    this.visits = restored.visits;
+    this.pageViews = restored.pageViews;
+    this.interactions = restored.interactions;
+  }
+  source(key, projectId) {
+    const source = this.sources.get(key);
+    if (!source) {
+      return;
+    }
+    const visit = this.visits.get(JSON.stringify([projectId, source.visitId]));
+    return { ...source, visitStartedAt: visit ? visit.startedAt.getTime() : null };
+  }
+  overlapping(input) {
+    const earliestStart = input.from.getTime() - ACTIVITY_MAX_VISIT_MS2;
+    return [...this.visits.values()].filter((visit) => visit.projectId === input.projectId && visit.startedAt.getTime() >= earliestStart && visit.startedAt < input.to && visit.lastSeenAt >= input.from && (input.userId === undefined || visit.actor.type === "user" && visit.actor.userId === input.userId));
+  }
+  pageViewsOf(visit) {
+    return this.pageViews.filter((pageView) => pageView.projectId === visit.projectId && pageView.visitId === visit.id);
+  }
+  pageViewsInPeriod(visit, period) {
+    return this.pageViewsOf(visit).filter((pageView) => pageView.receivedAt >= period.from && pageView.receivedAt < period.to);
+  }
+  isFromSession(event, input) {
+    const visit = this.visits.get(JSON.stringify([event.projectId, event.visitId]));
+    return visit?.actor.type === input.actor.type && visit.sessionId === input.sessionId;
+  }
+  requireVisit(projectId, id) {
+    const visit = this.visits.get(JSON.stringify([projectId, id]));
+    if (!visit) {
+      throw new Error("[Sixb] Activity visit is missing.");
+    }
+    return visit;
+  }
+}
+function toVisit(visit) {
+  return {
+    id: visit.id,
+    actor: structuredClone(visit.actor),
+    attribution: structuredClone(visit.attribution),
+    startedAt: new Date(visit.startedAt),
+    lastSeenAt: new Date(visit.lastSeenAt),
+    pageViews: visit.pageViews,
+    interactions: visit.interactions
+  };
+}
+function isBefore(at, id, cursor) {
+  if (!cursor) {
+    return true;
+  }
+  return at < cursor.at || at.getTime() === cursor.at.getTime() && id < cursor.id;
+}
+function byStartDescending(left, right) {
+  const byTime = right.startedAt.getTime() - left.startedAt.getTime();
+  if (byTime !== 0) {
+    return byTime;
+  }
+  return left.id < right.id ? 1 : left.id > right.id ? -1 : 0;
+}
+function byLastSeenDescending(id) {
+  return (left, right) => {
+    const byTime = right.lastSeenAt.getTime() - left.lastSeenAt.getTime();
+    if (byTime !== 0) {
+      return byTime;
+    }
+    return id(left) < id(right) ? 1 : id(left) > id(right) ? -1 : 0;
+  };
+}
+// src/storage/artifacts/in-memory.ts
+class InMemoryArtifactStorage {
+  artifacts = new Map;
+  frameGrants = new Map;
+  async create(input) {
+    const key = artifactKey(input.projectId, input.id);
+    if (this.artifacts.has(key))
+      throw artifactStorageErrors2.exists(input.id);
+    const version = versionRecord(input.projectId, input.id, 1, input.version);
+    const record = {
+      projectId: input.projectId,
+      id: input.id,
+      kind: input.kind,
+      title: version.title,
+      owner: { ...input.owner },
+      latestVersion: 1,
+      createdAt: new Date(version.createdAt),
+      updatedAt: new Date(version.createdAt)
+    };
+    this.artifacts.set(key, { record, versions: [version], nextVersion: 2 });
+    return published(record, version);
+  }
+  async publish(input) {
+    const key = artifactKey(input.projectId, input.artifactId);
+    const stored = this.artifacts.get(key);
+    if (!stored)
+      throw artifactStorageErrors2.notFound(input.artifactId);
+    if (stored.record.kind !== input.kind) {
+      throw artifactStorageErrors2.kindMismatch(input.artifactId, stored.record.kind, input.kind);
+    }
+    const version = versionRecord(input.projectId, input.artifactId, stored.nextVersion, input.version);
+    const record = {
+      ...stored.record,
+      title: version.title,
+      latestVersion: version.version,
+      updatedAt: new Date(version.createdAt)
+    };
+    this.artifacts.set(key, {
+      record,
+      versions: [...stored.versions, version],
+      nextVersion: stored.nextVersion + 1
+    });
+    return published(record, version);
+  }
+  async get(input) {
+    const stored = this.artifacts.get(artifactKey(input.projectId, input.id));
+    return stored ? structuredClone(stored.record) : null;
+  }
+  async list(input) {
+    const matching = [...this.artifacts.values()].filter(({ record, versions }) => record.projectId === input.projectId && (!input.owner || principalsEqual2(record.owner, input.owner)) && (input.kind === undefined || record.kind === input.kind) && (input.originThreadId === undefined || versions.some((version) => version.origin?.threadId === input.originThreadId))).map(({ record }) => record).sort((left, right) => right.updatedAt.getTime() - left.updatedAt.getTime() || left.id.localeCompare(right.id));
+    const { page, hasMore, total } = paginate(matching, input);
+    return { artifacts: structuredClone(page), hasMore, total };
+  }
+  async getVersion(input) {
+    const stored = this.artifacts.get(artifactKey(input.projectId, input.artifactId));
+    const version = stored?.versions.find((candidate) => candidate.version === input.version);
+    return version ? structuredClone(version) : null;
+  }
+  async listVersions(input) {
+    const stored = this.artifacts.get(artifactKey(input.projectId, input.artifactId));
+    const newestFirst = [...stored?.versions ?? []].reverse();
+    const { page, hasMore, total } = paginate(newestFirst, input);
+    return { versions: structuredClone(page), hasMore, total };
+  }
+  async listReferencingVersions(input) {
+    const prefix = `artifact:${input.artifactId}`;
+    const referencing = [];
+    for (const stored of this.artifacts.values()) {
+      if (stored.record.projectId !== input.projectId)
+        continue;
+      const latest = stored.versions.find((candidate) => candidate.version === stored.record.latestVersion);
+      if (latest?.references.some((reference) => refersTo(reference.address, prefix))) {
+        referencing.push(structuredClone(latest));
+      }
+    }
+    return referencing.sort((left, right) => left.artifactId < right.artifactId ? -1 : 1);
+  }
+  async createFrameGrant(record) {
+    if (!this.artifacts.has(artifactKey(record.projectId, record.artifactId))) {
+      throw artifactStorageErrors2.notFound(record.artifactId);
+    }
+    this.frameGrants.set(artifactKey(record.projectId, record.tokenHash), structuredClone(record));
+  }
+  async findFrameGrant(input) {
+    const grant = this.frameGrants.get(artifactKey(input.projectId, input.tokenHash));
+    return grant ? structuredClone(grant) : null;
+  }
+  async deleteExpiredFrameGrants(input) {
+    let deleted = 0;
+    for (const [key, grant] of this.frameGrants) {
+      if (deleted >= input.limit)
+        break;
+      if (grant.projectId !== input.projectId || grant.expiresAt >= input.expiredBefore)
+        continue;
+      this.frameGrants.delete(key);
+      deleted += 1;
+    }
+    return deleted;
+  }
+  async delete(input) {
+    return this.deleteArtifact(artifactKey(input.projectId, input.id));
+  }
+  async deleteVersionsByOrigin(input) {
+    let deleted = 0;
+    for (const [key, stored] of this.artifacts) {
+      if (stored.record.projectId !== input.projectId)
+        continue;
+      const remaining = stored.versions.filter((version) => version.origin?.runId !== input.runId);
+      if (remaining.length === stored.versions.length)
+        continue;
+      deleted += stored.versions.length - remaining.length;
+      const latest = remaining.at(-1);
+      if (!latest) {
+        this.deleteArtifact(key);
+        continue;
+      }
+      this.artifacts.set(key, {
+        ...stored,
+        record: {
+          ...stored.record,
+          title: latest.title,
+          latestVersion: latest.version,
+          updatedAt: new Date(latest.createdAt)
+        },
+        versions: remaining
+      });
+    }
+    return deleted;
+  }
+  snapshot() {
+    return structuredClone({ artifacts: this.artifacts, frameGrants: this.frameGrants });
+  }
+  restore(snapshot) {
+    const restored = structuredClone(snapshot);
+    this.artifacts = new Map(restored.artifacts);
+    this.frameGrants = new Map(restored.frameGrants);
+  }
+  deleteArtifact(key) {
+    for (const [grantKey, grant] of this.frameGrants) {
+      if (artifactKey(grant.projectId, grant.artifactId) === key)
+        this.frameGrants.delete(grantKey);
+    }
+    return this.artifacts.delete(key);
+  }
+}
+function versionRecord(projectId, artifactId, version, input) {
+  return structuredClone({ ...input, projectId, artifactId, version });
+}
+function published(record, version) {
+  return structuredClone({ artifact: record, version });
+}
+function artifactKey(projectId, id) {
+  return `${projectId}\x00${id}`;
+}
+function refersTo(address, prefix) {
+  return address.startsWith(prefix) && /^(?:$|[@/#])/.test(address.slice(prefix.length));
+}
 // src/storage/executions/in-memory.ts
 var runDirectly2 = async (run) => run();
 function executionKey(projectId, id) {
@@ -2387,6 +2786,30 @@ class InMemoryExecutionStorage {
       return record ? cloneExecutionRecord(record) : null;
     });
   }
+  async listBySession(input) {
+    return this.runRootOperation(() => {
+      const rows = [...this.rows.values()].filter((row) => row.projectId === input.projectId);
+      const roots = rows.filter((row) => row.source.type !== "execution" && row.createdAt >= input.from && row.createdAt < input.to && isFromSession(row, input.session)).sort(compareExecutionCreation2).slice(0, input.limit + 1);
+      const found = [...roots];
+      let level = roots;
+      while (level.length > 0 && found.length <= input.limit) {
+        const parents = new Set(level.map((row) => row.id));
+        level = rows.filter((row) => row.source.type === "execution" && parents.has(row.source.executionId)).sort(compareExecutionCreation2);
+        found.push(...level);
+      }
+      return {
+        executions: found.slice(0, input.limit).sort(compareExecutionCreation2).map(cloneExecutionRecord),
+        truncated: found.length > input.limit
+      };
+    });
+  }
+}
+function isFromSession(row, session) {
+  const ref = row.authorizationRef;
+  if (session.type === "user") {
+    return ref.type === "principal" && ref.credential?.type === "session" && ref.credential.id === session.id;
+  }
+  return ref.type === "delegated" && ref.delegation.sessionId === session.id;
 }
 
 // src/storage/file-download-grants/in-memory.ts
@@ -5843,6 +6266,24 @@ class InMemoryOntologySourceStorage {
       return active ? sourceMaterializationRecord(active) : null;
     });
   }
+  async listActive(input) {
+    return this.runRootOperation(() => {
+      assertNonblank(input.projectId, "Source project id");
+      const active = [];
+      for (const materialization of this.state.sourceMaterializations.values()) {
+        if (materialization.projectId !== input.projectId)
+          continue;
+        if (materialization.status !== "active")
+          continue;
+        active.push({
+          source: { projectionId: materialization.source.projectionId },
+          datasetVersion: { ...materialization.datasetVersion },
+          projectionRevision: materialization.projectionRevision
+        });
+      }
+      return active;
+    });
+  }
   async adopt(input) {
     return this.runRootOperation(async () => {
       assertSourceProject2(input);
@@ -7155,6 +7596,12 @@ class InMemoryShareGrantStorage2 {
     const record = this.rows.get(rowKey2(normalized.projectId, normalized.id));
     return record ? cloneShareGrantRecord2(record) : null;
   }
+  async getByIds(input) {
+    return [...new Set(input.ids)].flatMap((id) => {
+      const record = this.rows.get(rowKey2(input.projectId, id));
+      return record ? [cloneShareGrantRecord2(record)] : [];
+    });
+  }
   async list(input) {
     const normalized = normalizeListShareGrantsInput2(input);
     const matching = [...this.rows.values()].filter((record) => record.projectId === normalized.projectId && (normalized.definitionId === undefined || record.definitionId === normalized.definitionId) && (normalized.target === undefined || record.target.objectTypeId === normalized.target.objectTypeId && record.target.primaryId === normalized.target.primaryId) && (normalized.includeRevoked || record.revokedAt === undefined) && (normalized.includeExpired || record.expiresAt.getTime() > normalized.now.getTime())).sort(compareShareGrants);
@@ -7868,6 +8315,13 @@ class InMemoryWorkflowRunStorage2 {
     const record = this.runs.get(storageKey(params.projectId, params.id));
     return record ? cloneRecord(record) : null;
   }
+  async getByExecutionIds(params) {
+    const byExecution = new Map([...this.runs.values()].filter((record) => record.projectId === params.projectId).map((record) => [record.executionId, record]));
+    return [...new Set(params.executionIds)].flatMap((executionId) => {
+      const record = byExecution.get(executionId);
+      return record ? [cloneRecord(record)] : [];
+    });
+  }
   async list(input) {
     if (hasEmptyStatuses(input) || input.workflowIds?.length === 0) {
       return {
@@ -8245,6 +8699,7 @@ class InMemoryStorage2 {
     shareSessions: this.shareSessionStorage
   });
   agentStorage = new InMemoryAgentStorage2(this.executionStorage);
+  artifactStorage = new InMemoryArtifactStorage;
   aiUsageStorage = new InMemoryAiUsageStorage2(this.executionStorage);
   aiCostStorage = new InMemoryAiCostStorage2(this.aiUsageStorage, {
     resolve: (input) => this.resolveAiAccountingAttribution(input),
@@ -8286,9 +8741,11 @@ class InMemoryStorage2 {
   fileUploadSessionStorage = new InMemoryFileUploadSessions2;
   fileDownloadGrantStorage = new InMemoryFileDownloadGrantStorage;
   connectorConnectionStorage;
+  activityStorage = new InMemoryActivityStorage;
   auth;
   executions;
   agents;
+  artifacts;
   aiUsage;
   aiCosts;
   aiLimits;
@@ -8305,6 +8762,7 @@ class InMemoryStorage2 {
   fileUploadSessions;
   fileDownloadGrants;
   connectorConnections;
+  activity;
   constructor(options = {}) {
     this.connectorConnectionStorage = new InMemoryConnectorConnectionStorage2(options.connectorConnections);
     const scope = createStorageOperationScope2((run) => this.withStorageOperation(run), () => this.assertRootOperationAvailable());
@@ -8313,6 +8771,7 @@ class InMemoryStorage2 {
     this.auth = createAuthOperationScope2(this.authStorage, scope);
     this.executions = createOperationScopedFacade2(this.executionStorage, scope);
     this.agents = createAgentOperationScope2(this.agentStorage, scope);
+    this.artifacts = createOperationScopedFacade2(this.artifactStorage, scope);
     this.aiUsage = createOperationScopedFacade2(this.aiUsageStorage, scope);
     this.aiCosts = createOperationScopedFacade2(this.aiCostStorage, scope);
     this.aiLimits = createOperationScopedFacade2(this.aiLimitStorage, scope);
@@ -8329,6 +8788,7 @@ class InMemoryStorage2 {
     this.fileUploadSessions = createOperationScopedFacade2(this.fileUploadSessionStorage, scope);
     this.fileDownloadGrants = createOperationScopedFacade2(this.fileDownloadGrantStorage, scope);
     this.connectorConnections = createOperationScopedFacade2(this.connectorConnectionStorage, scope);
+    this.activity = createOperationScopedFacade2(this.activityStorage, scope);
     this.ontologyStorage = new InMemoryOntologyStorage(this.objectStorage, this.timeseriesStorage, {
       runRootOperation: async (run) => run(),
       getTransactionToken: () => this.getActiveTransactionToken(),
@@ -8474,6 +8934,7 @@ class InMemoryStorage2 {
       auth: this.authStorage,
       executions: this.executionStorage,
       agents: this.agentStorage,
+      artifacts: this.artifactStorage,
       aiUsage: this.aiUsageStorage,
       aiCosts: this.aiCostStorage,
       aiLimits: this.aiLimitStorage,
@@ -8490,6 +8951,7 @@ class InMemoryStorage2 {
       fileUploadSessions: this.fileUploadSessionStorage,
       fileDownloadGrants: this.fileDownloadGrantStorage,
       connectorConnections: this.connectorConnectionStorage,
+      activity: this.activityStorage,
       ping: async () => {
         return;
       },
@@ -8506,6 +8968,7 @@ class InMemoryStorage2 {
       auth: this.authStorage.snapshot(),
       executions: this.executionStorage.snapshot(),
       agents: this.agentStorage.snapshot(),
+      artifacts: this.artifactStorage.snapshot(),
       aiUsage: this.aiUsageStorage.snapshot(),
       aiCosts: this.aiCostStorage.snapshot(),
       aiLimits: this.aiLimitStorage.snapshot(),
@@ -8521,7 +8984,8 @@ class InMemoryStorage2 {
       shareSessions: this.shareSessionStorage.snapshot(),
       fileUploadSessions: this.fileUploadSessionStorage.snapshot(),
       fileDownloadGrants: this.fileDownloadGrantStorage.snapshot(),
-      connectorConnections: this.connectorConnectionStorage.snapshot()
+      connectorConnections: this.connectorConnectionStorage.snapshot(),
+      activity: this.activityStorage.snapshot()
     };
   }
   restore(snapshot) {
@@ -8531,6 +8995,7 @@ class InMemoryStorage2 {
     this.authStorage.restore(snapshot.auth);
     this.executionStorage.restore(snapshot.executions);
     this.agentStorage.restore(snapshot.agents);
+    this.artifactStorage.restore(snapshot.artifacts);
     this.aiUsageStorage.restore(snapshot.aiUsage);
     this.aiCostStorage.restore(snapshot.aiCosts);
     this.aiLimitStorage.restore(snapshot.aiLimits);
@@ -8547,6 +9012,7 @@ class InMemoryStorage2 {
     this.fileUploadSessionStorage.restore(snapshot.fileUploadSessions);
     this.fileDownloadGrantStorage.restore(snapshot.fileDownloadGrants);
     this.connectorConnectionStorage.restore(snapshot.connectorConnections);
+    this.activityStorage.restore(snapshot.activity);
   }
 }
 // src/storage/objects/query-preparation.ts
@@ -8806,4 +9272,4 @@ var VECTOR_INDEXING_FAILURE_CODES2 = [
 ];
 export { MAX_VECTOR_K, INDEXING_EMBEDDING_TIMEOUT_MS, vectorConfiguration, vectorSources, normalizeVector2, vectorSearchCandidateLimit2, hasVectorProfile2, isVectorProfileQuery2, InMemoryActionRunStorage2, AGENT_MESSAGE_CONTENT_VERSION2, InMemoryAgentStorage2, AiCostStorageError2, InMemoryAiCostStorage2, InMemoryAiLimitStorage2, InMemoryConnectorConnectionStorage2, InMemoryFileUploadSessions2, objectBatchKey2, linkBatchKey2, objectLinkCursor2, compareQueryScalarValues, queryScalarValuesEqual, PIPELINE_RUN_FAILURE_CODES2, InMemoryPipelineRunStorage2, InMemoryProjectionRunStorage2, InMemoryRulesStorage2, InMemoryShareGrantStorage2, InMemoryShareSessionStorage2, SYNC_RUN_FAILURE_CODES2, InMemorySyncRunStorage2, WEBHOOK_RUN_FAILURE_CODES2, canRetryWebhookRun2, InMemoryWebhookRunStorage2, WorkflowInterventionError2, InMemoryWorkflowInterventionStorage2, WORKFLOW_RUN_FAILURE_CODES2, InMemoryWorkflowRunStorage2, InMemoryWorkflowNodeRunStorage2, InMemoryWorkflowAgentNodeRunStorage2, InMemoryStorage2, prepareObjectQueries2, isMigrationCapableStorage2, migrateStorage2, checkStorageSchema2, step2, defineMigrations2, runMigrationSet2, describeMigrationHistory2, VECTOR_INDEXING_FAILURE_CODES2 };
 
-//# debugId=3B4A1636BCAC16F064756E2164756E21
+//# debugId=9F75904DDA2912F064756E2164756E21