@sixb/core 0.1.20 → 0.1.21

package/dist/{chunk-0rbyz4qy.js → chunk-61y5xs4p.js}

@@ -1,30 +1,33 @@
 // @bun
 import {
   supportsDirectUpload2
-} from "./chunk-jhm3zsa7.js";
-import {
-  SecurityValidationError2
-} from "./chunk-es1gxsbf.js";
+} from "./chunk-wkv3h3q7.js";
 import {
   OntologyRegistry2
-} from "./chunk-d09tj99x.js";
+} from "./chunk-g257jwnc.js";
 import {
   captureSixbFailure2,
   isSixbError2
-} from "./chunk-8mx7qw3y.js";
+} from "./chunk-dvd2fp9q.js";
 import {
   captureExecutionScope,
   resolveExecutionScopeAuthorization,
   AuthorizationError2
-} from "./chunk-d0bqz29d.js";
+} from "./chunk-6vb4st8k.js";
+import {
+  NO_CONTRIBUTION,
+  NO_APPLIED_MARKINGS,
+  assembleAppliedMarkings,
+  withPropertyMarkings
+} from "./chunk-x0v3jd47.js";
 import {
   isMigrationCapableStorage2,
   checkStorageSchema2
-} from "./chunk-n33z5bjw.js";
+} from "./chunk-918wwnaa.js";
 import {
   SecurityRegistry,
   AuthRuntime2
-} from "./chunk-vpq4shxz.js";
+} from "./chunk-nn5xnx3s.js";
 import {
   AuthRuntimeError2,
   isMagicLinkAuthStrategy2,
@@ -40,10 +43,28 @@ import {
 } from "./chunk-29yx306f.js";
 import {
   FileUploadSessionError2
-} from "./chunk-9w055r5b.js";
+} from "./chunk-d09e3rax.js";
+import {
+  ACTIVITY_VISIT_ID_PATTERN2,
+  ACTIVITY_ID_MAX_LENGTH2,
+  ACTIVITY_MAX_PERIOD_MS2,
+  ACTIVITY_MAX_PAGE_SIZE2,
+  ACTIVITY_MIN_IDLE_TIMEOUT_MS,
+  validateActivityEvents
+} from "./chunk-tbc1ngpd.js";
 import {
-  ActionRegistry2,
   createAuthorizedObjectReader,
+  registerOntologyMutationRuntime2,
+  createOntologyMutationRuntime2,
+  decodeActivityConnectionsCursor,
+  ModelExecutionSession
+} from "./chunk-6rqgmkde.js";
+import {
+  attachSixbErrorReporter2,
+  shareSixbErrorReporter2
+} from "./chunk-cy4mbddw.js";
+import {
+  ActionRegistry2,
   DEFAULT_PROJECT_LOCALE,
   DEFAULT_PROJECT_TIME_ZONE,
   canonicalLocale,
@@ -54,16 +75,7 @@ import {
   createBoundSixb,
   ActionRunExecutor,
   registerActionRunExecutor
-} from "./chunk-6c6sn0bh.js";
-import {
-  attachSixbErrorReporter2,
-  shareSixbErrorReporter2
-} from "./chunk-fa02jy15.js";
-import {
-  registerOntologyMutationRuntime2,
-  createOntologyMutationRuntime2,
-  ModelExecutionSession
-} from "./chunk-4vyr1j8f.js";
+} from "./chunk-akzryx9h.js";
 import {
   registerConnectorConnectionCallbackProcess
 } from "./chunk-5a4a52tq.js";
@@ -78,30 +90,28 @@ import {
   isConnectorStorageError,
   storageBoundaryError,
   recoverConnectorFailure
-} from "./chunk-tg2cw67r.js";
+} from "./chunk-ky3j490c.js";
 import {
-  assertDatasetDefinition2
-} from "./chunk-0yh890a4.js";
+  assertDatasetDefinition2,
+  isDatasetPick2
+} from "./chunk-q5e5tv4b.js";
 import {
   ProjectionRegistry2,
   createOntologyMaterializer2
-} from "./chunk-hjzdd750.js";
+} from "./chunk-bk9svbcq.js";
 import {
   LoggingService2
 } from "./chunk-3qms4nax.js";
 import {
   OntologyOutboxDispatcher2,
   createDomainEventService2
-} from "./chunk-yzwja0mj.js";
+} from "./chunk-5hx48dnn.js";
 import {
   validateSchedulesAtStartup2
 } from "./chunk-nq6gpjt7.js";
-import {
-  createSandboxDefinition
-} from "./chunk-9gyp8hg1.js";
 import {
   toolsFromProjectConfig
-} from "./chunk-tpn40322.js";
+} from "./chunk-e6k4thh5.js";
 import {
   SchedulerRuntime2
 } from "./chunk-yw9pyg66.js";
