@sixb/core 0.1.20 → 0.1.21

package/src/execution/object-reader-clearance.ts

@@ -0,0 +1,91 @@
+import { type PropertyClearance, resolvePropertyClearance } from "../objects/property-clearance"
+import type { OntologyRegistry } from "../ontology"
+import type { AppliedMarkings } from "../security/applied-markings"
+import type { EventOriginRef } from "../security/applied-markings-contribution"
+import type { AppliedMarkingsSnapshot } from "../security/applied-markings-snapshot"
+
+/** What one read may not return; `undefined` when it reads everything. */
+export type Clearance = PropertyClearance | undefined
+
+/**
+ * What one authority cannot read: the markings the code declares, and those the dataset versions
+ * projections applied add, for an authority they can affect.
+ *
+ * A reader they cannot affect, trusted code included, gets the code's clearance as a plain value:
+ * awaiting it costs one microtask, not a refresh. Otherwise the clearance is resolved for each
+ * snapshot, which rarely changes, so the last one is kept.
+ */
+export class ObjectReaderClearance {
+  readonly #ontology: OntologyRegistry
+  /** What the authority cannot read under the code's markings; absent when it reads everything. */
+  readonly #static: Clearance
+  /** The authority's clearances; absent when it is unrestricted. */
+  readonly #clearances?: ReadonlySet<string>
+  /** Present only when applied dataset versions can deny this authority more than the code. */
+  readonly #applied?: AppliedMarkings
+  #lastSnapshot?: AppliedMarkingsSnapshot
+  #lastClearance: Clearance
+
+  constructor(input: {
+    readonly ontology: OntologyRegistry
+    readonly clearances: ReadonlySet<string> | undefined
+    readonly appliedMarkings?: AppliedMarkings
+  }) {
+    this.#ontology = input.ontology
+    this.#clearances = input.clearances
+    this.#static = input.clearances && resolvePropertyClearance(input.ontology, input.clearances)
+
+    if (input.clearances && input.appliedMarkings?.affects(input.clearances)) {
+      this.#applied = input.appliedMarkings
+    }
+
+    Object.freeze(this)
+  }
+
+  /** What the authority cannot read now. */
+  current(): Clearance | Promise<Clearance> {
+    const applied = this.#applied
+    const clearances = this.#clearances
+    if (!applied || !clearances) return this.#static
+
+    return applied.current().then((snapshot) => {
+      if (snapshot !== this.#lastSnapshot) {
+        this.#lastClearance = resolvePropertyClearance(this.#ontology, clearances, snapshot)
+        this.#lastSnapshot = snapshot
+      }
+      return this.#lastClearance
+    })
+  }
+
+  /**
+   * What the authority cannot read in an object event. Reads the event's origin version only for
+   * an authority its markings affect.
+   */
+  forEvent(sources: EventSources): Clearance | Promise<Clearance> {
+    const applied = this.#applied
+    const clearances = this.#clearances
+    if (!applied || !clearances) return this.#static
+
+    return applied
+      .current()
+      .then((snapshot) =>
+        sources.origin ? applied.forEventOrigin(snapshot, sources.origin) : snapshot
+      )
+      .then((snapshot) =>
+        sources.earlier ? applied.forEarlierValues(snapshot, sources.objectTypeId) : snapshot
+      )
+      .then((snapshot) => resolvePropertyClearance(this.#ontology, clearances, snapshot))
+  }
+}
+
+/** Where the values of an object event came from. */
+export interface EventSources {
+  readonly objectTypeId: string
+  /** The projection that emitted the event, and the version it applied. */
+  readonly origin?: EventOriginRef
+  /**
+   * Whether the event holds values from before it, which came from versions applied earlier: an
+   * update or a deletion, or a record an action or a direct write took of projected values.
+   */
+  readonly earlier: boolean
+}

package/src/execution/object-reader-ontology.ts

@@ -0,0 +1,63 @@
+import { isAllowed } from "../authorization"
+import {
+  type AuthorizedOntologySelection,
+  type AuthorizedOntologyView,
+  createAuthorizedOntologyView,
+} from "../objects/authorized-ontology-view"
+import type { OntologyRegistry } from "../ontology"
+import { assertObjectReadOutputWithinLimit } from "../storage"
+import type { ResolvedExecutionAuthority } from "./object-reader-security"
+
+/** The ontology a reader resolves against, and the part of it its authority may describe. */
+export class ObjectReaderOntology {
+  readonly registry: OntologyRegistry
+  readonly #authority: ResolvedExecutionAuthority
+  #view?: AuthorizedOntologyView
+
+  constructor(registry: OntologyRegistry, authority: ResolvedExecutionAuthority) {
+    this.registry = registry
+    this.#authority = authority
+    Object.freeze(this)
+  }
+
+  /** Inert metadata for the types the authority may view, built on first use. */
+  view(): AuthorizedOntologyView {
+    const authority = this.#authority
+    this.#view ??= createAuthorizedOntologyView({
+      ontology: this.registry,
+      selection: selectionForAuthority(authority, this.registry),
+      ...(authority.type === "delegated"
+        ? {
+            assertOutputWithinLimit: (value: unknown) =>
+              assertObjectReadOutputWithinLimit(value, authority.objectRead.limits),
+          }
+        : {}),
+    })
+    return this.#view
+  }
+}
+
+function selectionForAuthority(
+  authority: ResolvedExecutionAuthority,
+  ontology: OntologyRegistry
+): AuthorizedOntologySelection {
+  switch (authority.type) {
+    case "unrestricted":
+      return { kind: "all" }
+    case "principal":
+      return {
+        kind: "types",
+        objectTypeIds: ontology
+          .listObjectTypes()
+          .filter((objectType) =>
+            isAllowed(authority.context, {
+              kind: "object.view",
+              objectTypeId: objectType.id,
+            })
+          )
+          .map((objectType) => objectType.id),
+      }
+    case "delegated":
+      return { kind: "selected", scope: authority.objectRead.scope }
+  }
+}

