@sixb/core 0.1.20 → 0.1.22

package/dist/chunk-fe8zwt8b.js

@@ -0,0 +1,688 @@
+// @bun
+import {
+  ACTION_RUN_PHASES2,
+  parseActionRunFailure2
+} from "./chunk-c0vk1djt.js";
+import {
+  ARTIFACT_STATE_LIMITS2
+} from "./chunk-hz5d43gn.js";
+import {
+  isFileRef2
+} from "./chunk-wkv3h3q7.js";
+import {
+  createObjectOperationScope2
+} from "./chunk-2adz0h75.js";
+import {
+  ActionRunError2
+} from "./chunk-3gbefjg5.js";
+import {
+  assertJsonValue2,
+  cloneJsonValue2,
+  stableJsonStringify2
+} from "./chunk-wy0qdqfm.js";
+import {
+  isArtifactKind
+} from "./chunk-d7vyc7k6.js";
+
+// src/storage/action-runs/idempotency.ts
+function actionSubjectsEqual(left, right) {
+  if (left.kind !== right.kind)
+    return false;
+  if (left.kind === "none")
+    return true;
+  if (right.kind === "none")
+    return false;
+  return left.objectTypeId === right.objectTypeId && left.primaryId === right.primaryId;
+}
+function actionRunParamsEqual(left, right) {
+  return stableJsonStringify2(left) === stableJsonStringify2(right);
+}
+function actionRunRequestsEqual(left, right) {
+  return left.actionId === right.actionId && actionSubjectsEqual(left.subject, right.subject) && actionRunParamsEqual(left.params, right.params);
+}
+function actionRunPhaseRecordsEqual(left, right) {
+  return actionRunParamsEqual(stripPhaseRecordCompletedAt(left), stripPhaseRecordCompletedAt(right));
+}
+function stripPhaseRecordCompletedAt(record) {
+  const { completedAt: _completedAt, ...stableRecord } = record;
+  return stableRecord;
+}
+
+// src/storage/action-runs/record.ts
+function normalizeRecordActionRunInput2(input) {
+  const label = `[Sixb] Action run '${input.id}'`;
+  for (const field of ["id", "projectId", "executionId", "actionId", "idempotencyKey"]) {
+    if (typeof input[field] !== "string" || input[field].trim().length === 0) {
+      throw new ActionRunError2(`${label} must have a nonblank ${field}.`);
+    }
+  }
+  const status = input.status;
+  if (status !== "succeeded" && status !== "failed") {
+    throw new ActionRunError2(`${label} has unknown status '${status}'.`);
+  }
+  if (!ACTION_RUN_PHASES2.includes(input.phase)) {
+    throw new ActionRunError2(`${label} has unknown phase '${input.phase}'.`);
+  }
+  if (input.phase === "effects") {
+    throw new ActionRunError2(`${label} is recorded before its effects run.`);
+  }
+  const startedAt = requireDate(input.startedAt, `${label} startedAt`);
+  const finishedAt = requireDate(input.finishedAt, `${label} finishedAt`);
+  if (finishedAt < startedAt) {
+    throw new ActionRunError2(`${label} cannot finish before it started.`);
+  }
+  assertJsonValue2(input.params, `${label} params`);
+  const fields = {
+    id: input.id,
+    projectId: input.projectId,
+    executionId: input.executionId,
+    actionId: input.actionId,
+    subject: structuredClone(input.subject),
+    phase: input.phase,
+    startedAt,
+    finishedAt,
+    params: structuredClone(input.params),
+    idempotencyKey: input.idempotencyKey,
+    ...input.writeback === undefined ? {} : { writeback: normalizeWriteback(input.writeback, label) }
+  };
+  if (input.status === "succeeded") {
+    if (input.error !== undefined) {
+      throw new ActionRunError2(`${label} succeeded, so it cannot record a failure.`);
+    }
+    return { ...fields, status: "succeeded" };
+  }
+  const error = parseActionRunFailure2(input.error, input.phase);
+  if (error.details.runId !== input.id || error.details.actionId !== input.actionId) {
+    throw new ActionRunError2(`${label} records the failure of another run.`);
+  }
+  return { ...fields, status: "failed", error };
+}
+function resolveActionRunEffects2(existing, input) {
+  const label = `[Sixb] Action run '${input.id}'`;
+  if (!existing) {
+    throw new ActionRunError2(`${label} not found for project '${input.projectId}'.`);
+  }
+  const completedAt = requireDate(input.completedAt ?? new Date, `${label} effects`);
+  const effects = input.status === "succeeded" ? { status: "succeeded", completedAt } : { status: "failed", completedAt, error: parseActionRunFailure2(input.error, "effects") };
+  if (existing.effects) {
+    if (actionRunPhaseRecordsEqual(existing.effects, effects))
+      return { run: existing, effects: null };
+    throw new ActionRunError2(`${label} already has a different effects record.`);
+  }
+  if (existing.status !== "succeeded" || existing.phase !== "commit") {
+    throw new ActionRunError2(`${label} cannot record effects: it ended '${existing.status}' in phase '${existing.phase}'.`);
+  }
+  return { run: existing, effects };
+}
+function normalizeWriteback(writeback, label) {
+  const completedAt = requireDate(writeback.completedAt, `${label} writeback`);
+  if (writeback.status === "succeeded") {
+    assertJsonValue2(writeback.result, `${label} writeback result`);
+    return { status: "succeeded", completedAt, result: cloneJsonValue2(writeback.result) };
+  }
+  return {
+    status: "failed",
+    completedAt,
+    error: parseActionRunFailure2(writeback.error, "writeback")
+  };
+}
+function requireDate(value, label) {
+  const date = value instanceof Date ? new Date(value) : new Date(Number.NaN);
+  if (!Number.isFinite(date.getTime())) {
+    throw new ActionRunError2(`${label} must be a valid date.`);
+  }
+  return date;
+}
+
+// src/storage/errors.ts
+class ObjectNotFoundError2 extends Error {
+  objectTypeId;
+  primaryId;
+  context;
+  name = "ObjectNotFoundError";
+  constructor(objectTypeId, primaryId, context) {
+    super(`[Sixb] ${context}: ${objectTypeId}:${primaryId}`);
+    this.objectTypeId = objectTypeId;
+    this.primaryId = primaryId;
+    this.context = context;
+  }
+}
+
+class ObjectStorageError2 extends Error {
+  name = "ObjectStorageError";
+}
+
+class StorageTransactionError2 extends Error {
+  name = "StorageTransactionError";
+  code;
+  cause;
+  constructor(message, options = {}) {
+    super(message);
+    this.code = options.code;
+    this.cause = options.cause;
+  }
+}
+function isStorageSerializationFailure2(error) {
+  return error instanceof StorageTransactionError2 && error.code === "serialization_failure";
+}
+
+// src/storage/activity/policy.ts
+var ACTIVITY_BATCH_LIMIT2 = 20;
+var ACTIVITY_EVENT_ID_PATTERN2 = /^[a-zA-Z0-9_-]{1,80}$/;
+var ACTIVITY_VISIT_ID_PATTERN2 = /^[a-zA-Z0-9_-]{1,128}$/;
+var ACTIVITY_HOSTNAME_PATTERN2 = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)*[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+var ACTIVITY_LABEL_PATTERN2 = /^[^\x00-\x1f\x7f]*$/;
+var ACTIVITY_LABEL_MAX_LENGTH2 = 100;
+var ACTIVITY_REFERRER_MAX_LENGTH2 = 253;
+var ACTIVITY_ROUTE_MAX_LENGTH2 = 512;
+var ACTIVITY_ID_MAX_LENGTH2 = 256;
+var ACTIVITY_INTERACTION_NAME_PATTERN2 = /^(?!.*\d{4})[a-z][a-z0-9_-]{0,39}(?:\.[a-z][a-z0-9_-]{0,39})*$/;
+var ACTIVITY_INTERACTION_NAME_MAX_LENGTH2 = 100;
+var ACTIVITY_MAX_PERIOD_MS2 = 31 * 24 * 60 * 60000;
+var ACTIVITY_MAX_PAGE_SIZE2 = 100;
+var ACTIVITY_SOURCE_LIMIT_PER_MINUTE = 120;
+var ACTIVITY_MIN_IDLE_TIMEOUT_MS = 60000;
+var ACTIVITY_MAX_VISIT_MS2 = 24 * 60 * 60000;
+var QUOTA_WINDOW_MS = 60000;
+var DAY_MS = 86400000;
+var ATTRIBUTION_KEYS = ["source", "medium", "campaign", "referrer"];
+function validateActivityEvents(events) {
+  if (!Array.isArray(events) || events.length === 0 || events.length > ACTIVITY_BATCH_LIMIT2) {
+    throw new Error(`[Sixb] Activity batches must contain 1 to ${ACTIVITY_BATCH_LIMIT2} events.`);
+  }
+  const ids = new Set;
+  for (const event of events) {
+    if (!event || typeof event.id !== "string" || !ACTIVITY_EVENT_ID_PATTERN2.test(event.id) || ids.has(event.id)) {
+      throw new Error("[Sixb] Activity event ids must be unique, nonempty identifiers.");
+    }
+    ids.add(event.id);
+    if (event.type !== "page.view" && event.type !== "visit.activity" && event.type !== "ui.interaction") {
+      throw new Error("[Sixb] Unknown activity event type.");
+    }
+    if (!isActivityRoutePattern2(event.route)) {
+      throw new Error("[Sixb] Activity routes must be normalized file-router patterns without URL parameters.");
+    }
+    if (event.type !== "ui.interaction") {
+      serializeActivityAttribution2(event.attribution);
+      continue;
+    }
+    if (!isActivityInteractionName(event.name)) {
+      throw new Error(`[Sixb] Activity interaction names are lowercase dotted identifiers such as "invoices.export": each segment starts with a letter, holds at most 40 characters and no run of four digits, and the name at most ${ACTIVITY_INTERACTION_NAME_MAX_LENGTH2}.`);
+    }
+    if (Reflect.get(event, "attribution") !== undefined) {
+      throw new Error("[Sixb] Activity interactions carry no attribution.");
+    }
+  }
+}
+function validateActivityAppend2(input) {
+  validateActivityEvents(input.events);
+  if (input.actor.type !== "user" && input.actor.type !== "share") {
+    throw new Error("[Sixb] Invalid activity actor.");
+  }
+  const actorId = input.actor.type === "user" ? input.actor.userId : input.actor.grantId;
+  for (const value of [input.projectId, input.sessionId, input.newVisitId, actorId]) {
+    if (typeof value !== "string" || !value.trim() || value.length > ACTIVITY_ID_MAX_LENGTH2) {
+      throw new Error("[Sixb] Invalid activity identity.");
+    }
+  }
+  if (!Number.isFinite(input.now.getTime()) || !Number.isSafeInteger(input.idleTimeoutMs) || input.idleTimeoutMs < ACTIVITY_MIN_IDLE_TIMEOUT_MS) {
+    throw new Error("[Sixb] Invalid activity clock or inactivity window.");
+  }
+}
+function planActivityAppend2(input, current, stored) {
+  const fresh = input.events.filter((event) => !isRetry(event, stored));
+  if (fresh.length === 0) {
+    return { status: "duplicate" };
+  }
+  const now = Math.max(input.now.getTime(), current?.lastSeenAt ?? 0);
+  const windowOpen = current !== undefined && now - current.windowStart < QUOTA_WINDOW_MS;
+  const windowStart = windowOpen ? current.windowStart : now;
+  const windowCount = windowOpen ? current.windowCount : 0;
+  if (windowCount + fresh.length > ACTIVITY_SOURCE_LIMIT_PER_MINUTE) {
+    return { status: "throttled" };
+  }
+  const continued = continuesVisit(current, now, input.idleTimeoutMs) ? current : undefined;
+  const visitId = continued?.visitId ?? input.newVisitId;
+  const previousSequence = continued?.sequence ?? 0;
+  const pageViews = [];
+  const interactions = [];
+  let sequence = previousSequence;
+  fresh.forEach((event, index) => {
+    const receivedAt = new Date(now);
+    const opensVisit = !continued && index === 0;
+    if (event.type === "ui.interaction") {
+      if (opensVisit) {
+        sequence += 1;
+        pageViews.push({
+          id: `${event.id}.page`,
+          visitId,
+          sequence,
+          route: event.route,
+          receivedAt,
+          attribution: {}
+        });
+      }
+      sequence += 1;
+      interactions.push({
+        id: event.id,
+        visitId,
+        sequence,
+        name: event.name,
+        route: event.route,
+        receivedAt
+      });
+      return;
+    }
+    if (event.type === "page.view" || opensVisit) {
+      sequence += 1;
+      pageViews.push({
+        id: event.id,
+        visitId,
+        sequence,
+        route: event.route,
+        receivedAt,
+        ...event.attribution === undefined ? {} : { attribution: structuredClone(event.attribution) }
+      });
+    }
+  });
+  const first = fresh[0];
+  const arrival = first?.type === "ui.interaction" ? {} : first?.attribution;
+  return {
+    status: "append",
+    newVisit: continued ? null : { attribution: cloneAttribution(arrival) },
+    pageViews,
+    interactions,
+    accepted: fresh.length,
+    state: {
+      visitId,
+      visitStartedAt: continued ? continued.visitStartedAt : now,
+      lastSeenAt: now,
+      sequence,
+      windowStart,
+      windowCount: windowCount + fresh.length
+    }
+  };
+}
+function continuesVisit(current, now, idleTimeoutMs) {
+  return current !== undefined && current.visitStartedAt !== null && now - current.lastSeenAt < idleTimeoutMs && now - current.visitStartedAt < ACTIVITY_MAX_VISIT_MS2;
+}
+function isRetry(event, stored) {
+  const previous = stored.find((candidate) => candidate.id === event.id);
+  if (!previous) {
+    return false;
+  }
+  const same = event.type === "ui.interaction" ? event.name === previous.name && event.route === previous.route : previous.name === undefined && event.route === previous.route && serializeActivityAttribution2(event.attribution) === serializeActivityAttribution2(previous.attribution);
+  if (!same) {
+    throw new Error("[Sixb] Activity event id was reused with different content.");
+  }
+  return true;
+}
+function activityCalendarDays2(period, visits, pageViewsByDay) {
+  const visitsByDay = new Map;
+  const from = period.from.getTime();
+  const last = period.to.getTime() - 1;
+  for (const visit of visits) {
+    const firstDay = Math.floor(Math.max(visit.startedAt.getTime(), from) / DAY_MS);
+    const lastDay = Math.floor(Math.min(visit.lastSeenAt.getTime(), last) / DAY_MS);
+    for (let day = firstDay;day <= lastDay; day++) {
+      const key = activityDay(day * DAY_MS);
+      visitsByDay.set(key, (visitsByDay.get(key) ?? 0) + 1);
+    }
+  }
+  const days = new Set([...visitsByDay.keys(), ...pageViewsByDay.keys()]);
+  return [...days].sort().map((day) => ({
+    day,
+    visits: visitsByDay.get(day) ?? 0,
+    pageViews: pageViewsByDay.get(day) ?? 0
+  }));
+}
+function activityDay(at) {
+  return new Date(at).toISOString().slice(0, 10);
+}
+function activityActor2(type, userId, grantId) {
+  if (type === "user" && userId) {
+    return { type, userId };
+  }
+  if (type === "share" && grantId) {
+    return { type, grantId };
+  }
+  throw new Error("[Sixb] Stored activity actor is invalid.");
+}
+function serializeActivityAttribution2(value) {
+  if (value === undefined) {
+    return null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("[Sixb] Invalid activity attribution.");
+  }
+  if (Object.keys(value).some((key) => !ATTRIBUTION_KEYS.some((field) => field === key))) {
+    throw new Error("[Sixb] Unknown activity attribution field.");
+  }
+  const result = {};
+  for (const key of ATTRIBUTION_KEYS) {
+    const text = Reflect.get(value, key);
+    if (text === undefined) {
+      continue;
+    }
+    const maxLength = key === "referrer" ? ACTIVITY_REFERRER_MAX_LENGTH2 : ACTIVITY_LABEL_MAX_LENGTH2;
+    if (!isAttributionLabel(text, maxLength)) {
+      throw new Error("[Sixb] Activity attribution requires bounded, nonempty labels.");
+    }
+    if (key === "referrer" && !ACTIVITY_HOSTNAME_PATTERN2.test(text)) {
+      throw new Error("[Sixb] Activity referrer must be a hostname, not a URL.");
+    }
+    result[key] = text;
+  }
+  return JSON.stringify(result);
+}
+function parseActivityAttribution2(value) {
+  if (value === null) {
+    return null;
+  }
+  const data = JSON.parse(value);
+  serializeActivityAttribution2(data);
+  return data;
+}
+function cloneAttribution(value) {
+  return value === undefined ? null : structuredClone(value);
+}
+function isAttributionLabel(value, maxLength) {
+  return typeof value === "string" && value.length > 0 && value.length <= maxLength && value === value.trim() && ACTIVITY_LABEL_PATTERN2.test(value);
+}
+function isActivityInteractionName(value) {
+  return typeof value === "string" && value.length <= ACTIVITY_INTERACTION_NAME_MAX_LENGTH2 && ACTIVITY_INTERACTION_NAME_PATTERN2.test(value);
+}
+function isActivityRoutePattern2(value) {
+  return typeof value === "string" && value.length <= ACTIVITY_ROUTE_MAX_LENGTH2 && value.startsWith("/") && !value.includes("//") && !/[?#%\s\x00-\x1f]/.test(value);
+}
+
+// src/storage/artifacts/errors.ts
+class ArtifactStorageError extends Error {
+  code;
+  latest;
+  name = "ArtifactStorageError";
+  constructor(code, message, latest) {
+    super(message);
+    this.code = code;
+    this.latest = latest;
+  }
+}
+
+// src/storage/artifacts/record.ts
+function parseArtifactRow2(row) {
+  const id = text(row.id, "id", "artifact");
+  const where = `artifact '${id}'`;
+  const kind = row.kind;
+  if (!isArtifactKind(kind))
+    throw corrupt(where, "kind is not an artifact kind");
+  return {
+    projectId: text(row.projectId, "projectId", where),
+    id,
+    kind,
+    title: text(row.title, "title", where),
+    owner: principal(row.ownerPrincipalType, row.ownerPrincipalId, "owner", where),
+    latestVersion: positiveInteger(row.latestVersion, "latestVersion", where),
+    createdAt: date(row.createdAt, "createdAt", where),
+    updatedAt: date(row.updatedAt, "updatedAt", where)
+  };
+}
+function parseArtifactVersionRow2(row) {
+  const artifactId = text(row.artifactId, "artifactId", "artifact version");
+  const version = positiveInteger(row.version, "version", `artifact '${artifactId}'`);
+  const where = `artifact '${artifactId}' version ${version}`;
+  const originThreadId = row.originThreadId;
+  const originRunId = row.originRunId;
+  if (originThreadId == null !== (originRunId == null)) {
+    throw corrupt(where, "origin needs both a thread and a run");
+  }
+  return {
+    projectId: text(row.projectId, "projectId", where),
+    artifactId,
+    version,
+    title: text(row.title, "title", where),
+    entry: text(row.entry, "entry", where),
+    files: files(json(row.files, "files", where), where),
+    outline: outline(json(row.outline, "outline", where), where),
+    references: references(json(row.refs, "refs", where), where),
+    author: principal(row.authorPrincipalType, row.authorPrincipalId, "author", where),
+    ...originThreadId == null ? {} : {
+      origin: {
+        threadId: text(originThreadId, "originThreadId", where),
+        runId: text(originRunId, "originRunId", where)
+      }
+    },
+    createdAt: date(row.createdAt, "createdAt", where)
+  };
+}
+function parseArtifactFrameGrantRow2(row) {
+  const artifactId = text(row.artifactId, "artifactId", "artifact frame grant");
+  const where = `frame grant for artifact '${artifactId}'`;
+  return {
+    projectId: text(row.projectId, "projectId", where),
+    tokenHash: text(row.tokenHash, "tokenHash", where),
+    artifactId,
+    version: positiveInteger(row.version, "version", where),
+    targets: frameTargets(json(row.targets, "targets", where), where),
+    createdAt: date(row.createdAt, "createdAt", where),
+    expiresAt: date(row.expiresAt, "expiresAt", where)
+  };
+}
+function parseArtifactStateRow2(row) {
+  const key = text(row.key, "key", "artifact state");
+  const where = `artifact state '${key}'`;
+  const sizeBytes = Number(row.sizeBytes);
+  if (!Number.isSafeInteger(sizeBytes) || sizeBytes < 0) {
+    throw corrupt(where, "sizeBytes is not a byte count");
+  }
+  return {
+    key,
+    value: text(row.value, "value", where),
+    sizeBytes,
+    updatedAt: date(row.updatedAt, "updatedAt", where)
+  };
+}
+function artifactStateBytes2(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function checkArtifactStateWrite2(input) {
+  const limits = ARTIFACT_STATE_LIMITS2;
+  if (input.valueBytes > limits.maxValueBytes) {
+    throw artifactStorageErrors2.stateFull(`[Sixb] '${input.key}' is ${kilobytes(input.valueBytes)}; a page keeps at most ${kilobytes(limits.maxValueBytes)} under one key.`);
+  }
+  if (input.others.keys + 1 > limits.maxKeys) {
+    throw artifactStorageErrors2.stateFull(`[Sixb] A page keeps at most ${limits.maxKeys} keys for each reader: delete one before keeping '${input.key}'.`);
+  }
+  if (input.others.bytes + input.valueBytes > limits.maxBytes) {
+    throw artifactStorageErrors2.stateFull(`[Sixb] A page keeps at most ${kilobytes(limits.maxBytes)} for each reader; '${input.key}' would take it to ${kilobytes(input.others.bytes + input.valueBytes)}.`);
+  }
+}
+function kilobytes(bytes) {
+  return `${Math.ceil(bytes / 1024).toLocaleString("en-US")} KB`;
+}
+var artifactStorageErrors2 = {
+  exists: (id) => new ArtifactStorageError("artifact_exists", `[Sixb] Artifact '${id}' already exists.`),
+  notFound: (id) => new ArtifactStorageError("artifact_not_found", `[Sixb] Artifact '${id}' was not found.`),
+  kindMismatch: (id, kind, requested) => new ArtifactStorageError("artifact_kind_mismatch", `[Sixb] Artifact '${id}' is a ${kind}; it cannot take a ${requested} version.`),
+  moved: (id, baseVersion, latest) => new ArtifactStorageError("artifact_moved", `[Sixb] Artifact '${id}' is at version ${latest.version}, not version ${baseVersion}, which this publish was based on.`, latest),
+  stateFull: (message) => new ArtifactStorageError("artifact_state_full", message)
+};
+function files(value, where) {
+  if (!Array.isArray(value))
+    throw corrupt(where, "files is not a list");
+  return value.map((entry) => {
+    if (!isObject(entry) || typeof entry.path !== "string" || !isFileRef2(entry.file)) {
+      throw corrupt(where, "a file entry is not a path and a file reference");
+    }
+    return { path: entry.path, file: entry.file };
+  });
+}
+function outline(value, where) {
+  if (!isObject(value) || !isArtifactKind(value.kind)) {
+    throw corrupt(where, "outline does not name an artifact kind");
+  }
+  return value;
+}
+function references(value, where) {
+  if (!Array.isArray(value))
+    throw corrupt(where, "references is not a list");
+  return value.map((entry) => {
+    if (!isObject(entry) || typeof entry.address !== "string" || entry.as !== "embed" && entry.as !== "link" || typeof entry.at !== "string" || !Number.isSafeInteger(entry.resolvedVersion) || entry.resolvedVersion < 1) {
+      throw corrupt(where, "a reference is not an address, a verb, a place, and a version");
+    }
+    return {
+      address: entry.address,
+      as: entry.as,
+      at: entry.at,
+      resolvedVersion: entry.resolvedVersion
+    };
+  });
+}
+function frameTargets(value, where) {
+  if (!Array.isArray(value))
+    throw corrupt(where, "targets is not a list");
+  return value.map((entry) => {
+    if (!isObject(entry) || typeof entry.address !== "string" || typeof entry.artifactId !== "string" || !Number.isSafeInteger(entry.version) || entry.version < 1) {
+      throw corrupt(where, "a target is not an address, an artifact, and a version");
+    }
+    return {
+      address: entry.address,
+      artifactId: entry.artifactId,
+      version: entry.version
+    };
+  });
+}
+var PRINCIPAL_TYPES = new Set(["user", "serviceAccount", "system"]);
+function principal(type, id, column, where) {
+  if (typeof type !== "string" || !PRINCIPAL_TYPES.has(type)) {
+    throw corrupt(where, `${column} is not a principal`);
+  }
+  return { type, id: text(id, column, where) };
+}
+function json(value, column, where) {
+  if (typeof value !== "string")
+    return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw corrupt(where, `${column} is not JSON`);
+  }
+}
+function text(value, column, where) {
+  if (typeof value !== "string" || value.length === 0)
+    throw corrupt(where, `${column} is not text`);
+  return value;
+}
+function positiveInteger(value, column, where) {
+  const number = typeof value === "bigint" ? Number(value) : value;
+  if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 1) {
+    throw corrupt(where, `${column} is not a positive integer`);
+  }
+  return number;
+}
+function date(value, column, where) {
+  const parsed = value instanceof Date || typeof value === "string" ? new Date(value) : null;
+  if (!parsed || !Number.isFinite(parsed.getTime()))
+    throw corrupt(where, `${column} is not a date`);
+  return parsed;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function corrupt(where, reason) {
+  return new Error(`[Sixb] Stored ${where} is invalid: ${reason}.`);
+}
+
+// src/storage/file-download-grants/record.ts
+function parseFileDownloadGrantRow2(row) {
+  const id = text2(row.id, "id", String(row.id));
+  const file = typeof row.file === "string" ? JSON.parse(row.file) : row.file;
+  if (!isFileRef2(file))
+    throw corrupt2(id, "file is not a file reference");
+  return {
+    id,
+    projectId: text2(row.projectId, "projectId", id),
+    tokenHash: text2(row.tokenHash, "tokenHash", id),
+    file,
+    executionId: text2(row.executionId, "executionId", id),
+    createdAt: date2(row.createdAt, "createdAt", id),
+    expiresAt: date2(row.expiresAt, "expiresAt", id),
+    ...row.revokedAt == null ? {} : { revokedAt: date2(row.revokedAt, "revokedAt", id) }
+  };
+}
+function cloneFileDownloadGrantRecord(record) {
+  return structuredClone(record);
+}
+function text2(value, column, id) {
+  if (typeof value !== "string" || value.length === 0)
+    throw corrupt2(id, `${column} is not text`);
+  return value;
+}
+function date2(value, column, id) {
+  const parsed = value instanceof Date || typeof value === "string" ? new Date(value) : null;
+  if (!parsed || !Number.isFinite(parsed.getTime()))
+    throw corrupt2(id, `${column} is not a date`);
+  return parsed;
+}
+function corrupt2(id, reason) {
+  return new Error(`[Sixb] Stored file download grant '${id}' is invalid: ${reason}.`);
+}
+
+// src/storage/pipeline-runs/idempotency.ts
+function canRequeuePipelineRunAfterEnqueueFailure2(existing, input) {
+  return existing.status === "failed" && existing.error?.code === "queue.enqueue_failed" && existing.error.retryable && existing.executionId === input.executionId && existing.pipelineId === input.pipelineId;
+}
+
+// src/storage/sync-runs/idempotency.ts
+function canRequeueSyncRunAfterEnqueueFailure2(existing, input) {
+  return existing.status === "failed" && existing.error?.code === "queue.enqueue_failed" && existing.error.retryable && existing.executionId === input.executionId && existing.syncId === input.syncId && existing.datasetId === input.datasetId && existing.mode === input.mode && existing.expectedLatestVersionId === input.expectedLatestVersionId && existing.commitMessage === input.commitMessage;
+}
+
+// src/storage/transaction.ts
+function createTransactionStorageProxy2(target, isActive) {
+  const proxies = new WeakMap;
+  const objectStorage = createObjectOperationScope2(target.objects, {
+    assertAvailable: () => assertTransactionActive2(isActive),
+    run: async (operation) => {
+      assertTransactionActive2(isActive);
+      return operation();
+    }
+  });
+  const wrap = (value) => {
+    const existing = proxies.get(value);
+    if (existing)
+      return existing;
+    const proxy = new Proxy(value, {
+      get(current, property, receiver) {
+        assertTransactionActive2(isActive);
+        const result = current === target && property === "objects" ? objectStorage : Reflect.get(current, property, receiver);
+        if (typeof result === "function") {
+          return (...args) => {
+            assertTransactionActive2(isActive);
+            return result.apply(current, args);
+          };
+        }
+        if (result && typeof result === "object") {
+          return wrap(result);
+        }
+        return result;
+      }
+    });
+    proxies.set(value, proxy);
+    return proxy;
+  };
+  return wrap(target);
+}
+function assertTransactionActive2(isActive) {
+  if (!isActive()) {
+    throw new StorageTransactionError2("[Sixb] Transaction storage cannot be used after transaction completion.", { code: "transaction_inactive" });
+  }
+}
+function throwNestedStorageTransaction2() {
+  throw new StorageTransactionError2("[Sixb] Nested storage transactions are not supported yet.", {
+    code: "nested_transaction"
+  });
+}
+
+export { actionSubjectsEqual, actionRunRequestsEqual, normalizeRecordActionRunInput2, resolveActionRunEffects2, ObjectNotFoundError2, ObjectStorageError2, StorageTransactionError2, isStorageSerializationFailure2, ACTIVITY_BATCH_LIMIT2, ACTIVITY_EVENT_ID_PATTERN2, ACTIVITY_VISIT_ID_PATTERN2, ACTIVITY_HOSTNAME_PATTERN2, ACTIVITY_LABEL_PATTERN2, ACTIVITY_LABEL_MAX_LENGTH2, ACTIVITY_REFERRER_MAX_LENGTH2, ACTIVITY_ROUTE_MAX_LENGTH2, ACTIVITY_ID_MAX_LENGTH2, ACTIVITY_INTERACTION_NAME_PATTERN2, ACTIVITY_INTERACTION_NAME_MAX_LENGTH2, ACTIVITY_MAX_PERIOD_MS2, ACTIVITY_MAX_PAGE_SIZE2, ACTIVITY_MIN_IDLE_TIMEOUT_MS, ACTIVITY_MAX_VISIT_MS2, validateActivityEvents, validateActivityAppend2, planActivityAppend2, activityCalendarDays2, activityDay, activityActor2, serializeActivityAttribution2, parseActivityAttribution2, isActivityRoutePattern2, ArtifactStorageError, parseArtifactRow2, parseArtifactVersionRow2, parseArtifactFrameGrantRow2, parseArtifactStateRow2, artifactStateBytes2, checkArtifactStateWrite2, artifactStorageErrors2, parseFileDownloadGrantRow2, cloneFileDownloadGrantRecord, canRequeuePipelineRunAfterEnqueueFailure2, canRequeueSyncRunAfterEnqueueFailure2, createTransactionStorageProxy2, assertTransactionActive2, throwNestedStorageTransaction2 };
+
+//# debugId=4E442F782CC107BF64756E2164756E21