@@ -113,22 +123,41 @@ import {
   validateSharesAtStartup,
   discoverOntologySources,
   discoverProjectDefinitions2
-} from "./chunk-ren4kg2j.js";
+} from "./chunk-561r0yc9.js";
 import {
   bindEmbeddingModels,
   createVectorIndexingRuntime,
   registerVectorIndexingRuntime,
   getApiPublicOrigin
-} from "./chunk-5j58wjct.js";
+} from "./chunk-858emn8m.js";
 import {
   registerProjectionRegistry2
-} from "./chunk-6p49a5cq.js";
+} from "./chunk-c1rxbz5y.js";
+import {
+  registeredSteps,
+  runStepLineages,
+  MarkingPropagation,
+  validateProjectionMarkings,
+  appliedContribution,
+  eventOriginMarkings,
+  producingPipelines,
+  sentence,
+  errorMessage,
+  registerAppliedMarkings,
+  createDatasetVersionMarkings,
+  registerDatasetVersionMarkings
+} from "./chunk-twe4dx8p.js";
 import {
   SyncValidationError2
-} from "./chunk-xfs8x8m9.js";
+} from "./chunk-0bphap9y.js";
+import {
+  SandboxError2,
+  createSandboxDefinition,
+  sandboxCredentialIssue2
+} from "./chunk-cfj9dfbb.js";
 import {
   ensureExecutionRecord2
-} from "./chunk-9dmt152s.js";
+} from "./chunk-vf57cr4t.js";
 import {
   ConnectorConnectionStorageError2,
   CONNECTOR_CONNECTION_RUN_FAILURE_CODES2
@@ -136,12 +165,15 @@ import {
 import {
   RuntimeError2
 } from "./chunk-m4ehq95f.js";
-import {
-  reportEventDeliveryFailure3
-} from "./chunk-7t429e3f.js";
 import {
   isOAuthConnectorDefinition2
 } from "./chunk-9x8dybsb.js";
+import {
+  reportEventDeliveryFailure3
+} from "./chunk-xvsc5m8n.js";
+import {
+  SecurityValidationError2
+} from "./chunk-jcfw4h7m.js";
 import {
   sameEmbeddingModel
 } from "./chunk-kyjcwqz6.js";
@@ -381,6 +413,136 @@ import { resolve as resolve2 } from "path";
 // src/runtime/host.ts
 import { resolve } from "path";
 
+// src/activity/service.ts
+import { randomUUID } from "crypto";
+var DEFAULT_IDLE_TIMEOUT_MS = 30 * 60000;
+var ACTIVITY_CONNECTION_VISITS = 5;
+var MAX_IDLE_TIMEOUT_MS = 24 * 60 * 60000;
+
+class ActivityService {
+  projectId;
+  storage;
+  now;
+  captureOptions;
+  constructor(projectId, storage, options = {}, now = () => new Date) {
+    this.projectId = projectId;
+    this.storage = storage;
+    this.now = now;
+    const idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+    if (!Number.isSafeInteger(idleTimeoutMs) || idleTimeoutMs < ACTIVITY_MIN_IDLE_TIMEOUT_MS || idleTimeoutMs > MAX_IDLE_TIMEOUT_MS) {
+      throw new Error(`[Sixb] activity.idleTimeoutMs must be an integer between ${ACTIVITY_MIN_IDLE_TIMEOUT_MS} and ${MAX_IDLE_TIMEOUT_MS} milliseconds.`);
+    }
+    this.captureOptions = Object.freeze({ enabled: options.enabled === true, idleTimeoutMs });
+    if (this.captureOptions.enabled && !storage) {
+      throw new Error("[Sixb] activity.enabled needs a storage with an activity store, such as a migrated SQLite or PostgreSQL storage.");
+    }
+  }
+  async capture(source, events) {
+    validateActivityEvents(events);
+    if (!this.captureOptions.enabled) {
+      return { status: "disabled", accepted: 0 };
+    }
+    return this.requireStorage().append({
+      projectId: this.projectId,
+      actor: source.actor,
+      sessionId: source.sessionId,
+      events,
+      now: this.now(),
+      idleTimeoutMs: this.captureOptions.idleTimeoutMs,
+      newVisitId: `visit_${randomUUID()}`
+    });
+  }
+  list(query) {
+    return this.requireStorage().list({
+      ...this.period(query),
+      limit: pageLimit(query.limit),
+      before: cursor(query.before)
+    });
+  }
+  users(query) {
+    return this.requireStorage().users({
+      ...this.period(query),
+      limit: pageLimit(query.limit),
+      before: cursor(query.before)
+    });
+  }
+  summarize(query) {
+    return this.requireStorage().summarize(this.period(query));
+  }
+  async calendar(query) {
+    validateUserId(query.userId);
+    if (!Number.isSafeInteger(query.year) || query.year < 1970 || query.year > 9998) {
+      throw new Error("[Sixb] Activity calendar year must be between 1970 and 9998.");
+    }
+    const days = await this.requireStorage().calendar({
+      projectId: this.projectId,
+      userId: query.userId,
+      from: new Date(Date.UTC(query.year, 0, 1)),
+      to: new Date(Date.UTC(query.year + 1, 0, 1))
+    });
+    return { userId: query.userId, year: query.year, days };
+  }
+  readWithSession(input) {
+    if (typeof input.id !== "string" || !ACTIVITY_VISIT_ID_PATTERN2.test(input.id)) {
+      throw new Error("[Sixb] Invalid activity visit id.");
+    }
+    return this.requireStorage().read({
+      projectId: this.projectId,
+      id: input.id,
+      limit: input.limit
+    });
+  }
+  connectionsQuery(query) {
+    validateUserId(query.userId);
+    return {
+      userId: query.userId,
+      limit: pageLimit(query.limit ?? 20),
+      ...query.cursor === undefined ? {} : { before: decodeActivityConnectionsCursor(query.cursor) }
+    };
+  }
+  sessionVisits(input) {
+    return this.requireStorage().sessionVisits({
+      ...input,
+      projectId: this.projectId,
+      limit: ACTIVITY_CONNECTION_VISITS
+    });
+  }
+  period(query) {
+    if (query.userId !== undefined) {
+      validateUserId(query.userId);
+    }
+    const from = query.from.getTime();
+    const to = query.to.getTime();
+    if (!Number.isFinite(from) || !Number.isFinite(to) || from >= to || to - from > ACTIVITY_MAX_PERIOD_MS2) {
+      throw new Error("[Sixb] Activity queries require an ordered period of at most 31 days.");
+    }
+    return { projectId: this.projectId, from: query.from, to: query.to, userId: query.userId };
+  }
+  requireStorage() {
+    if (!this.storage) {
+      throw new Error("[Sixb] This project's storage has no activity store.");
+    }
+    return this.storage;
+  }
+}
+function validateUserId(value) {
+  if (typeof value !== "string" || !value.trim() || value.length > ACTIVITY_ID_MAX_LENGTH2) {
+    throw new Error(`[Sixb] Activity userId must be a nonempty user id of at most ${ACTIVITY_ID_MAX_LENGTH2} characters.`);
+  }
+}
+function cursor(value) {
+  if (value && (!Number.isFinite(value.at.getTime()) || !value.id.trim() || value.id.length > ACTIVITY_ID_MAX_LENGTH2)) {
+    throw new Error("[Sixb] Invalid activity cursor.");
+  }
+  return value;
+}
+function pageLimit(value = 50) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > ACTIVITY_MAX_PAGE_SIZE2) {
+    throw new Error(`[Sixb] Activity page size must be between 1 and ${ACTIVITY_MAX_PAGE_SIZE2}.`);
+  }
+  return value;
+}
+
 // src/connectors/credentials.ts
 import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
 function createConnectorCredentialProtectorFromKey(encodedKey) {
@@ -469,10 +631,10 @@ function assertNonblank(value, field) {
 }
 
 // src/connectors/connections/service.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 
 // src/connectors/connections/authorizations.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/connectors/connections/validation.ts
 import { createHash } from "crypto";
@@ -714,7 +876,7 @@ class ConnectorCredentialCodec {
 }
 
 // src/connectors/connections/credential-mutations.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/connectors/connections/provider-operation.ts
 async function runBoundedConnectorProviderOperation(options, run, interruptionError = createAmbiguousProviderOperationError) {
@@ -778,7 +940,7 @@ class ConnectorCredentialMutationCoordinator {
     this.operationTimeoutMs = positiveDuration(options.operationTimeoutMs, "credential mutation timeout");
     this.hostSignal = options.hostSignal;
     this.discoverReauthorizationAccounts = options.discoverReauthorizationAccounts;
-    this.holderId = options.holderId ?? `connector-service-${randomUUID()}`;
+    this.holderId = options.holderId ?? `connector-service-${randomUUID2()}`;
   }
   async claimCredentialMutation(connectorId, initial, kind, expectedConnectionIds) {
     const waitDeadline = Date.now() + MUTATION_WAIT_MS;
@@ -790,7 +952,7 @@ class ConnectorCredentialMutationCoordinator {
         connectorId,
         authorizationId: authorization.id,
         expectedRevision: authorization.revision,
-        mutation: { id: `ccm_${randomUUID()}`, kind, holderId: this.holderId },
+        mutation: { id: `ccm_${randomUUID2()}`, kind, holderId: this.holderId },
         ...expectedConnectionIds === undefined ? {} : { expectedConnectionIds },
         leaseDurationMs: this.leaseDurationMs,
         operationTimeoutMs: this.operationTimeoutMs
@@ -1279,7 +1441,7 @@ class DefaultConnectorAuthorizationLifecycle {
   }
   async completeNewAuthorization(input) {
     this.assertRegistered(input.definition);
-    const authorizationId = `cau_${randomUUID2()}`;
+    const authorizationId = `cau_${randomUUID3()}`;
     const credentials = await this.exchangeAuthorizationCode(input.definition, input.code, input.codeVerifier, input.redirectUri, input.callbackParameters);
     const credentialsEnvelope = await this.credentials.seal(input.definition.id, authorizationId, credentials);
     let pending;
@@ -1548,7 +1710,7 @@ function sameConnectorConnectionCommandActor(left, right) {
 }
 
 // src/connectors/connections/request.ts
-import { createHash as createHash2, randomBytes as randomBytes2, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash2, randomBytes as randomBytes2, randomUUID as randomUUID4 } from "crypto";
 
 // src/connectors/connections/views.ts
 function assertConnectorConnectionSelector(selector) {
@@ -1613,7 +1775,7 @@ class ConnectorAuthorizationRequestHandler {
     validateCallbackParameterNames(definition.adapter.authentication.callbackParameters);
     const redirectUri = normalizedHttpUrl(input.redirectUri, "OAuth callback URL");
     const reauthorization = await this.prepareReauthorization(definition, actor, input.reauthorizationId);
-    const attemptId = `cat_${randomUUID3()}`;
+    const attemptId = `cat_${randomUUID4()}`;
     const state = `${attemptId}.${randomBytes2(32).toString("base64url")}`;
     const codeVerifier = connectorPkceEnabled(definition.adapter.authentication.pkce) ? randomBytes2(32).toString("base64url") : undefined;
     const codeChallenge = codeVerifier === undefined ? undefined : createHash2("sha256").update(codeVerifier).digest("base64url");
@@ -1795,7 +1957,7 @@ function requireConnectorConnectionStorage(storage) {
 }
 
 // src/connectors/connections/runs.ts
-import { randomBytes as randomBytes3, randomUUID as randomUUID4 } from "crypto";
+import { randomBytes as randomBytes3, randomUUID as randomUUID5 } from "crypto";
 var CLEANUP_RETRY_DELAY_MS = 30000;
 var MAX_TIMER_DELAY_MS = 2147483647;
 
@@ -1822,7 +1984,7 @@ class ConnectorConnectionRunService {
     this.now = options.now;
   }
   async startSelection(command, connectorId, input) {
-    const runId = `ccr_${randomUUID4()}`;
+    const runId = `ccr_${randomUUID5()}`;
     let run;
     try {
       run = await this.storage.transaction(async (tx) => {
@@ -1847,7 +2009,7 @@ class ConnectorConnectionRunService {
   async start(command, connectorId, input) {
     const returnTo = normalizedHttpUrl(input.returnTo, "connector return URL");
     const prepared = await this.requests.prepareAuthorizationRequest(command, connectorId, input);
-    const runId = `ccr_${randomUUID4()}`;
+    const runId = `ccr_${randomUUID5()}`;
     const callbackBinding = randomBytes3(32).toString("base64url");
     let expiresAt;
     try {
@@ -1988,7 +2150,7 @@ class ConnectorConnectionRunService {
     let selected;
     try {
       selected = await this.connectionStorage.putConnectionFromRun({
-        id: `ccn_${randomUUID4()}`,
+        id: `ccn_${randomUUID5()}`,
         projectId: this.projectId,
         connectorId: definition.id,
         runId: run.id,
@@ -2028,7 +2190,7 @@ class ConnectorConnectionRunService {
           stateHash: hashSecret(state),
           callbackBindingHash: hashSecret(callbackBinding),
           redirectUri,
-          processingId: `ccp_${randomUUID4()}`,
+          processingId: `ccp_${randomUUID5()}`,
           processingTtlMs: this.processingTtlMs
         });
         if (!result || result.type === "expired")
@@ -2497,7 +2659,7 @@ class ConnectorConnectionService {
     let result;
     try {
       result = await this.connectionStorage.putConnection({
-        id: `ccn_${randomUUID5()}`,
+        id: `ccn_${randomUUID6()}`,
         projectId: this.projectId,
         connectorId: definition.id,
         owner: input.owner,
@@ -2836,6 +2998,14 @@ class OntologyMaintenance {
         limit: this.cleanupLimit
       }), failures, 0);
     }
+    const artifacts = this.storage.artifacts;
+    if (artifacts) {
+      await captureFailure(() => artifacts.deleteExpiredFrameGrants({
+        projectId: this.projectId,
+        expiredBefore: started,
+        limit: this.cleanupLimit
+      }), failures, 0);
+    }
     return {
       publishedOutboxRowsDeleted,
       terminalSourceRowsDeleted: terminalSources.rowsDeleted + abandonedSources.rowsDeleted + spentPlanRows,
@@ -2918,7 +3088,7 @@ class OntologyMaintenance {
       lastCompletedAt: completed.toISOString(),
       lastDurationMs: Math.max(0, completed.getTime() - input.started.getTime()),
       consecutiveFailures: failure ? this.snapshot.consecutiveFailures + 1 : 0,
-      lastError: failure ? errorMessage(failure) : null,
+      lastError: failure ? errorMessage2(failure) : null,
       outbox: input.outbox,
       cleanup: input.cleanup
     };
@@ -2991,9 +3161,9 @@ function assertNonblank2(value, name) {
     throw new Error(`[Sixb] Ontology maintenance ${name} must not be blank.`);
   }
 }
-function errorMessage(error) {
+function errorMessage2(error) {
   if (error instanceof AggregateError) {
-    return [...error.errors].map(errorMessage).join(" | ").slice(0, 2000);
+    return [...error.errors].map(errorMessage2).join(" | ").slice(0, 2000);
   }
   const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
   return message.slice(0, 2000);
@@ -3027,7 +3197,7 @@ async function captureFailure(run, failures, fallback) {
   }
 }
 // src/models/execution/reranking.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 function bindRerankingModels(catalog, session) {
   if (!catalog)
     return;
@@ -3059,7 +3229,7 @@ async function executeReranking(session, binding, input) {
   const encoder = new TextEncoder;
   const queryBytes = encoder.encode(query).byteLength;
   const tokens = documents.reduce((sum, text) => sum + Math.ceil((queryBytes + encoder.encode(text).byteLength) / 4), 0);
-  const callId = `call_${randomUUID6()}`;
+  const callId = `call_${randomUUID7()}`;
   await accounting.admitCall({
     callId,
     providerId: model.providerId,
@@ -3183,11 +3353,246 @@ function settled(promise) {
   });
 }
 
+// src/security/applied-markings.ts
+var EVENT_ORIGINS_KEPT = 64;
+var APPLIED_MARKINGS_FRESH_MS = 5000;
+var APPLIED_MARKINGS_MAX_AGE_MS = 1e4;
+function createAppliedMarkings(options) {
+  const maxAgeMs = options.maxAgeMs ?? APPLIED_MARKINGS_MAX_AGE_MS;
+  const freshMs = Math.min(APPLIED_MARKINGS_FRESH_MS, maxAgeMs / 2);
+  const now = options.now ?? (() => performance.now());
+  const versionMarkings = options.versionMarkings;
+  let pipelineOf;
+  let snapshot;
+  let fingerprint;
+  let refreshedAt = 0;
+  let states = new Map;
+  let generation = 0;
+  let refreshedGeneration = -1;
+  let inflight;
+  let latestRun = 0;
+  let failing = false;
+  const warned = new Set;
+  const refresh = () => {
+    if (inflight)
+      return inflight;
+    latestRun += 1;
+    const run = latestRun;
+    let timer;
+    const deadline = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        latestRun += 1;
+        reject(new Error(`[Sixb] Reading the dataset versions projections applied took longer than ${maxAgeMs / 1000}s.`));
+      }, maxAgeMs);
+      timer.unref?.();
+    });
+    const work = read(run);
+    work.catch(() => {});
+    inflight = Promise.race([work, deadline]).finally(() => {
+      clearTimeout(timer);
+      inflight = undefined;
+    });
+    return inflight;
+  };
+  const read = async (run) => {
+    const startedAt = now();
+    const startedGeneration = generation;
+    const active = await options.sources.listActive({ projectId: options.projectId });
+    const applied = new Map(active.map((source) => [source.source.projectionId, source]));
+    const projections = [
+      ...options.projections.listObjects(),
+      ...options.projections.listLinks()
+    ];
+    const next = new Map;
+    await Promise.all(projections.map(async (projection) => {
+      const projectionId = projection.id;
+      const source = applied.get(projectionId);
+      if (!source)
+        return;
+      const key = JSON.stringify([
+        source.datasetVersion.datasetId,
+        source.datasetVersion.versionId,
+        source.projectionRevision
+      ]);
+      const previous = states.get(projectionId);
+      if (previous && previous.key === key && !previous.retry) {
+        next.set(projectionId, previous);
+        return;
+      }
+      const version = await readVersion(source.datasetVersion);
+      pipelineOf ??= producingPipelines(options.pipelines);
+      const contribution = appliedContribution(projection, source, version, {
+        ontology: options.ontology,
+        revisionOf: options.revisionOf,
+        everyMarking: versionMarkings.everyMarking(),
+        pipelineOf
+      });
+      next.set(projectionId, { key, retry: version.kind !== "read", contribution });
+    }));
+    if (run !== latestRun)
+      return;
+    states = next;
+    failing = false;
+    publish(next);
+    refreshedAt = startedAt;
+    refreshedGeneration = startedGeneration;
+  };
+  const readVersion = async (ref) => {
+    try {
+      const version = await options.lakeStorage.getVersion(ref.datasetId, ref.versionId);
+      if (!version)
+        return { kind: "missing" };
+      return { kind: "read", version, classification: versionMarkings.classify(version) };
+    } catch (error) {
+      return { kind: "failed", error };
+    }
+  };
+  const publish = (next) => {
+    const contributions = [...next].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).flatMap(([, state]) => state.contribution === NO_CONTRIBUTION ? [] : [state.contribution]);
+    const nextFingerprint = JSON.stringify(contributions);
+    if (snapshot && nextFingerprint === fingerprint)
+      return;
+    snapshot = assembleAppliedMarkings(contributions);
+    fingerprint = nextFingerprint;
+    const sealed = new Set(snapshot.notices.filter((notice) => notice.sealed).map((notice) => notice.projectionId));
+    for (const projectionId of warned)
+      if (!sealed.has(projectionId))
+        warned.delete(projectionId);
+    for (const notice of snapshot.notices) {
+      if (!notice.sealed || warned.has(notice.projectionId))
+        continue;
+      warned.add(notice.projectionId);
+      console.warn(notice.message);
+    }
+  };
+  const refreshBehind = () => {
+    if (inflight)
+      return;
+    refresh().catch((error) => {
+      if (failing)
+        return;
+      failing = true;
+      console.warn(`[Sixb] Could not read the dataset versions projections applied: ${sentence(errorMessage(error))} Reads keep the markings read before for up to ${maxAgeMs / 1000}s, then fail until it succeeds.`);
+    });
+  };
+  const current = async () => {
+    if (versionMarkings.everyMarking().size === 0)
+      return NO_APPLIED_MARKINGS;
+    for (let attempt = 0;attempt < 3; attempt += 1) {
+      if (snapshot && refreshedGeneration === generation) {
+        const age = now() - refreshedAt;
+        if (age < freshMs)
+          return snapshot;
+        if (age <= maxAgeMs) {
+          refreshBehind();
+          return snapshot;
+        }
+      }
+      try {
+        await refresh();
+      } catch (error) {
+        if (snapshot && now() - refreshedAt <= maxAgeMs)
+          return snapshot;
+        throw new Error(`[Sixb] Cannot read the dataset versions projections applied, so markings cannot be enforced: ${errorMessage(error)}`, { cause: error });
+      }
+    }
+    if (!snapshot)
+      throw new Error("[Sixb] Applied markings were not read.");
+    return snapshot;
+  };
+  const originVersions = new Map;
+  const readOriginVersion = (origin) => {
+    const key = JSON.stringify([origin.datasetId, origin.datasetVersionId]);
+    let version = originVersions.get(key);
+    if (version) {
+      originVersions.delete(key);
+    } else {
+      const read = readVersion({ datasetId: origin.datasetId, versionId: origin.datasetVersionId });
+      read.then((result) => {
+        if (result.kind === "failed" && originVersions.get(key) === read)
+          originVersions.delete(key);
+      });
+      version = read;
+    }
+    keep(originVersions, key, version);
+    return version;
+  };
+  const combined = new WeakMap;
+  const forEventOrigin = async (snapshot, origin) => {
+    const projection = options.projections.listObjects().find((candidate) => candidate.id === origin.projectionId);
+    if (!projection)
+      return snapshot;
+    const read = await readOriginVersion(origin);
+    const key = JSON.stringify([
+      origin.projectionId,
+      origin.datasetId,
+      origin.datasetVersionId,
+      origin.objectTypeId,
+      read.kind
+    ]);
+    let bySnapshot = combined.get(snapshot);
+    const cached = bySnapshot?.get(key);
+    if (cached)
+      return cached;
+    const result = withPropertyMarkings(snapshot, eventOriginMarkings(projection, origin, read, {
+      ontology: options.ontology,
+      everyMarking: versionMarkings.everyMarking()
+    }));
+    if (read.kind !== "failed") {
+      bySnapshot ??= new Map;
+      combined.set(snapshot, bySnapshot);
+      keep(bySnapshot, key, result);
+    }
+    return result;
+  };
+  const earlier = new WeakMap;
+  const forEarlierValues = (snapshot, objectTypeId) => {
+    let byType = earlier.get(snapshot);
+    const cached = byType?.get(objectTypeId);
+    if (cached)
+      return cached;
+    const primary = options.ontology.getObjectTypeById(objectTypeId)?.properties.find((property) => property.primary)?.id;
+    const projected = options.projections.listObjects().filter((projection) => projection.objectTypeId === objectTypeId).flatMap((projection) => Object.keys(projection.properties));
+    const markings = [...versionMarkings.everyMarking()].sort();
+    const result = withPropertyMarkings(snapshot, [...new Set(projected)].filter((propertyId) => propertyId !== primary).map((propertyId) => ({ objectTypeId, propertyId, markings })));
+    byType ??= new Map;
+    earlier.set(snapshot, byType);
+    keep(byType, objectTypeId, result);
+    return result;
+  };
+  return {
+    forEventOrigin,
+    forEarlierValues,
+    affects: (clearances) => {
+      for (const markingId of versionMarkings.everyMarking()) {
+        if (!clearances.has(markingId))
+          return true;
+      }
+      return false;
+    },
+    current,
+    invalidate: () => {
+      generation += 1;
+    }
+  };
+}
+function keep(map, key, value) {
+  map.set(key, value);
+  if (map.size <= EVENT_ORIGINS_KEPT)
+    return;
+  const oldest = map.keys().next().value;
+  if (oldest !== undefined)
+    map.delete(oldest);
+}
+
 // src/agents/skills.ts
 function createAgentSkillCatalog(definitions) {
   const skills = Object.freeze([...definitions ?? []]);
   const skillsByName = new Map;
   for (const skill of skills) {
+    if (skill.name.startsWith("sixb-")) {
+      throw new RuntimeError2(`[Sixb] Agent Skill name '${skill.name}' uses the reserved 'sixb-' prefix.`);
+    }
     if (skillsByName.has(skill.name)) {
       throw new RuntimeError2(`[Sixb] Duplicate Agent Skill name: ${skill.name}`);
     }
@@ -3209,6 +3614,17 @@ function createAgentToolCatalog(definitions) {
   });
 }
 
+// src/datasets/column-index.ts
+var indexes = new WeakMap;
+function columnsByName(dataset) {
+  let index = indexes.get(dataset);
+  if (!index) {
+    index = new Map(dataset.schema.columns.map((column) => [column.name, column]));
+    indexes.set(dataset, index);
+  }
+  return index;
+}
+
 // src/ontology/docs.ts
 function createOntologyDocsCatalog(input) {
   const modules = input.docs?.modules ?? [];
@@ -3326,8 +3742,9 @@ function byPath(left, right) {
 function validateMarkingsAtStartup(input) {
   validatePropertyMarkings(input.ontology, input.markingIds);
   validateColumnMarkings(input.datasetsById, input.markingIds);
-  rejectPipelineStepsOverMarkedColumns(input.pipelines, input.datasetsById);
-  validateProjectionMarkings(input.projections, input.ontology, input.datasetsById);
+  const runLineageOf = runStepLineages(input.datasetsById);
+  const markings = new MarkingPropagation(input.datasetsById, registeredSteps(input.pipelines)).derive((entry) => runLineageOf(entry) ?? null);
+  validateProjectionMarkings(input.projections, input.ontology, markings);
 }
 function validatePropertyMarkings(ontology, markingIds) {
   for (const objectType of ontology.listObjectTypes()) {
@@ -3362,9 +3779,19 @@ function assertSubtypeKeepsParentMarkings(objectType, ontology) {
   const parent = ontology.getObjectTypeById(objectType.extends);
   if (!parent)
     return;
+  let propertiesById;
   for (const parentProperty of parent.properties) {
-    const property = objectType.properties.find((candidate) => candidate.id === parentProperty.id);
-    const missing = missingMarkings(parentProperty.markings, property?.markings);
+    const parentMarkings = parentProperty.markings;
+    if (!parentMarkings)
+      continue;
+    if (!propertiesById) {
+      propertiesById = new Map;
+      for (const property of objectType.properties) {
+        if (!propertiesById.has(property.id))
+          propertiesById.set(property.id, property);
+      }
+    }
+    const missing = missingMarkings(parentMarkings, propertiesById.get(parentProperty.id)?.markings);
     if (missing.length > 0) {
       throw new SecurityValidationError2(`[Sixb] Property '${objectType.id}.${parentProperty.id}' must keep the markings of '${parent.id}.${parentProperty.id}': add ${missing.map((markingId) => `'${markingId}'`).join(", ")}.`);
     }
@@ -3392,106 +3819,10 @@ function assertMarkingList(markings, subject, markingIds) {
     }
   }
 }
-function rejectPipelineStepsOverMarkedColumns(pipelines, datasetsById) {
-  for (const pipeline of pipelines) {
-    for (const { step } of pipeline.graph.nodes) {
-      for (const input of Object.values(step.inputs)) {
-        const dataset = datasetsById.get(input.id);
-        const column = dataset?.schema.columns.find((candidate) => candidate.markings);
-        if (!dataset || !column)
-          continue;
-        throw new SecurityValidationError2(`[Sixb] Pipeline '${pipeline.id}' step '${step.id}' reads column '${dataset.id}.${column.name}', which carries ${markingList(column.markings)}. Pipeline steps cannot read marked columns yet.`);
-      }
-    }
-  }
-}
-function validateProjectionMarkings(projections, ontology, datasetsById) {
-  for (const projection of projections.listObjects()) {
-    const objectType = ontology.getObjectTypeById(projection.objectTypeId);
-    if (objectType)
-      validateObjectProjection(projection, objectType, datasetsById);
-  }
-  for (const projection of projections.listLinks()) {
-    const role = `keys link '${projection.sourceObjectTypeId}.${projection.linkId}'`;
-    for (const columnName of [projection.sourceField, projection.targetField]) {
-      assertUnmarkedColumn(projection, sourceColumn(projection, columnName, datasetsById), role);
-    }
-  }
-  for (const projection of projections.listTelemetry()) {
-    const columnNames = [
-      projection.objectIdField,
-      projection.atField,
-      ...Object.values(projection.properties).flatMap((mapping) => mapping.unitField === undefined ? [mapping.valueField] : [mapping.valueField, mapping.unitField])
-    ];
-    for (const columnName of columnNames) {
-      const column = sourceColumn(projection, columnName, datasetsById);
-      if (!column.markings)
-        continue;
-      throw new SecurityValidationError2(`[Sixb] Projection '${projection.id}' reads column '${column.path}', which carries ${markingList(column.markings)}. Telemetry projections cannot read marked columns yet.`);
-    }
-  }
-}
-function validateObjectProjection(projection, objectType, datasetsById) {
-  const keyRoles = objectProjectionKeyRoles(projection, objectType);
-  for (const [propertyId, columnName] of Object.entries(projection.properties)) {
-    const column = sourceColumn(projection, columnName, datasetsById);
-    const property = objectType.properties.find((candidate) => candidate.id === propertyId);
-    const path = `${objectType.id}.${propertyId}`;
-    const keyRole = keyRoles.get(propertyId);
-    if (keyRole) {
-      assertUnmarkedColumn(projection, column, keyRole);
-      if (property?.markings) {
-        throw new SecurityValidationError2(`[Sixb] Projection '${projection.id}': property '${path}' ${keyRole} and cannot carry markings.`);
-      }
-      continue;
-    }
-    const missing = missingMarkings(column.markings, property?.markings);
-    if (missing.length > 0) {
-      throw new SecurityValidationError2(`[Sixb] Projection '${projection.id}': property '${path}' is projected from column '${column.path}', which carries ${markingList(column.markings)}. Add markings: ${markingList(missing)} to the property.`);
-    }
-  }
-  for (const [linkId, link] of Object.entries(projection.links)) {
-    if (link.sourceField === undefined)
-      continue;
-    assertUnmarkedColumn(projection, sourceColumn(projection, link.sourceField, datasetsById), `keys link '${objectType.id}.${linkId}'`);
-  }
-  const conflictResolution = projection.conflictResolution;
-  if (conflictResolution?.strategy === "mostRecent") {
-    assertUnmarkedColumn(projection, sourceColumn(projection, conflictResolution.sourceTimestamp, datasetsById), "decides which value wins under 'mostRecent'");
-  }
-}
-function objectProjectionKeyRoles(projection, objectType) {
-  const roles = new Map;
-  for (const property of objectType.properties) {
-    if (property.primary)
-      roles.set(property.id, `becomes the id of '${objectType.id}'`);
-  }
-  for (const [linkId, link] of Object.entries(projection.links)) {
-    if (link.sourcePropertyId === undefined)
-      continue;
-    roles.set(link.sourcePropertyId, `keys link '${objectType.id}.${linkId}'`);
-  }
-  return roles;
-}
-function sourceColumn(projection, columnName, datasetsById) {
-  const column = datasetsById.get(projection.datasetId)?.schema.columns.find((candidate) => candidate.name === columnName);
-  if (!column) {
-    throw new Error(`[Sixb] Projection '${projection.id}' maps unknown column '${columnName}'.`);
-  }
-  return { path: `${projection.datasetId}.${columnName}`, markings: column.markings };
-}
-function assertUnmarkedColumn(projection, column, role) {
-  if (!column.markings)
-    return;
-  throw new SecurityValidationError2(`[Sixb] Projection '${projection.id}': column '${column.path}' ${role} and cannot carry markings.`);
-}
 function missingMarkings(required, declared) {
   const present = new Set(declared ?? []);
   return (required ?? []).filter((markingId) => !present.has(markingId));
 }
-function markingList(markings) {
-  return `[${(markings ?? []).join(", ")}]`;
-}
 
 // src/syncs/validation.ts
 function validateKeyedDatasetWriterTopology(input) {
@@ -3585,9 +3916,11 @@ function resolveDefinitions(options) {
   const syncsById = new Map;
   for (const sync of options.syncs ?? []) {
     assertUniqueDefinitionId("sync", sync.id, syncsById);
-    if (!datasetsById.has(sync.target.dataset.id)) {
+    const target = datasetsById.get(sync.target.dataset.id);
+    if (!target) {
       throw new RuntimeError2(`Sync '${sync.id}' targets unknown dataset '${sync.target.dataset.id}'. Add it to 'datasets' in createSixb() or export it from 'datasets/'.`);
     }
+    assertRegisteredColumns(`Sync '${sync.id}' target '${target.id}'`, sync.target.dataset, target);
     syncsById.set(sync.id, sync);
   }
   const pipelinesById = new Map;
@@ -3704,13 +4037,39 @@ function validatePipelineDatasets(pipeline, datasetsById) {
     }
     stepIds.add(step.id);
     for (const [inputName, dataset] of Object.entries(step.inputs)) {
-      if (!datasetsById.has(dataset.id)) {
+      const registered = datasetsById.get(dataset.id);
+      if (!registered) {
         throw new RuntimeError2(`Pipeline '${pipeline.id}' step '${step.id}' input '${inputName}' references unknown dataset '${dataset.id}'. Add it to 'datasets' in createSixb() or export it from 'datasets/'.`);
       }
+      assertRegisteredColumns(`Pipeline '${pipeline.id}' step '${step.id}' input '${inputName}'`, dataset, registered, { pick: "allowed" });
     }
-    if (!datasetsById.has(step.output.id)) {
+    const output = datasetsById.get(step.output.id);
+    if (!output) {
       throw new RuntimeError2(`Pipeline '${pipeline.id}' step '${step.id}' outputs unknown dataset '${step.output.id}'. Add it to 'datasets' in createSixb() or export it from 'datasets/'.`);
     }
+    assertRegisteredColumns(`Pipeline '${pipeline.id}' step '${step.id}' output '${output.id}'`, step.output, output);
+  }
+}
+function assertRegisteredColumns(subject, dataset, registered, options = {}) {
+  if (dataset === registered)
+    return;
+  const pick = isDatasetPick2(dataset);
+  if (pick && options.pick !== "allowed") {
+    throw new RuntimeError2(`${subject} must be the whole dataset, not a pick.`);
+  }
+  const registeredColumns = columnsByName(registered);
+  for (const column of dataset.schema.columns) {
+    const declared = registeredColumns.get(column.name);
+    if (!declared) {
+      throw new RuntimeError2(`${subject} has column '${column.name}', which dataset '${registered.id}' does not declare. Use the registered definition.`);
+    }
+    if (declared.type !== column.type) {
+      throw new RuntimeError2(`${subject} has column '${column.name}' as '${column.type}', but dataset '${registered.id}' declares it as '${declared.type}'. Use the registered definition.`);
+    }
+  }
+  if (!pick && dataset.schema.columns.length !== registeredColumns.size) {
+    const hint = options.pick === "allowed" ? ", or .pick(...) to read some of its columns" : "";
+    throw new RuntimeError2(`${subject} lacks columns of dataset '${registered.id}'. Use the registered definition${hint}.`);
   }
 }
 function validateScheduleReferences(consumerKind, consumerId, references, schedulesById) {
@@ -3796,11 +4155,14 @@ class SixbHost2 {
   storageReadiness;
   connectorService;
   materializer;
+  datasetVersionMarkings;
+  appliedMarkings;
   sandboxDefinition;
   definitions;
   broker;
   events;
   logging;
+  activity;
   storage;
   lakeStorage;
   blobStorage;
@@ -3828,6 +4190,7 @@ class SixbHost2 {
       observability: options.observability?.logs
     });
     this.storage = options.storage;
+    this.activity = new ActivityService(this.projectId, this.storage.activity, options.activity);
     this.storageReadiness = new StorageReadiness(this.storage);
     this.lakeStorage = options.lakeStorage;
     this.blobStorage = options.blobStorage;
@@ -3837,7 +4200,24 @@ class SixbHost2 {
     const definitions = resolveDefinitions(options);
     this.definitions = definitions;
     this.sandboxDefinition = options.sandboxes?.configuration === undefined ? undefined : createSandboxDefinition(options.sandboxes.configuration, definitions.ontology);
+    assertSandboxCredentials(options.sandboxes);
     registerProjectionRegistry2(this, definitions.projections);
+    this.datasetVersionMarkings = createDatasetVersionMarkings({
+      datasets: definitions.datasets,
+      lakeStorage: this.lakeStorage
+    });
+    registerDatasetVersionMarkings(this, this.datasetVersionMarkings);
+    this.appliedMarkings = createAppliedMarkings({
+      projectId: this.projectId,
+      ontology: definitions.ontology,
+      projections: definitions.projections,
+      revisionOf: (projectionId) => definitions.projections.resolveDispatch(projectionId).projectionRevision,
+      pipelines: definitions.pipelines.list(),
+      versionMarkings: this.datasetVersionMarkings,
+      lakeStorage: this.lakeStorage,
+      sources: this.storage.ontology.sources
+    });
+    registerAppliedMarkings(this, this.appliedMarkings);
     this.auth = new AuthRuntime2({
       projectId: this.projectId,
       storage: this.storage,
@@ -3921,7 +4301,8 @@ class SixbHost2 {
       ontology: this.hostContext.ontology,
       objectStorage: this.storage.objects,
       embeddingModels,
-      rerankingModels
+      rerankingModels,
+      appliedMarkings: this.appliedMarkings
     });
     const runtime = {
       ...this.hostContext,
@@ -3937,7 +4318,8 @@ class SixbHost2 {
       notifyCommittedFacts: () => {
         this.committedFacts.notify();
         this.vectorIndexing?.notify();
-      }
+      },
+      onProjectionApplied: () => this.appliedMarkings.invalidate()
     }));
     return createBoundSixb(runtime, this.sixbDependencies(), capturedScope.execution);
   }
@@ -3983,11 +4365,13 @@ class SixbHost2 {
         supportsPersistence: typeof this.sandboxes?.resume === "function"
       },
       logging: this.logging,
+      activity: this.activity,
       connectorService: this.connectorService,
       ...this.connectorService.connectionProcess === undefined ? {} : { connectorConnections: this.connectorService.connectionProcess },
       blobStorage: this.blobStorage,
       apiPublicOrigin: () => getApiPublicOrigin(this),
-      lakeStorage: this.lakeStorage
+      lakeStorage: this.lakeStorage,
+      datasetVersionMarkings: this.datasetVersionMarkings
     };
   }
 }
@@ -4030,6 +4414,17 @@ function assertWebhookRunStorage(connectors, storage) {
     }
   }
 }
+function assertSandboxCredentials(sandboxes) {
+  if (!sandboxes)
+    return;
+  const issue = sandboxCredentialIssue2({
+    supportsRequestCredentials: sandboxes.supportsRequestCredentials,
+    auth: sandboxes.configuration?.auth,
+    source: sandboxes.configuration?.source
+  });
+  if (issue)
+    throw new SandboxError2(`[Sixb] ${issue}`);
+}
 
 // src/runtime/create.ts
 async function createSixb2(options) {
@@ -4057,6 +4452,7 @@ async function createSixb2(options) {
     sandboxes: options.sandboxes,
     logger: options.logger,
     observability: options.observability,
+    activity: options.activity,
     onError: options.onError,
     ontologyMaintenance: options.ontologyMaintenance,
     projectRoot,
@@ -4087,4 +4483,4 @@ async function createSixb2(options) {
 }
 export { WebhookValidationError2, defineWebhook2, webhookConnector2, UnverifiedWebhookError2, resolveWebhookVerification2, warnUnverifiedWebhook2, SixbHost2, createSixb2 };
 
-//# debugId=6128FDB623B490B964756E2164756E21
+//# debugId=0B55C1215556227464756E2164756E21