package/src/execution/object-reader-security.ts

@@ -0,0 +1,146 @@
+import { assertAuthorized, isAllowed } from "../authorization"
+import { AuthorizationError } from "../authorization/errors"
+import type { AuthorizationContext } from "../authorization/types"
+import { unreadableError } from "../objects/property-clearance"
+import {
+  createSelectedObjectQueryAdmission,
+  type SelectedObjectQueryAdmission,
+} from "../objects/query/selected-read-admission"
+import type { OntologyRegistry } from "../ontology"
+import type { AppliedMarkings } from "../security/applied-markings"
+import type { CompiledObjectReadStep, ObjectLinkRow } from "../storage"
+import type { resolveExecutionScopeAuthorization } from "./authorization"
+import { type Clearance, ObjectReaderClearance } from "./object-reader-clearance"
+import type { RuntimeAuthorization } from "./types"
+
+export type ResolvedExecutionAuthority = ReturnType<typeof resolveExecutionScopeAuthorization>
+
+export type RuntimeReadAuthorization = {
+  readonly projectId: string
+  readonly runtimeAuthorization: RuntimeAuthorization
+  readonly authorization?: AuthorizationContext
+}
+
+/** What a delegated authority selected: the object types, links, and queries it may read. */
+export interface ObjectReaderDelegation {
+  readonly objectTypeIds: ReadonlySet<string>
+  readonly linkDefinitions: ReadonlySet<string>
+  readonly queryAdmission: SelectedObjectQueryAdmission
+}
+
+/**
+ * Who reads, and what it may read: the exact execution authority, the selection a delegated one
+ * carries, and its clearance. It decides whether an object type or a link is viewable.
+ */
+export class ObjectReaderSecurity {
+  /** The registered authority the reader is bound to. */
+  readonly authorization: RuntimeAuthorization
+  readonly authority: ResolvedExecutionAuthority
+  /** The authority as generic authorization checks take it. */
+  readonly runtime: RuntimeReadAuthorization
+  /** Present for delegated authority only. */
+  readonly delegation?: ObjectReaderDelegation
+  readonly clearance: ObjectReaderClearance
+
+  constructor(input: {
+    readonly authorization: RuntimeAuthorization
+    readonly authority: ResolvedExecutionAuthority
+    readonly projectId: string
+    readonly ontology: OntologyRegistry
+    readonly appliedMarkings?: AppliedMarkings
+  }) {
+    const authority = input.authority
+    this.authorization = input.authorization
+    this.authority = authority
+    this.runtime = Object.freeze({
+      projectId: input.projectId,
+      runtimeAuthorization: input.authorization,
+      ...(authority.type === "principal" ? { authorization: authority.context } : {}),
+    })
+
+    if (authority.type === "delegated") {
+      const scope = authority.objectRead.scope
+      this.delegation = Object.freeze({
+        objectTypeIds: new Set(scope.objects.map((object) => object.objectTypeId)),
+        linkDefinitions: new Set(scope.steps.map(delegatedLinkDefinitionKey)),
+        queryAdmission: createSelectedObjectQueryAdmission(scope),
+      })
+    }
+
+    this.clearance = new ObjectReaderClearance({
+      ontology: input.ontology,
+      clearances: clearancesForAuthority(authority),
+      ...(input.appliedMarkings === undefined ? {} : { appliedMarkings: input.appliedMarkings }),
+    })
+
+    Object.freeze(this)
+  }
+
+  assertObjectTypesViewable(objectTypeIds: readonly string[], clearance: Clearance): void {
+    if (this.delegation) {
+      for (const objectTypeId of new Set(objectTypeIds)) {
+        if (this.delegation.objectTypeIds.has(objectTypeId)) continue
+        throw new AuthorizationError(
+          `delegated:object.view:${objectTypeId}`,
+          `[Sixb] Delegated authorization does not select object type '${objectTypeId}'.`
+        )
+      }
+    } else {
+      for (const objectTypeId of new Set(objectTypeIds)) {
+        assertAuthorized(this.runtime, { kind: "object.view", objectTypeId })
+      }
+    }
+
+    if (!clearance) return
+
+    for (const objectTypeId of new Set(objectTypeIds)) {
+      const unreadable = clearance.unreadableType(objectTypeId)
+      if (unreadable) throw unreadableError(unreadable)
+    }
+  }
+
+  isObjectTypeViewable(objectTypeId: string, clearance: Clearance): boolean {
+    if (clearance?.unreadableType(objectTypeId)) return false
+    if (this.delegation) return this.delegation.objectTypeIds.has(objectTypeId)
+    return isAllowed(this.runtime.authorization, { kind: "object.view", objectTypeId })
+  }
+
+  isLinkViewable(link: ObjectLinkRow, clearance: Clearance): boolean {
+    if (
+      !this.isObjectTypeViewable(link.sourceTypeId, clearance) ||
+      !this.isObjectTypeViewable(link.targetTypeId, clearance) ||
+      clearance?.unreadableLink(link.sourceTypeId, link.linkId)
+    ) {
+      return false
+    }
+
+    return this.delegation?.linkDefinitions.has(delegatedLinkDefinitionKey(link)) ?? true
+  }
+}
+
+/**
+ * Unrestricted authority reads every property. A principal reads what its roles clear; delegated
+ * shared access carries no clearance, so no share can expose a marked property.
+ */
+function clearancesForAuthority(
+  authority: ResolvedExecutionAuthority
+): ReadonlySet<string> | undefined {
+  switch (authority.type) {
+    case "unrestricted":
+      return undefined
+    case "principal":
+      return authority.context.clearances ?? new Set()
+    case "delegated":
+      return new Set()
+  }
+}
+
+function delegatedLinkDefinitionKey(
+  input:
+    | Pick<CompiledObjectReadStep, "sourceObjectTypeId" | "linkId" | "targetObjectTypeId">
+    | Pick<ObjectLinkRow, "sourceTypeId" | "linkId" | "targetTypeId">
+): string {
+  return "sourceObjectTypeId" in input
+    ? JSON.stringify([input.sourceObjectTypeId, input.linkId, input.targetObjectTypeId])
+    : JSON.stringify([input.sourceTypeId, input.linkId, input.targetTypeId])
+}

