@sixb/core 0.1.3 → 0.1.5

package/dist/{chunk-d2adj15j.js → chunk-tkdscva6.js}

@@ -17,7 +17,7 @@ import {
   grantKindOf,
   resolveAuthorizationContext,
   resolveRoleGrants
-} from "./chunk-4z3n1dzt.js";
+} from "./chunk-f83ka50g.js";
 
 // src/auth/access-tokens.ts
 import { createHash, randomBytes, randomUUID } from "crypto";

package/dist/{chunk-xmggaxg4.js → chunk-v0egge8b.js}

@@ -27,7 +27,7 @@ import {
   startScopeAccumulator,
   uniqueSorted,
   workUniquenessKey
-} from "./chunk-fmx1sz2h.js";
+} from "./chunk-72q2y8hn.js";
 import {
   createAgentOperationScope,
   createAuthOperationScope,
@@ -79,7 +79,7 @@ import {
   WorkflowRunError,
   assertWorkflowAgentNodeRunExecution,
   assertWorkflowRunExecution
-} from "./chunk-pxtrxm3p.js";
+} from "./chunk-a09jx26t.js";
 import {
   parseActionRunFailure
 } from "./chunk-htq0qh7z.js";
@@ -95,14 +95,14 @@ import {
   assertAgentContextCheckpointReplayState,
   assertAgentRunExecution,
   assertCreateAgentContextCheckpointInput
-} from "./chunk-qer6am8w.js";
+} from "./chunk-xdf9yswn.js";
 import {
   InMemoryAiUsageStorage,
   aiModelCallCostMatchesUsage,
   buildAiAccountingOverview,
   buildAiModelCallAccountingList,
   normalizeAiModelCallCostRecord
-} from "./chunk-kqxgf6kv.js";
+} from "./chunk-drjqm1aa.js";
 import {
   CONNECTOR_CONNECTION_RUN_FAILURE_CODES,
   ConnectorConnectionStorageError
@@ -131,10 +131,6 @@ import {
   MaterializationConflictError,
   MaterializationValidationError
 } from "./chunk-ry24jbr1.js";
-import {
-  compareQueryScalarValues,
-  queryScalarValuesEqual
-} from "./chunk-6wetht33.js";
 import {
   AGENT_RUN_FAILURE_CODES
 } from "./chunk-t0jjkep3.js";
@@ -142,10 +138,13 @@ import {
   InMemoryAuthStorage,
   paginate,
   principalsEqual
-} from "./chunk-d2adj15j.js";
+} from "./chunk-tkdscva6.js";
 import {
   normalizeRequesterGroupIds
 } from "./chunk-rhrbz7d4.js";
+import {
+  compareDecimalValues
+} from "./chunk-04b07a9q.js";
 import {
   createSixbError,
   parseSixbFailure,
@@ -846,6 +845,13 @@ class InMemoryAgentContextCheckpointStore {
     const record = this.findLatest(input.projectId, input.threadId);
     return record ? clone(record) : null;
   }
+  async getByRunIds(input) {
+    const byRunId = new Map([...this.state.checkpoints.values()].filter((checkpoint) => checkpoint.projectId === input.projectId).map((checkpoint) => [checkpoint.createdByRunId, checkpoint]));
+    return [...new Set(input.runIds)].flatMap((runId) => {
+      const checkpoint = byRunId.get(runId);
+      return checkpoint ? [clone(checkpoint)] : [];
+    });
+  }
   findLatest(projectId, threadId) {
     return [...this.state.checkpoints.values()].filter((checkpoint) => checkpoint.projectId === projectId && checkpoint.threadId === threadId).sort((left, right) => right.summarizedThroughSeq - left.summarizedThroughSeq || right.createdAt.getTime() - left.createdAt.getTime() || right.id.localeCompare(left.id))[0] ?? null;
   }
@@ -2104,6 +2110,110 @@ class InMemoryExecutionStorage {
   }
 }
 
