@sixb/core 0.1.19 → 0.1.21

package/src/auth/session-cache.ts

@@ -1,10 +1,8 @@
-import type { AuthSessionAudience } from "./audience"
 import type { AuthenticatedAuthSession } from "./types"
 
 interface SessionCacheEntry {
   readonly tokenHash: string
   readonly transport: "cookie" | "bearer"
-  readonly audience: AuthSessionAudience
   readonly session: AuthenticatedAuthSession
   readonly expiresAtMs: number
 }
@@ -14,15 +12,12 @@ export interface SessionCacheGetInput {
   readonly tokenHash: string
   /** A cookie is only ever answered from a cookie entry, and a bearer token from a bearer entry. */
   readonly transport: "cookie" | "bearer"
-  /** The browser audience a cookie was read for. Bearer sessions carry their own. */
-  readonly audience?: AuthSessionAudience
   readonly nowMs: number
 }
 
 export interface SessionCacheSetInput {
   readonly sessionId: string
   readonly tokenHash: string
-  readonly audience: AuthSessionAudience
   readonly nowMs: number
   readonly session: AuthenticatedAuthSession
   readonly sessionExpiresAtMs: number
@@ -38,7 +33,7 @@ export interface SessionCacheSetInput {
  * API stalls. Caching the resolved result for a short TTL collapses those reads to one
  * per session per window.
  *
- * Safety: entries are pinned to the exact token hash, transport, and audience that produced them and
+ * Safety: entries are pinned to the exact token hash and transport that produced them and
  * are never served past the session's rolling or absolute deadline. The short TTL bounds how long
  * a revoked session can linger; sign-out additionally invalidates eagerly via
  * {@link SessionCache.invalidate}.
@@ -60,8 +55,7 @@ export class SessionCache {
     if (
       entry.expiresAtMs <= input.nowMs ||
       entry.tokenHash !== input.tokenHash ||
-      entry.transport !== input.transport ||
-      (input.audience !== undefined && entry.audience !== input.audience)
+      entry.transport !== input.transport
     ) {
       this.entries.delete(input.sessionId)
       return undefined
@@ -88,7 +82,6 @@ export class SessionCache {
     this.entries.set(input.sessionId, {
       tokenHash: input.tokenHash,
       transport: bearer ? "bearer" : "cookie",
-      audience: input.audience,
       session: input.session,
       expiresAtMs,
     })

package/src/auth/types.ts

@@ -11,7 +11,6 @@ import type {
   SessionRecord,
   UserRecord,
 } from "../storage/auth"
-import type { AuthSessionAudience, AuthSessionAudienceOptions } from "./audience"
 
 export type Principal =
   | { readonly type: "user"; readonly id: string }
@@ -63,7 +62,6 @@ export interface InvitationDeliveryInput {
   readonly projectId: string
   readonly authStorage: AuthStorage
   readonly invitation: InvitationRecord
-  readonly audience: AuthSessionAudience
   readonly returnTo: string
   readonly requestOrigin: string
   /** Return the delivered link once so the inviter can copy it through an approved channel. */
@@ -98,7 +96,6 @@ export interface MagicLinkRequestInput {
   readonly projectId: string
   readonly authStorage: AuthStorage
   readonly email: string
-  readonly audience: AuthSessionAudience
   readonly returnTo: string
   readonly requestOrigin: string
   /**
@@ -140,7 +137,6 @@ export interface MagicLinkCallbackInput {
 }
 
 export interface MagicLinkCallbackResult extends CompleteSignInResult {
-  readonly audience: AuthSessionAudience
   readonly returnTo: string
 }
 
@@ -182,7 +178,6 @@ export interface MagicLinkAuthStrategy extends InvitationDeliveryAuthStrategy {
 export interface OidcStartSignInInput {
   readonly projectId: string
   readonly authStorage: AuthStorage
-  readonly audience: AuthSessionAudience
   readonly returnTo: string
   readonly requestOrigin: string
   readonly now?: Date
@@ -208,7 +203,6 @@ export interface OidcCallbackInput {
 }
 
 export interface OidcCallbackResult extends CompleteSignInResult {
-  readonly audience: AuthSessionAudience
   readonly returnTo: string
 }
 
@@ -277,11 +271,14 @@ export interface MembershipOperationCapabilities {
   readonly invite: boolean
   readonly assignGroups: boolean
   readonly suspend: boolean
+  readonly serviceAccounts: boolean
 }
 
 export interface GetMembershipOptionsResult {
   /** Groups the caller may assign to a member (the `assignGroups` scope). */
   readonly groups: readonly InvitationGroupOption[]
+  /** Groups the caller may place a service account in (the `serviceAccounts` scope). */
+  readonly serviceAccountGroups: readonly InvitationGroupOption[]
   readonly capabilities: MembershipOperationCapabilities
 }
 
@@ -377,7 +374,7 @@ export interface ReactivateMemberResult {
 /** `"session"` reads only the cookie; `"any"` reads a bearer access token, else the cookie. */
 export type AuthCredentialSource = "session" | "any"
 
-export interface AuthSessionResolutionOptions extends AuthSessionAudienceOptions {
+export interface AuthSessionResolutionOptions {
   readonly credentialSource?: AuthCredentialSource
   /** Marks this request as eligible to renew a near-expiry browser session. */
   readonly sessionActivity?: "foreground"
@@ -385,7 +382,6 @@ export interface AuthSessionResolutionOptions extends AuthSessionAudienceOptions
 
 /** Where an invitation link sends its recipient. */
 export interface InvitationDestination {
-  readonly audience: AuthSessionAudience
   readonly requestOrigin: string
   readonly returnTo: string
 }

package/src/auth/validation.ts

@@ -22,8 +22,6 @@ export const MAX_AUTH_INVITATION_TTL_MS = 30 * DAY
  */
 export const DEFAULT_AUTH_SESSION_CACHE_TTL_MS = 5_000
 
-export { resolveAuthSessionAudience } from "./audience"
-
 export function resolveAuthConfig(config: SixbAuthConfig | undefined): ResolvedAuthConfig {
   if (!config) {
     return {

package/src/authorization/decision.ts

@@ -10,7 +10,6 @@
  * is unrestricted.
  */
 
-import type { AuthSessionAudience } from "../auth/audience"
 import {
   type ResolvedRuntimeAuthorization,
   resolveExecutionScopeAuthorization,
@@ -18,12 +17,11 @@ import {
 } from "../execution/authorization"
 import type { ExecutionContext, RuntimeAuthorization } from "../execution/types"
 import { AuthorizationError } from "./errors"
-import type { GrantKind } from "./grant-kinds"
+import type { SingletonGrantKind, TargetedGrantKind } from "./grant-kinds"
 import type { AuthorizationContext, GrantIndex } from "./types"
 
 /** Something a principal may attempt, paired with the resource it targets. */
 export type AuthzRequest =
-  | { readonly kind: "application.access"; readonly audience: AuthSessionAudience }
   | { readonly kind: "object.view"; readonly objectTypeId: string }
   | { readonly kind: "dataset.view"; readonly datasetId: string }
   | { readonly kind: "object.edit"; readonly objectTypeId: string }
@@ -36,6 +34,7 @@ export type AuthzRequest =
   | { readonly kind: "agent.run" }
   | { readonly kind: "logs.observe" }
   | { readonly kind: "aiUsage.observe" }
+  | { readonly kind: "activity.observe" }
   | { readonly kind: "aiUsage.manage" }
   | { readonly kind: "connector.manage"; readonly connectorId: string }
   | { readonly kind: "object.query"; readonly touchedObjectTypeIds: readonly string[] }
@@ -59,13 +58,11 @@ interface AuthorizedRuntime {
 // the two can never drift. `kind` is the resolved-index key, so enforcement is
 // a direct lookup with no per-target dispatch.
 type Atom =
-  | { readonly kind: "run:agent" }
-  | { readonly kind: Exclude<GrantKind, "run:agent">; readonly id: string }
+  | { readonly kind: SingletonGrantKind }
+  | { readonly kind: TargetedGrantKind; readonly id: string }
 
 function atomsFor(request: AuthzRequest): readonly Atom[] {
   switch (request.kind) {
-    case "application.access":
-      return [{ kind: "access:application", id: request.audience }]
     case "object.view":
       return [{ kind: "view:object", id: request.objectTypeId }]
     case "dataset.view":
@@ -87,11 +84,13 @@ function atomsFor(request: AuthzRequest): readonly Atom[] {
     case "agent.run":
       return [{ kind: "run:agent" }]
     case "logs.observe":
-      return [{ kind: "observe:logs", id: "logs" }]
+      return [{ kind: "observe:logs" }]
     case "aiUsage.observe":
-      return [{ kind: "observe:aiUsage", id: "aiUsage" }]
+      return [{ kind: "observe:aiUsage" }]
+    case "activity.observe":
+      return [{ kind: "observe:activity" }]
     case "aiUsage.manage":
-      return [{ kind: "manage:aiUsage", id: "aiUsage" }]
+      return [{ kind: "manage:aiUsage" }]
     case "connector.manage":
       return [{ kind: "manage:connector", id: request.connectorId }]
     case "object.query":
@@ -100,20 +99,11 @@ function atomsFor(request: AuthzRequest): readonly Atom[] {
 }
 
 function atomKey(atom: Atom): string {
-  if (atom.kind === "run:agent") return atom.kind
-  if (
-    atom.kind === "observe:logs" ||
-    atom.kind === "observe:aiUsage" ||
-    atom.kind === "manage:aiUsage"
-  ) {
-    return atom.kind
-  }
-  return `${atom.kind}:${atom.id}`
+  return "id" in atom ? `${atom.kind}:${atom.id}` : atom.kind
 }
 
 function holds(grants: GrantIndex, atom: Atom): boolean {
-  if (atom.kind === "run:agent") return grants[atom.kind]
-  return grants[atom.kind].has(atom.id)
+  return "id" in atom ? grants[atom.kind].has(atom.id) : grants[atom.kind]
 }
 
 /** Resolve a request against a principal's grants. Never throws. */
@@ -267,8 +257,6 @@ function deniedMessage(
 ): string {
   const principalId = authorization?.principal.id ?? "unknown"
   switch (request.kind) {
-    case "application.access":
-      return `[Sixb] Principal '${principalId}' is not allowed to access application '${request.audience}'.`
     case "object.view":
       return `[Sixb] Principal '${principalId}' is not allowed to view object type '${request.objectTypeId}'.`
     case "dataset.view":
@@ -293,6 +281,8 @@ function deniedMessage(
       return `[Sixb] Principal '${principalId}' is not allowed to observe project logs.`
     case "aiUsage.observe":
       return `[Sixb] Principal '${principalId}' is not allowed to observe project AI usage.`
+    case "activity.observe":
+      return `[Sixb] Principal '${principalId}' is not allowed to observe project activity.`
     case "aiUsage.manage":
       return `[Sixb] Principal '${principalId}' is not allowed to manage project AI usage limits.`
     case "connector.manage":

package/src/authorization/grant-kinds.ts

@@ -8,10 +8,9 @@
  * entry in `GRANT_KINDS` plus the compile errors that forces at every consumer.
  */
 
-import type { AgentRunGrant, GrantDefinition } from "../security/types"
+import type { GrantDefinition } from "../security/types"
 
 export type GrantKind =
-  | "access:application"
   | "view:object"
   | "view:dataset"
   | "edit:object"
@@ -24,15 +23,21 @@ export type GrantKind =
   | "run:agent"
   | "observe:logs"
   | "observe:aiUsage"
+  | "observe:activity"
   | "manage:connector"
   | "manage:aiUsage"
 
-export type SingletonGrantKind = "run:agent"
+/** Capabilities over one project-wide surface: held or not, with no ids to select. */
+export type SingletonGrantKind =
+  | "run:agent"
+  | "observe:logs"
+  | "observe:aiUsage"
+  | "observe:activity"
+  | "manage:aiUsage"
 export type TargetedGrantKind = Exclude<GrantKind, SingletonGrantKind>
 
 /** Registered id universes a grant kind ranges over, plus subtype expansion. */
 export interface GrantUniverse {
-  readonly applicationIds: ReadonlySet<string>
   readonly objectTypeIds: ReadonlySet<string>
   readonly datasetIds: ReadonlySet<string>
   readonly actionIds: ReadonlySet<string>
@@ -40,9 +45,7 @@ export interface GrantUniverse {
   readonly workflowIds: ReadonlySet<string>
   readonly syncIds: ReadonlySet<string>
   readonly pipelineIds: ReadonlySet<string>
-  readonly observableIds: ReadonlySet<string>
   readonly connectorIds: ReadonlySet<string>
-  readonly manageableIds: ReadonlySet<string>
   readonly getSubTypes: (objectTypeId: string) => readonly string[]
 }
 
@@ -76,11 +79,6 @@ export const GRANT_KINDS: {
     ? SingletonGrantKindSpec
     : TargetedGrantKindSpec
 } = {
-  "access:application": {
-    universeKey: "applicationIds",
-    subject: "application",
-    fix: "Use an application exported from '@sixb/core'.",
-  },
   "view:object": {
     universeKey: "objectTypeIds",
     subject: "object type",
@@ -136,40 +134,47 @@ export const GRANT_KINDS: {
     fix: "Configure models.language and use the exported agent reference in can.run(agent).",
   },
   "observe:logs": {
-    universeKey: "observableIds",
-    subject: "observability surface",
-    fix: 'Use can.observe("logs").',
+    singleton: true,
+    subject: "logs",
+    fix: "Use can.observe(project.logs).",
   },
   "observe:aiUsage": {
-    universeKey: "observableIds",
-    subject: "observability surface",
+    singleton: true,
+    subject: "AI usage",
     fix: "Use can.observe(agent.usage).",
   },
+  "observe:activity": {
+    singleton: true,
+    subject: "activity",
+    fix: "Use can.observe(project.activity).",
+  },
   "manage:connector": {
     universeKey: "connectorIds",
     subject: "connector",
     fix: "Add it to 'connectors/' or pass it to createSixb({ connectors }).",
   },
   "manage:aiUsage": {
-    universeKey: "manageableIds",
-    subject: "management surface",
+    singleton: true,
+    subject: "AI usage",
     fix: "Use can.manage(agent.usage).",
   },
 }
 
 export const GRANT_KIND_KEYS = Object.keys(GRANT_KINDS) as readonly GrantKind[]
+export const SINGLETON_GRANT_KIND_KEYS = GRANT_KIND_KEYS.filter(
+  (kind): kind is SingletonGrantKind => "singleton" in GRANT_KINDS[kind]
+)
 export const TARGETED_GRANT_KIND_KEYS = GRANT_KIND_KEYS.filter(
-  (kind): kind is TargetedGrantKind => kind !== "run:agent"
+  (kind): kind is TargetedGrantKind => !("singleton" in GRANT_KINDS[kind])
 )
 
+export function isSingletonGrantKind(kind: GrantKind): kind is SingletonGrantKind {
+  return "singleton" in GRANT_KINDS[kind]
+}
+
 /** The grant kind a stored grant resolves to. */
-export function grantKindOf(grant: AgentRunGrant): SingletonGrantKind
-export function grantKindOf(grant: Exclude<GrantDefinition, AgentRunGrant>): TargetedGrantKind
-export function grantKindOf(grant: GrantDefinition): GrantKind
 export function grantKindOf(grant: GrantDefinition): GrantKind {
   switch (grant.capability) {
-    case "access":
-      return "access:application"
     case "view":
       return `view:${grant.target}`
     case "edit":
@@ -196,7 +201,6 @@ export type MutableGrantIndex = {
 
 export function emptyGrantSets(): MutableGrantIndex {
   return {
-    "access:application": new Set(),
     "view:object": new Set(),
     "view:dataset": new Set(),
     "edit:object": new Set(),
@@ -207,9 +211,10 @@ export function emptyGrantSets(): MutableGrantIndex {
     "run:sync": new Set(),
     "run:pipeline": new Set(),
     "run:agent": false,
-    "observe:logs": new Set(),
-    "observe:aiUsage": new Set(),
+    "observe:logs": false,
+    "observe:aiUsage": false,
+    "observe:activity": false,
     "manage:connector": new Set(),
-    "manage:aiUsage": new Set(),
+    "manage:aiUsage": false,
   }
 }

package/src/authorization/index.ts

@@ -1,4 +1,3 @@
-export { canAccessApplication, isApplicationAccessControlled } from "./application-access"
 export type { AuthzDecision, AuthzRequest } from "./decision"
 export {
   assertAuthorized,

package/src/authorization/resolve.ts

@@ -5,6 +5,8 @@ import {
   GRANT_KINDS,
   type GrantUniverse,
   grantKindOf,
+  isSingletonGrantKind,
+  SINGLETON_GRANT_KIND_KEYS,
   TARGETED_GRANT_KIND_KEYS,
 } from "./grant-kinds"
 import type { AuthorizationContext, GrantIndex, ResolvedRole } from "./types"
@@ -14,7 +16,7 @@ import type { AuthorizationContext, GrantIndex, ResolvedRole } from "./types"
  *
  * Broad grants (`every.object().except([...])`) expand against the registered
  * universe; object-type grants also expand to subtypes. Resource grants become
- * id sets; the project Agent grant becomes a boolean.
+ * id sets; grants on one project-wide surface (the Agent, logs, AI usage) become booleans.
  * The per-kind universe and subtype rules come from the `GRANT_KINDS` table, so
  * this loop never enumerates targets by hand.
  */
@@ -22,11 +24,13 @@ export function resolveRoleGrants(role: RoleDefinition, universe: GrantUniverse)
   const grants = emptyGrantSets()
 
   for (const grant of role.grants) {
-    if (grant.capability === "run" && grant.target === "agent") {
-      grants["run:agent"] = true
+    const kind = grantKindOf(grant)
+    if (isSingletonGrantKind(kind)) {
+      grants[kind] = true
       continue
     }
-    const kind = grantKindOf(grant)
+    // Every other kind carries a selection; this narrows the grant's type to say so.
+    if (!("selection" in grant)) continue
     const spec = GRANT_KINDS[kind]
     expandSelection(
       grant.selection,
@@ -89,8 +93,8 @@ export function resolveAuthorizationContext(input: {
     }
 
     roleIds.push(role.id)
-    if (role.grants["run:agent"]) {
-      grants["run:agent"] = true
+    for (const kind of SINGLETON_GRANT_KIND_KEYS) {
+      if (role.grants[kind]) grants[kind] = true
     }
     for (const kind of TARGETED_GRANT_KIND_KEYS) {
       for (const id of role.grants[kind]) {

package/src/blob-storage/internal.ts

@@ -5,4 +5,4 @@ export {
   resolveFileRefAtPath,
   statFileRef,
 } from "./file-content"
-export { canonicalMediaType } from "./media-type"
+export { canonicalMediaType, inferFileMediaType, sniffFileMediaType } from "./media-type"

package/src/blob-storage/media-type.ts

@@ -27,3 +27,72 @@ export function canonicalMediaType(value: unknown): string | null {
   }
   return canonical
 }
+
+/**
+ * The media type a file's bytes declare by their leading signature, or `undefined` when they carry
+ * none this function knows. Only formats with an unambiguous signature are recognized; text formats
+ * have none and are left to the file name.
+ */
+export function sniffFileMediaType(bytes: Uint8Array): string | undefined {
+  if (startsWith(bytes, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) return "image/png"
+  if (startsWith(bytes, [0xff, 0xd8, 0xff])) return "image/jpeg"
+  if (asciiAt(bytes, 0, "GIF87a") || asciiAt(bytes, 0, "GIF89a")) return "image/gif"
+  if (asciiAt(bytes, 0, "RIFF") && asciiAt(bytes, 8, "WEBP")) return "image/webp"
+  if (asciiAt(bytes, 0, "%PDF-")) return "application/pdf"
+  return undefined
+}
+
+/**
+ * The media type of a file handed over without one: its bytes' signature when they have one, else
+ * its extension, else `application/octet-stream`. Every place that classifies a sandbox or tool file
+ * goes through this one table, so the same file gets the same type wherever it comes from.
+ */
+export function inferFileMediaType(fileName: string, bytes?: Uint8Array): string {
+  const sniffed = bytes === undefined ? undefined : sniffFileMediaType(bytes)
+  if (sniffed) return sniffed
+  const dot = fileName.lastIndexOf(".")
+  const extension = dot < 0 ? "" : fileName.slice(dot).toLowerCase()
+  return EXTENSION_MEDIA_TYPES[extension] ?? "application/octet-stream"
+}
+
+const EXTENSION_MEDIA_TYPES: Readonly<Record<string, string>> = {
+  ".bmp": "image/bmp",
+  ".css": "text/css",
+  ".csv": "text/csv",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".gif": "image/gif",
+  ".htm": "text/html",
+  ".html": "text/html",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "application/javascript",
+  ".json": "application/json",
+  ".jsonl": "application/x-ndjson",
+  ".markdown": "text/markdown",
+  ".md": "text/markdown",
+  ".mjs": "application/javascript",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".svg": "image/svg+xml",
+  ".tsv": "text/tab-separated-values",
+  ".txt": "text/plain",
+  ".webp": "image/webp",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".xml": "application/xml",
+  ".yaml": "application/yaml",
+  ".yml": "application/yaml",
+  ".zip": "application/zip",
+}
+
+function startsWith(bytes: Uint8Array, signature: readonly number[]): boolean {
+  return signature.every((byte, index) => bytes[index] === byte)
+}
+
+function asciiAt(bytes: Uint8Array, offset: number, value: string): boolean {
+  if (bytes.byteLength < offset + value.length) return false
+  for (let index = 0; index < value.length; index += 1) {
+    if (bytes[offset + index] !== value.charCodeAt(index)) return false
+  }
+  return true
+}

package/src/datasets/builders.ts

@@ -93,6 +93,17 @@ type PickColumns<
     ? readonly []
     : readonly ColumnDefinitionOf<TColumns, TNames[number]>[]
 
+/** A dataset read through some of its columns: `rawInvoices.pick("id", "title")`. */
+type PickableDataset<TId extends string, TColumns extends readonly DatasetColumnDefinition[]> = {
+  /**
+   * The same dataset with only these columns, in this order. A pipeline step given it as an input
+   * reads nothing else, so its output inherits no other column's markings.
+   */
+  pick<const TNames extends readonly [ColumnNameOf<TColumns>, ...ColumnNameOf<TColumns>[]]>(
+    ...columns: TNames
+  ): DatasetDefinition<TId, PickColumns<TColumns, TNames>>
+}
+
 type AddColumns<
   TColumns extends readonly DatasetColumnDefinition[],
   TAdd extends readonly DatasetColumnDefinition[],
@@ -140,7 +151,8 @@ type DatasetDefinitionResult<TId extends string, TOptions extends DefineDatasetO
   FieldFromOptions<TOptions, "sequenceBy", string> &
   FieldFromOptions<TOptions, "primaryKey", DatasetPrimaryKey> &
   FieldFromOptions<TOptions, "partitionBy", readonly string[]> &
-  FieldFromOptions<TOptions, "description", string>
+  FieldFromOptions<TOptions, "description", string> &
+  PickableDataset<TId, TOptions["schema"]>
 
 type DerivedDatasetDefinitionResult<
   TId extends string,
@@ -153,7 +165,8 @@ type DerivedDatasetDefinitionResult<
   FieldFromOptions<TOptions, "sequenceBy", string> &
   FieldFromOptions<TOptions, "primaryKey", DatasetPrimaryKey> &
   FieldFromOptions<TOptions, "partitionBy", readonly string[]> &
-  FieldFromOptions<TOptions, "description", string>
+  FieldFromOptions<TOptions, "description", string> &
+  PickableDataset<TId, DerivedColumns<TParent, TOptions>>
 
 type CheckedDeriveDatasetOptions<
   TParent extends DatasetDefinition,
@@ -217,9 +230,60 @@ function createDatasetDefinition(id: string, options: DefineDatasetOptions): Dat
   }
 
   assertDatasetDefinition(definition, (message) => new DatasetValidationError(message))
+
+  // Not enumerable: the definition stays plain data for cloning, spreading, and storage.
+  Object.defineProperty(definition, "pick", {
+    value: (...columns: string[]) => pickDatasetColumns(definition, columns),
+  })
+
   return definition
 }
 
+const datasetPick: unique symbol = Symbol("sixb.datasetPick")
+
+/**
+ * Whether a definition was made by `pick()`. Only a pick may hold some of a dataset's columns: any
+ * other definition with a registered id stands for the whole dataset.
+ */
+export function isDatasetPick(dataset: DatasetDefinition): boolean {
+  return (dataset as { readonly [datasetPick]?: true })[datasetPick] === true
+}
+
+function pickDatasetColumns(
+  dataset: DatasetDefinition,
+  columnNames: readonly string[]
+): DatasetDefinition {
+  if (columnNames.length === 0) {
+    throw new DatasetValidationError(
+      `[Sixb] Dataset '${dataset.id}' pick needs at least one column.`
+    )
+  }
+
+  const columnsByName = new Map(dataset.schema.columns.map((column) => [column.name, column]))
+  const picked = new Set<string>()
+  const columns = columnNames.map((columnName) => {
+    if (picked.has(columnName)) {
+      throw new DatasetValidationError(
+        `[Sixb] Dataset '${dataset.id}' pick lists column '${columnName}' twice.`
+      )
+    }
+    picked.add(columnName)
+
+    const column = columnsByName.get(columnName)
+    if (column === undefined) {
+      throw new DatasetValidationError(
+        `[Sixb] Dataset '${dataset.id}' has no column '${columnName}' to pick.`
+      )
+    }
+
+    return column
+  })
+
+  const pick: DatasetDefinition = { kind: "dataset", id: dataset.id, schema: { columns } }
+  Object.defineProperty(pick, datasetPick, { value: true })
+  return pick
+}
+
 function assertStringArray(value: unknown, field: string): asserts value is readonly string[] {
   if (!Array.isArray(value)) {
     throw new DatasetValidationError(`${field} must be an array of column names.`)

package/src/datasets/column-index.ts

@@ -0,0 +1,19 @@
+import type { DatasetColumnDefinition, DatasetDefinition } from "./types"
+
+const indexes = new WeakMap<DatasetDefinition, ReadonlyMap<string, DatasetColumnDefinition>>()
+
+/**
+ * The columns of a dataset definition by name, built once per definition object. Registered
+ * definitions are not changed after startup, so every check and resolver can share one index.
+ */
+export function columnsByName(
+  dataset: DatasetDefinition
+): ReadonlyMap<string, DatasetColumnDefinition> {
+  let index = indexes.get(dataset)
+  if (!index) {
+    index = new Map(dataset.schema.columns.map((column) => [column.name, column]))
+    indexes.set(dataset, index)
+  }
+
+  return index
+}