package/src/http/api-routes.ts

@@ -430,6 +430,71 @@ export const SIXB_API_ROUTES: readonly SixbApiRoute[] = [
     accessToken: true,
     agentApi: false,
   },
+  // Artifacts are reachable with an access token, so the CLI and integrations can publish them. The
+  // Agent publishes through its own tool, not the gateway.
+  {
+    operationId: "listArtifacts",
+    method: "GET",
+    path: "/api/artifacts",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "createArtifact",
+    method: "POST",
+    path: "/api/artifacts",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "getArtifact",
+    method: "GET",
+    path: "/api/artifacts/:artifactId",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "deleteArtifact",
+    method: "DELETE",
+    path: "/api/artifacts/:artifactId",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "publishArtifactVersion",
+    method: "POST",
+    path: "/api/artifacts/:artifactId/versions",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "getArtifactVersion",
+    method: "GET",
+    path: "/api/artifacts/:artifactId/versions/:version",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "createArtifactFrame",
+    method: "POST",
+    path: "/api/artifacts/:artifactId/versions/:version/frame",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "getArtifactFileContent",
+    method: "GET",
+    path: "/api/artifacts/:artifactId/versions/:version/content",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "headArtifactFileContent",
+    method: "HEAD",
+    path: "/api/artifacts/:artifactId/versions/:version/content",
+    accessToken: true,
+    agentApi: false,
+  },
   {
     operationId: "searchObjects",
     method: "GET",
@@ -452,6 +517,66 @@ export const SIXB_API_ROUTES: readonly SixbApiRoute[] = [
     accessToken: true,
     agentApi: false,
   },
+  // A browser records its own activity, signed in or through a shared link. Access tokens never
+  // do: a script is not a visit.
+  {
+    operationId: "getActivityCaptureConfig",
+    method: "GET",
+    path: "/api/activity/capture-config",
+    accessToken: false,
+    agentApi: false,
+    sharedSession: true,
+  },
+  {
+    operationId: "captureActivity",
+    method: "POST",
+    path: "/api/activity/events",
+    accessToken: false,
+    agentApi: false,
+    sharedSession: true,
+  },
+  {
+    operationId: "listActivityVisits",
+    method: "GET",
+    path: "/api/activity/visits",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "listActivityUsers",
+    method: "GET",
+    path: "/api/activity/users",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "getActivitySummary",
+    method: "GET",
+    path: "/api/activity/summary",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "getActivityCalendar",
+    method: "GET",
+    path: "/api/activity/calendar",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "getActivityVisitTimeline",
+    method: "GET",
+    path: "/api/activity/visits/:visitId/timeline",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "listActivityConnections",
+    method: "GET",
+    path: "/api/activity/connections",
+    accessToken: true,
+    agentApi: false,
+  },
   {
     operationId: "getAiAccountingOverview",
     method: "GET",

package/src/index.ts

@@ -451,6 +451,8 @@ export type {
   MembershipPolicyDefinition,
   ObserveGrant,
   ObserveGrantTarget,
+  ProjectReference,
+  ProjectSurfaceReference,
   RedactionReason,
   Redactions,
   RegisteredSecurityDefinitions,
@@ -470,6 +472,7 @@ export {
   defineMembershipPolicy,
   defineRole,
   every,
+  project,
   SecurityValidationError,
 } from "./security"
 
@@ -583,6 +586,7 @@ export type {
   SandboxNetworkPolicy,
   SandboxNetworkTarget,
   SandboxRequestCredential,
+  SandboxRequestMethod,
   SandboxSessionOptions,
   SandboxStatus,
 } from "./sandboxes"
@@ -859,6 +863,38 @@ export type {
 // ── Runtime ─────────────────────────────────────────────────
 
 export type { ActionRunsRuntime, ActionsRuntime } from "./actions/execution"
+export type {
+  ActivityConnection,
+  ActivityConnectionStatus,
+  ActivityConnectionsPage,
+  ActivityConnectionsQuery,
+  ActivitySessionConnection,
+  ActivityShareConnection,
+  ActivityUserConnection,
+} from "./activity/connection"
+export type { ActivityDevice } from "./activity/device"
+export type {
+  ActivityRuntime,
+  ActivityUsersResult,
+  ActivityVisitList,
+} from "./activity/execution"
+export type {
+  ActivityCalendar,
+  ActivityCalendarQuery,
+  ActivityOptions,
+  ActivityPageQuery,
+  ActivityPeriodQuery,
+} from "./activity/service"
+export type { ActivityVisitActor, ActivityVisitView } from "./activity/shares"
+export type {
+  ActivityActionEntry,
+  ActivityAgentEntry,
+  ActivityInteractionEntry,
+  ActivityPageEntry,
+  ActivityTimelineEntry,
+  ActivityVisitTimeline,
+  ActivityWorkflowEntry,
+} from "./activity/timeline"
 export type {
   AgentRunListResult,
   AgentRunsRuntime,
@@ -867,6 +903,18 @@ export type {
   AgentThreadsRuntime,
   ExecutionAgentRunResult,
 } from "./agents/execution"
+export type { ArtifactRequestErrorCode } from "./artifacts/errors"
+export { ArtifactRequestError } from "./artifacts/errors"
+export type {
+  ArtifactContentInput,
+  ArtifactsRuntime,
+  ListArtifactsRuntimeInput,
+} from "./artifacts/execution"
+export type { ArtifactKind } from "./artifacts/kinds"
+export type { ArtifactOutline } from "./artifacts/outline"
+export type { PublishedArtifact } from "./artifacts/publish/publish"
+export type { ArtifactReference } from "./artifacts/references"
+export type { ArtifactWarning } from "./artifacts/warnings"
 export type { CreateFileDownloadUrlOptions, FileDownloadUrl } from "./blob-storage/download-urls"
 export type { BlobsRuntime } from "./blob-storage/execution"
 export type { ConnectorRuntime } from "./connectors/execution"
@@ -990,6 +1038,18 @@ export type {
   WebhookRunFailureCode,
   WorkflowRunFailureCode,
 } from "./storage"
+export type {
+  ActivityActor,
+  ActivityAttribution,
+  ActivityCursor,
+  ActivityDay,
+  ActivityInteraction,
+  ActivityPageView,
+  ActivitySummary,
+  ActivityUser,
+  ActivityVisit,
+  ActivityVisitsPage,
+} from "./storage/activity/types"
 export type { VectorIndexingFailureCode } from "./storage/ontology/vector-indexing"
 export type { SyncRunsRuntime, SyncsRuntime } from "./syncs/execution"
 export type {
@@ -1033,9 +1093,6 @@ export type {
   AgentSkillDefinition,
   AgentStepStartPart,
   AgentTextPart,
-  AgentToolArtifact,
-  AgentToolArtifactPutInput,
-  AgentToolArtifacts,
   AgentToolAttachments,
   AgentToolCallPart,
   AgentToolCallState,
@@ -1043,7 +1100,10 @@ export type {
   AgentToolContent,
   AgentToolDefinition,
   AgentToolDescriptionBuilder,
+  AgentToolFile,
   AgentToolFileContent,
+  AgentToolFilePutInput,
+  AgentToolFiles,
   AgentToolHandler,
   AgentToolHandlerResult,
   AgentToolInputBuilder,
@@ -1090,6 +1150,14 @@ export type {
   AgentThreadSandboxState,
   ListAgentThreadsResult,
 } from "./storage/agents"
+export type {
+  ArtifactFile,
+  ArtifactOrigin,
+  ArtifactRecord,
+  ArtifactVersionRecord,
+  ListArtifactsResult,
+  ListArtifactVersionsResult,
+} from "./storage/artifacts"
 
 // ── Models ──────────────────────────────────────────────────
 

package/src/lake-storage/in-memory.ts

@@ -5,6 +5,7 @@ import { getDatasetRowValidationFailure } from "../datasets/validation"
 import { resolveDatasetChangeColumns } from "./changes"
 import { mergeStrictDatasetDefinition } from "./definition-updates"
 import { LakeConcurrencyError, LakeStorageError } from "./errors"
+import { lineageAtCommit } from "./lineage"
 import type {
   BeginDatasetMergeInput,
   CommitDatasetMergeInput,
@@ -42,7 +43,7 @@ import type {
   ReadDatasetChangesInput,
   ReadDatasetRowsInput,
 } from "./types"
-import { hasDatasetInputChanges } from "./version-inputs"
+import { hasDatasetProvenanceChanges } from "./version-inputs"
 
 function cloneDatasetDefinition(definition: DatasetDefinition): DatasetDefinition {
   return structuredClone(definition)
@@ -230,6 +231,7 @@ class InMemoryLakeMergeSession implements LakeMergeSession {
 }
 
 export class InMemoryLakeStorage implements LakeStorage {
+  readonly recordsLineage = true
   private readonly datasets = new Map<string, DatasetDefinition>()
   private readonly versionsByDataset = new Map<string, DatasetVersion[]>()
   private readonly rowsByVersionId = new Map<string, readonly DatasetRow[]>()
@@ -568,6 +570,12 @@ export class InMemoryLakeStorage implements LakeStorage {
 
       const visibleRows = [...nextByKey.values()]
       const versionId = `ver_${randomUUID()}`
+      const lineage = lineageAtCommit({
+        mode: "merge",
+        schema: definition.schema,
+        producer: options.merge.producer,
+        parent: latestVersion,
+      })
       const version: DatasetVersion = {
         datasetId: options.merge.dataset.id,
         versionId,
@@ -577,6 +585,7 @@ export class InMemoryLakeStorage implements LakeStorage {
         schema: definition.schema,
         producer: options.merge.producer ? structuredClone(options.merge.producer) : undefined,
         inputs: options.merge.inputs ? structuredClone(options.merge.inputs) : undefined,
+        ...(lineage && { lineage }),
         rowCount: visibleRows.length,
         sizeBytes: new TextEncoder().encode(
           visibleRows.map((row) => JSON.stringify(row)).join("\n")
@@ -623,11 +632,24 @@ export class InMemoryLakeStorage implements LakeStorage {
 
     this.assertKeyedWriteIsUnique(mode, options.rows, latestVersion, definition)
 
+    const lineage = lineageAtCommit({
+      mode,
+      schema: definition.schema,
+      producer: options.write.producer,
+      written: options.write.lineage,
+      parent: latestVersion,
+    })
+
     // Content-identical snapshots and empty appends reuse the latest version
-    // unless explicitly supplied input lineage has changed.
+    // unless explicitly supplied provenance has changed.
     if (
       latestVersion &&
-      !hasDatasetInputChanges(latestVersion.inputs, options.write.inputs) &&
+      !hasDatasetProvenanceChanges(latestVersion, {
+        ...options.write,
+        datasetId: definition.id,
+        schema: definition.schema,
+        lineage,
+      }) &&
       this.isUnchangedWrite(mode, latestVersion, options.rows, definition.schema)
     ) {
       return { ...latestVersion, outcome: "unchanged" }
@@ -652,6 +674,7 @@ export class InMemoryLakeStorage implements LakeStorage {
       schema: definition.schema,
       producer: options.write.producer ? structuredClone(options.write.producer) : undefined,
       inputs: options.write.inputs ? structuredClone(options.write.inputs) : undefined,
+      ...(lineage && { lineage }),
       rowCount: visibleRows.length,
       sizeBytes,
     }