+// src/objects/query/scalar-values.ts
+function compareQueryScalarValues(left, right, scalarKind) {
+  if (left === undefined || right === undefined || left === null || right === null) {
+    return Number.NaN;
+  }
+  if (scalarKind === undefined)
+    return compareRuntimeValues(left, right);
+  switch (scalarKind) {
+    case "string":
+    case "uuid":
+      return typeof left === "string" && typeof right === "string" ? compareStrings(left, right) : Number.NaN;
+    case "boolean":
+      return typeof left === "boolean" && typeof right === "boolean" ? Number(left) - Number(right) : Number.NaN;
+    case "integer":
+    case "double":
+      return typeof left === "number" && typeof right === "number" ? left - right : Number.NaN;
+    case "decimal":
+      return typeof left === "string" && typeof right === "string" ? compareDecimalValues(left, right) : Number.NaN;
+    case "date":
+    case "timestamp":
+      return compareTemporalValues(left, right);
+  }
+}
+function queryScalarValuesEqual(left, right, scalarKind) {
+  if (scalarKind === "decimal") {
+    const comparison = compareQueryScalarValues(left, right, scalarKind);
+    return !Number.isNaN(comparison) && comparison === 0;
+  }
+  if (scalarKind === "date" || scalarKind === "timestamp") {
+    const comparison = compareTemporalValues(left, right);
+    return !Number.isNaN(comparison) && comparison === 0;
+  }
+  if (scalarKind !== undefined)
+    return Object.is(left, right);
+  return runtimeValuesEqual(left, right);
+}
+function compareRuntimeValues(left, right) {
+  if (typeof left === "number" && typeof right === "number")
+    return left - right;
+  if (typeof left === "string" && typeof right === "string")
+    return compareStrings(left, right);
+  if (typeof left === "boolean" && typeof right === "boolean") {
+    return Number(left) - Number(right);
+  }
+  if (left instanceof Date || right instanceof Date)
+    return compareTemporalValues(left, right);
+  return Number.NaN;
+}
+function runtimeValuesEqual(left, right) {
+  if (left instanceof Date || right instanceof Date) {
+    const comparison = compareTemporalValues(left, right);
+    return !Number.isNaN(comparison) && comparison === 0;
+  }
+  return Object.is(left, right);
+}
+function compareTemporalValues(left, right) {
+  const leftTime = dateTime(left);
+  const rightTime = dateTime(right);
+  if (leftTime === null || rightTime === null)
+    return Number.NaN;
+  return leftTime - rightTime;
+}
+function dateTime(value) {
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return Number.isNaN(time) ? null : time;
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    const time = new Date(value).getTime();
+    return Number.isNaN(time) ? null : time;
+  }
+  return null;
+}
+function compareStrings(left, right) {
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+
+// src/storage/objects/keys.ts
+function objectBatchKey(objectTypeId, primaryId) {
+  return JSON.stringify([objectTypeId, primaryId]);
+}
+function linkBatchKey(objectTypeId, objectId, linkId) {
+  return JSON.stringify([objectTypeId, objectId, linkId]);
+}
+function objectLinkCursor(link) {
+  return [link.sourceTypeId, link.sourceId, link.linkId, link.targetTypeId, link.targetId];
+}
+function compareObjectLinkCursors(left, right) {
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] < right[index])
+      return -1;
+    if (left[index] > right[index])
+      return 1;
+  }
+  return 0;
+}
+function compareObjectLinks(left, right) {
+  return compareObjectLinkCursors(objectLinkCursor(left), objectLinkCursor(right));
+}
+
 // src/storage/objects/in-memory.ts
 var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
   queryObjects: true,
@@ -2112,6 +2222,7 @@ var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
   facetObjects: true,
   nodes: {
     start: true,
+    refs: true,
     filter: true,
     text: true,
     vector: true,
@@ -2165,23 +2276,37 @@ var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
   }
 };
 function objectRowKey(projectId, objectTypeId) {
-  return `${projectId}:${objectTypeId}`;
+  return JSON.stringify([projectId, objectTypeId]);
+}
+function objectRowProjectPrefix(projectId) {
+  return `[${JSON.stringify(projectId)},`;
 }
-function comparePrimaryIds(left, right) {
+function compareStrings2(left, right) {
   if (left < right)
     return -1;
   if (left > right)
     return 1;
   return 0;
 }
+function assertLinkQueryLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new Error("Object link query limit must be a positive safe integer.");
+  }
+}
 function sourceLinkBucketKey(projectId, sourceTypeId, sourceId) {
-  return `${projectId}:${sourceTypeId}:${sourceId}`;
+  return JSON.stringify([projectId, sourceTypeId, sourceId]);
 }
 function linkRowKey(linkId, targetTypeId, targetId) {
-  return `${linkId}:${targetTypeId}:${targetId}`;
+  return JSON.stringify([linkId, targetTypeId, targetId]);
 }
 function fullLinkRowKey(row) {
-  return `${row.sourceTypeId}:${row.sourceId}:${row.linkId}:${row.targetTypeId}:${row.targetId}`;
+  return JSON.stringify([
+    row.sourceTypeId,
+    row.sourceId,
+    row.linkId,
+    row.targetTypeId,
+    row.targetId
+  ]);
 }
 var PAGE_TOKEN_PREFIX = "offset:";
 var materializerAdapters = new WeakMap;
@@ -2316,6 +2441,8 @@ class InMemoryObjectStorage {
     switch (query.kind) {
       case "start":
         return this.evaluateStart(projectId, query.objectTypeId);
+      case "refs":
+        return this.evaluateRefs(projectId, query.refs);
       case "filter": {
         const input = this.evaluateObjectQuery(projectId, query.input);
         const entries = input.entries.filter((entry) => matchesPredicate(entry.row, query.predicate));
@@ -2405,6 +2532,18 @@ class InMemoryObjectStorage {
     }));
     return completeEvaluation(entries);
   }
+  evaluateRefs(projectId, refs) {
+    const seen = new Set;
+    const entries = refs.flatMap((ref) => {
+      const key2 = JSON.stringify([ref.objectTypeId, ref.primaryId]);
+      if (seen.has(key2))
+        return [];
+      seen.add(key2);
+      const row = this.rows.get(objectRowKey(projectId, ref.objectTypeId))?.get(ref.primaryId);
+      return row ? [row] : [];
+    }).sort((left, right) => compareStrings2(left.objectTypeId, right.objectTypeId) || compareStrings2(left.primaryId, right.primaryId)).map((row, order) => ({ row, score: 0, order }));
+    return completeEvaluation(entries);
+  }
   evaluateSet(projectId, op, inputs) {
     const evaluations = inputs.map((input) => this.evaluateObjectQuery(projectId, input));
     const first = evaluations[0];
@@ -2512,7 +2651,7 @@ class InMemoryObjectStorage {
         primaryId: item.primaryId
       });
       if (row) {
-        result.set(`${item.objectTypeId}:${item.primaryId}`, row);
+        result.set(objectBatchKey(item.objectTypeId, item.primaryId), row);
       }
     }
     return result;
@@ -2527,11 +2666,39 @@ class InMemoryObjectStorage {
         linkId: item.linkId
       });
       if (rows.length > 0) {
-        result.set(`${item.objectTypeId}:${item.objectId}:${item.linkId}`, [...rows]);
+        result.set(linkBatchKey(item.objectTypeId, item.objectId, item.linkId), [...rows]);
       }
     }
     return result;
   }
+  async queryLinks(params) {
+    assertLinkQueryLimit(params.limit);
+    if (params.objectRefs.length === 0 || params.endpointObjectTypeIds?.length === 0) {
+      return { links: [], hasMore: false };
+    }
+    const allowedTypes = params.endpointObjectTypeIds ? new Set(params.endpointObjectTypeIds) : undefined;
+    const deduped = new Map;
+    for (const object of params.objectRefs) {
+      const rows2 = await this.listLinks({
+        projectId: params.projectId,
+        objectTypeId: object.objectTypeId,
+        objectId: object.primaryId,
+        direction: params.direction,
+        ...params.linkId === undefined ? {} : { linkId: params.linkId }
+      });
+      for (const row of rows2) {
+        if (allowedTypes && (!allowedTypes.has(row.sourceTypeId) || !allowedTypes.has(row.targetTypeId))) {
+          continue;
+        }
+        if (params.after && compareObjectLinkCursors(objectLinkCursor(row), params.after) <= 0) {
+          continue;
+        }
+        deduped.set(fullLinkRowKey(row), row);
+      }
+    }
+    const rows = [...deduped.values()].sort(compareObjectLinks).slice(0, params.limit + 1);
+    return { links: rows.slice(0, params.limit), hasMore: rows.length > params.limit };
+  }
   async listIncidentLinksBatch(params) {
     const deduped = new Map;
     for (const item of params.items) {
@@ -2550,7 +2717,7 @@ class InMemoryObjectStorage {
   async listByPrimaryIdPage(params) {
     assertReconciliationPageLimit(params.limit);
     const bucket = this.rows.get(objectRowKey(params.projectId, params.objectTypeId));
-    const rows = [...bucket?.values() ?? []].filter((row) => !params.afterPrimaryId || comparePrimaryIds(row.primaryId, params.afterPrimaryId) > 0).sort((left, right) => comparePrimaryIds(left.primaryId, right.primaryId)).slice(0, params.limit + 1);
+    const rows = [...bucket?.values() ?? []].filter((row) => !params.afterPrimaryId || compareStrings2(row.primaryId, params.afterPrimaryId) > 0).sort((left, right) => compareStrings2(left.primaryId, right.primaryId)).slice(0, params.limit + 1);
     const hasMore = rows.length > params.limit;
     const objects = rows.slice(0, params.limit).map((row) => structuredClone(row));
     const last = objects.at(-1);
@@ -2571,7 +2738,7 @@ class InMemoryObjectStorage {
       }
     } else {
       for (const [key2, bucket] of this.rows) {
-        if (key2.startsWith(`${params.projectId}:`)) {
+        if (key2.startsWith(objectRowProjectPrefix(params.projectId))) {
           allRows.push(...bucket.values());
         }
       }
@@ -2837,7 +3004,7 @@ function rowIdentityKey(row) {
   return rowIdentityKeyParts(row.objectTypeId, row.primaryId);
 }
 function rowIdentityKeyParts(objectTypeId, primaryId) {
-  return `${objectTypeId}:${primaryId}`;
+  return objectBatchKey(objectTypeId, primaryId);
 }
 function upsertEntry(entriesByKey, entry) {
   const key2 = rowIdentityKey(entry.row);
@@ -3127,23 +3294,19 @@ class InMemoryTimeseriesStorage {
     return points.map(clonePoint);
   }
   async getHistoryBatch(input) {
-    const results = [];
-    for (const series of input.series) {
-      results.push({
-        ...series,
-        points: await this.getHistory({
-          projectId: input.projectId,
-          objectTypeId: series.objectTypeId,
-          objectId: series.objectId,
-          propertyId: series.propertyId,
-          from: input.from,
-          to: input.to,
-          limit: input.limitPerSeries,
-          order: input.order
-        })
-      });
-    }
-    return results;
+    return Promise.all(input.series.map(async (series) => ({
+      ...series,
+      points: await this.getHistory({
+        projectId: input.projectId,
+        objectTypeId: series.objectTypeId,
+        objectId: series.objectId,
+        propertyId: series.propertyId,
+        from: input.from,
+        to: input.to,
+        limit: input.limitPerSeries,
+        order: input.order
+      })
+    })));
   }
   async getLatest(params) {
     const series = this.pointsByKey.get(pointKey(params.projectId, params.objectTypeId, params.objectId, params.propertyId));
@@ -7088,6 +7251,6 @@ function assertAppliedPrefix(migrations, rows) {
   }
   return [...rows].sort((a, b) => a.version - b.version);
 }
-export { actionSubjectsEqual, actionRunParamsEqual, actionRunPhaseRecordsEqual, finishActionRunPhase, canRequeueActionRunAfterEnqueueFailure, isTerminalActionRun, InMemoryActionRunStorage, AGENT_MESSAGE_CONTENT_VERSION, InMemoryAgentStorage, AiCostStorageError, InMemoryAiCostStorage, InMemoryConnectorConnectionStorage, ObjectNotFoundError, ObjectStorageError, StorageTransactionError, isStorageSerializationFailure, FileUploadSessionError, DEFAULT_FILE_UPLOAD_SESSION_TTL_MS, DEFAULT_FILE_UPLOAD_TERMINAL_SESSION_TTL_MS, createUploadExpiresAt, createFileUploadId, InMemoryFileUploadSessions, canRequeuePipelineRunAfterEnqueueFailure, PIPELINE_RUN_FAILURE_CODES, InMemoryPipelineRunStorage, InMemoryProjectionRunStorage, InMemoryRulesStorage, canRequeueSyncRunAfterEnqueueFailure, SYNC_RUN_FAILURE_CODES, InMemorySyncRunStorage, createTransactionStorageProxy, assertTransactionActive, throwNestedStorageTransaction, WEBHOOK_RUN_FAILURE_CODES, canRetryWebhookRun, InMemoryWebhookRunStorage, WorkflowInterventionError, InMemoryWorkflowInterventionStorage, WORKFLOW_RUN_FAILURE_CODES, InMemoryWorkflowRunStorage, InMemoryWorkflowNodeRunStorage, InMemoryWorkflowAgentNodeRunStorage, InMemoryStorage, isMigrationCapableStorage, migrateStorage, checkStorageSchema, step, defineMigrations, runMigrationSet, describeMigrationHistory };
+export { actionSubjectsEqual, actionRunParamsEqual, actionRunPhaseRecordsEqual, finishActionRunPhase, canRequeueActionRunAfterEnqueueFailure, isTerminalActionRun, InMemoryActionRunStorage, AGENT_MESSAGE_CONTENT_VERSION, InMemoryAgentStorage, AiCostStorageError, InMemoryAiCostStorage, InMemoryConnectorConnectionStorage, ObjectNotFoundError, ObjectStorageError, StorageTransactionError, isStorageSerializationFailure, FileUploadSessionError, DEFAULT_FILE_UPLOAD_SESSION_TTL_MS, DEFAULT_FILE_UPLOAD_TERMINAL_SESSION_TTL_MS, createUploadExpiresAt, createFileUploadId, InMemoryFileUploadSessions, compareQueryScalarValues, queryScalarValuesEqual, objectBatchKey, linkBatchKey, objectLinkCursor, canRequeuePipelineRunAfterEnqueueFailure, PIPELINE_RUN_FAILURE_CODES, InMemoryPipelineRunStorage, InMemoryProjectionRunStorage, InMemoryRulesStorage, canRequeueSyncRunAfterEnqueueFailure, SYNC_RUN_FAILURE_CODES, InMemorySyncRunStorage, createTransactionStorageProxy, assertTransactionActive, throwNestedStorageTransaction, WEBHOOK_RUN_FAILURE_CODES, canRetryWebhookRun, InMemoryWebhookRunStorage, WorkflowInterventionError, InMemoryWorkflowInterventionStorage, WORKFLOW_RUN_FAILURE_CODES, InMemoryWorkflowRunStorage, InMemoryWorkflowNodeRunStorage, InMemoryWorkflowAgentNodeRunStorage, InMemoryStorage, isMigrationCapableStorage, migrateStorage, checkStorageSchema, step, defineMigrations, runMigrationSet, describeMigrationHistory };
 
-//# debugId=D421DE165E32FF5B64756E2164756E21
+//# debugId=AD092B967C71B31564756E2164756E21