@artkit-ai/core 0.1.0 → 0.2.0

package/src/errors.ts

@@ -3,11 +3,11 @@ import { t } from './i18n.js';
 
 /** Error catalog (spec §10.3). `INTERNAL_ERROR` is the only extension: unexpected failures never leak details. */
 export const ERROR_CODES = [
-  'UNKNOWN_KIND',
-  'DUPLICATE_KIND',
+  'UNKNOWN_FORMAT',
+  'DUPLICATE_FORMAT',
   'NOT_FOUND',
   'INVALID_ENVELOPE',
-  'UNSUPPORTED_VERSION',
+  'UNSUPPORTED_FORMAT_VERSION',
   'MIGRATION_FAILED',
   'INVALID_CONTENT',
   'INVALID_OPERATION',
@@ -16,9 +16,9 @@ export const ERROR_CODES = [
   'LOCKED',
   'LIMIT_EXCEEDED',
   'PERMISSION_DENIED',
-  'APPROVAL_REQUIRED',
   'ASSET_REJECTED',
   'EXPORT_FAILED',
+  'ENGINE_UNAVAILABLE',
   'INTERNAL_ERROR',
 ] as const;
 

package/src/events.ts

@@ -1,5 +1,5 @@
-import type { Actor, ArtifactStatus, ArtifactSummary } from './envelope.js';
-import type { ChangeSummary } from './kind.js';
+import type { ChangeSummary } from './adapter.js';
+import type { Actor, ArtifactSummary } from './envelope.js';
 
 /** Typed events (spec §15.4). They carry metadata only, never content. */
 export type ArtifactEvent =
@@ -10,7 +10,6 @@ export type ArtifactEvent =
       actor: Actor;
       operationCount: number;
       diff: ChangeSummary[];
-      rebased: boolean;
     }
   | {
       type: 'artifact.conflict';
@@ -19,14 +18,6 @@ export type ArtifactEvent =
       currentVersion: number;
       actor: Actor;
     }
-  | {
-      type: 'artifact.status_changed';
-      artifact: ArtifactSummary;
-      from: ArtifactStatus;
-      to: ArtifactStatus;
-      actor: Actor;
-      message?: string;
-    }
   | { type: 'artifact.exported'; artifact: ArtifactSummary; format: string; actor: Actor; warnings: number }
   | { type: 'artifact.lint'; artifactId: string; version: number; warnings: number };
 

package/src/i18n.ts

@@ -9,14 +9,14 @@ type Template = (params: Record<string, unknown>) => string;
 
 const messages = {
   'pt-BR': {
-    UNKNOWN_KIND: (p) => `O tipo "${p.kind}" não está registrado.`,
-    UNKNOWN_KIND_HINT: (p) => `Use um dos tipos disponíveis: ${p.available}.`,
-    DUPLICATE_KIND: (p) => `O tipo "${p.kind}" já está registrado.`,
+    UNKNOWN_FORMAT: (p) => `O formato "${p.format}" não está registrado.`,
+    UNKNOWN_FORMAT_HINT: (p) => `Use um dos formatos disponíveis: ${p.available}.`,
+    DUPLICATE_FORMAT: (p) => `O formato "${p.format}" já está registrado.`,
     NOT_FOUND: (p) => `${p.what} não encontrado: ${p.id}.`,
     NOT_FOUND_HINT: () => 'Confira o id com artifact_list ou leia o artefato novamente.',
     INVALID_ENVELOPE: () => 'O envelope do artefato é inválido.',
-    UNSUPPORTED_VERSION: (p) =>
-      `O conteúdo usa a versão de esquema ${p.found}, mas o tipo "${p.kind}" suporta até a versão ${p.supported}.`,
+    UNSUPPORTED_FORMAT_VERSION: (p) =>
+      `O conteúdo usa a versão de formato ${p.found}, mas o formato "${p.format}" lê apenas ${p.supported}.`,
     MIGRATION_FAILED: (p) => `Falha ao migrar o conteúdo da versão ${p.from} para a ${p.to}.`,
     INVALID_CONTENT: () => 'O conteúdo é inválido.',
     INVALID_OPERATION: (p) => `A operação ${p.index} é inválida.`,
@@ -30,15 +30,12 @@ const messages = {
     LIMIT_EXCEEDED: (p) => `Limite "${p.limit}" excedido: máximo ${p.max}, encontrado ${p.found}.`,
     LIMIT_EXCEEDED_HINT: () => 'Divida o conteúdo em mais artefatos ou reduza a quantidade de itens.',
     PERMISSION_DENIED: (p) => `Ação "${p.action}" negada.`,
-    APPROVAL_REQUIRED: (p) => `A ação "${p.action}" depende de aprovação humana.`,
-    APPROVAL_REQUIRED_HINT: () => 'Use artifact_submit para enviar o artefato para aprovação.',
     ASSET_REJECTED: (p) => `Asset rejeitado: ${p.reason}.`,
     EXPORT_FAILED: (p) => `Falha ao exportar para ${p.format}.`,
     INTERNAL_ERROR: () => 'Erro interno ao processar a solicitação.',
-    INVALID_STATUS_TRANSITION: (p) => `Não é possível mudar o status de "${p.from}" para "${p.to}".`,
-    INPUT_FORMAT_UNSUPPORTED: (p) => `O tipo "${p.kind}" não aceita a entrada "${p.format}".`,
+    INPUT_FORMAT_UNSUPPORTED: (p) => `O formato "${p.format}" não aceita a entrada "${p.input}".`,
     INPUT_FORMAT_HINT: (p) => `Formatos aceitos: ${p.available}.`,
-    EXPORTER_NOT_FOUND: (p) => `Não há exportador de "${p.kind}" para o formato "${p.format}".`,
+    EXPORTER_NOT_FOUND: (p) => `Não há exportador de "${p.format}" para o formato "${p.target}".`,
     THEME_NOT_FOUND: (p) => `Tema "${p.themeId}" não registrado.`,
     DUPLICATE_ID: (p) => `O id "${p.id}" está repetido.`,
     DUPLICATE_ID_HINT: () => 'Cada item precisa de um id único dentro do artefato.',
@@ -62,14 +59,14 @@ const messages = {
     ZOD_CUSTOM: (p) => String(p.message ?? 'Valor inválido.'),
   },
   en: {
-    UNKNOWN_KIND: (p) => `Kind "${p.kind}" is not registered.`,
-    UNKNOWN_KIND_HINT: (p) => `Use one of the available kinds: ${p.available}.`,
-    DUPLICATE_KIND: (p) => `Kind "${p.kind}" is already registered.`,
+    UNKNOWN_FORMAT: (p) => `Format "${p.format}" is not registered.`,
+    UNKNOWN_FORMAT_HINT: (p) => `Use one of the available formats: ${p.available}.`,
+    DUPLICATE_FORMAT: (p) => `Format "${p.format}" is already registered.`,
     NOT_FOUND: (p) => `${p.what} not found: ${p.id}.`,
     NOT_FOUND_HINT: () => 'Check the id with artifact_list or read the artifact again.',
     INVALID_ENVELOPE: () => 'The artifact envelope is invalid.',
-    UNSUPPORTED_VERSION: (p) =>
-      `Content uses schema version ${p.found}, but kind "${p.kind}" supports up to version ${p.supported}.`,
+    UNSUPPORTED_FORMAT_VERSION: (p) =>
+      `Content uses format version ${p.found}, but format "${p.format}" reads only ${p.supported}.`,
     MIGRATION_FAILED: (p) => `Failed to migrate content from version ${p.from} to ${p.to}.`,
     INVALID_CONTENT: () => 'The content is invalid.',
     INVALID_OPERATION: (p) => `Operation ${p.index} is invalid.`,
@@ -83,15 +80,12 @@ const messages = {
     LIMIT_EXCEEDED: (p) => `Limit "${p.limit}" exceeded: max ${p.max}, found ${p.found}.`,
     LIMIT_EXCEEDED_HINT: () => 'Split the content into more artifacts or reduce the number of items.',
     PERMISSION_DENIED: (p) => `Action "${p.action}" denied.`,
-    APPROVAL_REQUIRED: (p) => `Action "${p.action}" requires human approval.`,
-    APPROVAL_REQUIRED_HINT: () => 'Use artifact_submit to send the artifact for approval.',
     ASSET_REJECTED: (p) => `Asset rejected: ${p.reason}.`,
     EXPORT_FAILED: (p) => `Failed to export to ${p.format}.`,
     INTERNAL_ERROR: () => 'Internal error while processing the request.',
-    INVALID_STATUS_TRANSITION: (p) => `Cannot change status from "${p.from}" to "${p.to}".`,
-    INPUT_FORMAT_UNSUPPORTED: (p) => `Kind "${p.kind}" does not accept "${p.format}" input.`,
+    INPUT_FORMAT_UNSUPPORTED: (p) => `Format "${p.format}" does not accept "${p.input}" input.`,
     INPUT_FORMAT_HINT: (p) => `Accepted formats: ${p.available}.`,
-    EXPORTER_NOT_FOUND: (p) => `No "${p.kind}" exporter for format "${p.format}".`,
+    EXPORTER_NOT_FOUND: (p) => `No exporter from "${p.format}" to "${p.target}".`,
     THEME_NOT_FOUND: (p) => `Theme "${p.themeId}" is not registered.`,
     DUPLICATE_ID: (p) => `Id "${p.id}" is duplicated.`,
     DUPLICATE_ID_HINT: () => 'Every item needs an id that is unique inside the artifact.',

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from './adapter.js';
 export * from './assets.js';
 export * from './diff.js';
 export * from './engine.js';
@@ -7,7 +8,6 @@ export * from './events.js';
 export * from './i18n.js';
 export * from './ids.js';
 export * from './jsonschema.js';
-export * from './kind.js';
 export * from './logger.js';
 export * from './memory.js';
 export * from './migrations.js';
@@ -16,18 +16,16 @@ export * from './registry.js';
 export * from './sanitize.js';
 export {
   type ApplyRequest,
-  type ApprovalPolicy,
   type ArtifactAction,
+  type ArtifactReadResult,
   type ArtifactService,
   type ArtifactServiceOptions,
   type AuthorizeFn,
   type CommitResult,
   type CreateRequest,
   createArtifactService,
-  DEFAULT_APPROVAL_POLICY,
   type ExportRequest,
   type ExportResult,
-  type ReadResult,
   slugify,
 } from './service.js';
 export * from './store.js';

package/src/logger.ts

@@ -1,13 +1,12 @@
 /** Structured, injectable logger (spec §17). Never log artifact content, cell text, prompts or personal data. */
 export interface LogFields {
   artifactId?: string;
-  kind?: string;
+  format?: string;
   version?: number;
   operationCount?: number;
   durationMs?: number;
   code?: string;
   actorType?: string;
-  format?: string;
   [key: string]: string | number | boolean | undefined;
 }
 

package/src/memory.ts

@@ -7,13 +7,7 @@ import {
   sha256Hex,
   toDataUrl,
 } from './assets.js';
-import {
-  type Actor,
-  type Artifact,
-  type ArtifactStatus,
-  type ArtifactSummary,
-  summarize,
-} from './envelope.js';
+import { type Artifact, type ArtifactSummary, summarize } from './envelope.js';
 import { ArtifactError } from './errors.js';
 import { t } from './i18n.js';
 import { createArtifactId } from './ids.js';
@@ -27,31 +21,24 @@ import type {
   Page,
   PageRequest,
   Scope,
-  VersionEntry,
 } from './store.js';
 
 export interface MemoryStoreOptions {
   now?: () => Date;
-  /** Snapshot every N versions (first version always has one). Memory keeps full versions anyway. */
-  snapshotEvery?: number;
   locale?: string;
 }
 
 interface Record_ {
   workspaceId: string;
-  versions: Artifact[];
-  history: VersionEntry[];
+  artifact: Artifact;
   lock?: Lock;
 }
 
 const DEFAULT_PAGE = 50;
 
-const sameActor = (a: Actor, b: Actor) => a.type === b.type && a.id === b.id;
-
 /** Reference in-memory store: tests, playground and prototypes (spec §15.2). Runs in any runtime. */
 export function createMemoryStore(options: MemoryStoreOptions = {}): ArtifactStore {
   const now = options.now ?? (() => new Date());
-  const snapshotEvery = Math.max(1, options.snapshotEvery ?? 10);
   const records = new Map<string, Record_>();
 
   const notFound = (id: string): never => {
@@ -65,10 +52,6 @@ export function createMemoryStore(options: MemoryStoreOptions = {}): ArtifactSto
     return found;
   }
 
-  function latest(rec: Record_): Artifact {
-    return rec.versions[rec.versions.length - 1]!;
-  }
-
   function activeLock(rec: Record_): Lock | null {
     if (!rec.lock) return null;
     if (Date.parse(rec.lock.expiresAt) <= now().getTime()) {
@@ -90,12 +73,10 @@ export function createMemoryStore(options: MemoryStoreOptions = {}): ArtifactSto
   const clone = <T>(value: T): T => structuredClone(value);
 
   return {
-    async get(scope, id, opts) {
+    async get(scope, id) {
       const rec = records.get(id);
       if (!rec || rec.workspaceId !== scope.workspaceId) return null;
-      if (opts?.version === undefined) return clone(latest(rec));
-      const found = rec.versions.find((v) => v.version === opts.version);
-      return found ? clone(found) : null;
+      return clone(rec.artifact);
     },
 
     async create(scope, input: NewArtifact) {
@@ -103,11 +84,10 @@ export function createMemoryStore(options: MemoryStoreOptions = {}): ArtifactSto
       const id = createArtifactId(at.getTime());
       const artifact: Artifact = {
         id,
-        kind: input.kind,
-        schemaVersion: input.schemaVersion,
+        format: input.format,
+        formatVersion: input.formatVersion,
         version: 1,
         title: input.title,
-        status: input.status,
         locale: input.locale,
         themeId: input.themeId,
         content: clone(input.content),
@@ -119,30 +99,13 @@ export function createMemoryStore(options: MemoryStoreOptions = {}): ArtifactSto
           tags: input.tags ?? [],
         },
       };
-      records.set(id, {
-        workspaceId: scope.workspaceId,
-        versions: [artifact],
-        history: [
-          {
-            version: 1,
-            actor: scope.actor,
-            createdAt: at.toISOString(),
-            operations: [],
-            diff: [],
-            createdIds: input.createdIds ?? [],
-            status: input.status,
-            ...(input.message ? { message: input.message } : {}),
-            ...(input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}),
-            snapshot: { schemaVersion: input.schemaVersion, content: clone(input.content) },
-          },
-        ],
-      });
+      records.set(id, { workspaceId: scope.workspaceId, artifact });
       return clone(artifact);
     },
 
     async commit(scope, id, change: Commit) {
       const rec = record(scope, id);
-      const current = latest(rec);
+      const current = rec.artifact;
       if (change.baseVersion !== current.version) {
         throw new ArtifactError(
           'VERSION_CONFLICT',
@@ -150,55 +113,29 @@ export function createMemoryStore(options: MemoryStoreOptions = {}): ArtifactSto
             baseVersion: change.baseVersion,
             currentVersion: current.version,
           }),
-          {
-            details: { currentVersion: current.version },
-          },
+          { details: { currentVersion: current.version } },
         );
       }
-      const at = now().toISOString();
-      const version = current.version + 1;
       const next: Artifact = {
         ...current,
-        schemaVersion: change.schemaVersion,
-        version,
+        formatVersion: change.formatVersion,
+        version: current.version + 1,
         title: change.title,
         locale: change.locale,
         themeId: change.themeId,
-        status: change.status ?? current.status,
         content: clone(change.content),
-        meta: { ...current.meta, updatedAt: at, updatedBy: scope.actor },
+        meta: { ...current.meta, updatedAt: now().toISOString(), updatedBy: scope.actor },
       };
-      rec.versions.push(next);
-      rec.history.push({
-        version,
-        actor: scope.actor,
-        createdAt: at,
-        operations: clone(change.operations),
-        diff: clone(change.diff),
-        createdIds: change.createdIds ?? [],
-        status: next.status,
-        ...(change.message ? { message: change.message } : {}),
-        ...(change.idempotencyKey ? { idempotencyKey: change.idempotencyKey } : {}),
-        ...(change.restoredFrom ? { restoredFrom: change.restoredFrom } : {}),
-        ...(version % snapshotEvery === 0
-          ? { snapshot: { schemaVersion: change.schemaVersion, content: clone(change.content) } }
-          : {}),
-      });
+      rec.artifact = next;
       return clone(next);
     },
 
-    async history(scope, id, page) {
-      const rec = record(scope, id);
-      return paginate(clone([...rec.history].reverse()), page);
-    },
-
     async list(scope, filter: ArtifactFilter, page) {
       const items: ArtifactSummary[] = [];
       for (const rec of records.values()) {
         if (rec.workspaceId !== scope.workspaceId) continue;
-        const artifact = latest(rec);
-        if (filter.kind && artifact.kind !== filter.kind) continue;
-        if (filter.status && artifact.status !== filter.status) continue;
+        const artifact = rec.artifact;
+        if (filter.format && artifact.format !== filter.format) continue;
         if (filter.title && !artifact.title.toLowerCase().includes(filter.title.toLowerCase())) continue;
         if (filter.tag && !artifact.meta.tags.includes(filter.tag)) continue;
         items.push(summarize(artifact));
@@ -209,32 +146,6 @@ export function createMemoryStore(options: MemoryStoreOptions = {}): ArtifactSto
       return paginate(items, page);
     },
 
-    async setStatus(scope, id, status: ArtifactStatus, actor: Actor, message?: string) {
-      const rec = record(scope, id);
-      const current = latest(rec);
-      const at = now().toISOString();
-      const updated: Artifact = {
-        ...current,
-        status,
-        meta: {
-          ...current.meta,
-          updatedAt: at,
-          updatedBy: actor,
-          ...(status === 'published' ? { publishedVersion: current.version } : {}),
-        },
-      };
-      rec.versions[rec.versions.length - 1] = updated;
-      const entry = rec.history[rec.history.length - 1];
-      if (entry) {
-        entry.status = status;
-        entry.statusLog = [
-          ...(entry.statusLog ?? []),
-          { status, actor, at, ...(message ? { message } : {}) },
-        ];
-      }
-      return clone(updated);
-    },
-
     async lock(scope, id, actor, ttlMs) {
       const rec = record(scope, id);
       const existing = activeLock(rec);
@@ -245,9 +156,7 @@ export function createMemoryStore(options: MemoryStoreOptions = {}): ArtifactSto
             holder: `${existing.holder.type}:${existing.holder.id}`,
             expiresAt: existing.expiresAt,
           }),
-          {
-            details: { expiresAt: existing.expiresAt },
-          },
+          { details: { expiresAt: existing.expiresAt } },
         );
       }
       const token = createArtifactId(now().getTime()).slice(4);
@@ -270,21 +179,6 @@ export function createMemoryStore(options: MemoryStoreOptions = {}): ArtifactSto
       const lock = activeLock(rec);
       return lock ? clone(lock) : null;
     },
-
-    async findByIdempotencyKey(scope, id, key) {
-      const rec = record(scope, id);
-      const entry = rec.history.find((h) => h.idempotencyKey === key);
-      return entry ? clone(entry) : null;
-    },
-
-    async findCreatedByIdempotencyKey(scope, key) {
-      for (const rec of records.values()) {
-        if (rec.workspaceId !== scope.workspaceId) continue;
-        const first = rec.history[0];
-        if (first?.idempotencyKey === key && sameActor(first.actor, scope.actor)) return clone(latest(rec));
-      }
-      return null;
-    },
   };
 }
 

package/src/migrations.ts

@@ -1,40 +1,44 @@
+import type { AnyFormatAdapter } from './adapter.js';
 import { ArtifactError } from './errors.js';
 import { t } from './i18n.js';
-import type { AnyArtifactKind } from './kind.js';
 
 export interface MigrationResult {
   content: unknown;
-  schemaVersion: number;
+  formatVersion: string;
   migrated: boolean;
 }
 
 /**
- * Migrates content in memory along the kind's migration chain (spec §6.3).
- * Persisting the migrated version only happens on the next commit.
+ * Migrates content in memory along the adapter's migration chain (spec §7.2). Reading a version the adapter does not
+ * declare is refused with `UNSUPPORTED_FORMAT_VERSION`. Persisting the migrated content only happens on the next
+ * commit.
  */
 export function migrateContent(
-  kind: AnyArtifactKind,
+  adapter: AnyFormatAdapter,
   content: unknown,
-  schemaVersion: number,
+  formatVersion: string,
   locale?: string,
 ): MigrationResult {
-  if (schemaVersion > kind.version) {
+  if (formatVersion === adapter.formatVersion) return { content, formatVersion, migrated: false };
+  if (!adapter.readableVersions.includes(formatVersion)) {
     throw new ArtifactError(
-      'UNSUPPORTED_VERSION',
-      t(locale, 'UNSUPPORTED_VERSION', { found: schemaVersion, supported: kind.version, kind: kind.kind }),
-      { details: { found: schemaVersion, supported: kind.version } },
+      'UNSUPPORTED_FORMAT_VERSION',
+      t(locale, 'UNSUPPORTED_FORMAT_VERSION', {
+        found: formatVersion,
+        supported: adapter.readableVersions.join(', '),
+        format: adapter.format,
+      }),
+      { details: { found: formatVersion, supported: adapter.readableVersions } },
     );
   }
-  if (schemaVersion === kind.version) return { content, schemaVersion, migrated: false };
   let current = content;
-  let version = schemaVersion;
-  const chain = [...kind.migrations].sort((a, b) => a.from - b.from);
-  while (version < kind.version) {
-    const step = chain.find((migration) => migration.from === version);
+  let version = formatVersion;
+  while (version !== adapter.formatVersion) {
+    const step = adapter.migrations.find((migration) => migration.from === version);
     if (!step) {
       throw new ArtifactError(
         'MIGRATION_FAILED',
-        t(locale, 'MIGRATION_FAILED', { from: version, to: version + 1 }),
+        t(locale, 'MIGRATION_FAILED', { from: version, to: adapter.formatVersion }),
       );
     }
     try {
@@ -43,10 +47,12 @@ export function migrateContent(
       throw new ArtifactError(
         'MIGRATION_FAILED',
         t(locale, 'MIGRATION_FAILED', { from: step.from, to: step.to }),
-        { cause },
+        {
+          cause,
+        },
       );
     }
     version = step.to;
   }
-  return { content: current, schemaVersion: version, migrated: true };
+  return { content: current, formatVersion: version, migrated: true };
 }

package/src/projection.ts

@@ -1,7 +1,25 @@
-import type { Projection, ProjectionOptions } from './kind.js';
+import type { ReadMode } from './adapter.js';
 
 export const DEFAULT_CHARS_PER_TOKEN = 4;
 
+export interface Projection {
+  text: string;
+  truncated: boolean;
+  /** Present when truncated: pass it back to continue reading. */
+  cursor?: string;
+  /** Outline of what was left out, so the model can jump with `range`. */
+  remainingOutline?: string;
+}
+
+export interface ProjectionOptions {
+  mode: ReadMode;
+  /** Format-specific range: anchors, A1 ranges, declaration names or 1-based positions ("3-5"). */
+  range?: string;
+  maxTokens?: number;
+  cursor?: string;
+  charsPerToken?: number;
+}
+
 export function estimateTokens(text: string, charsPerToken = DEFAULT_CHARS_PER_TOKEN): number {
   return Math.ceil(text.length / Math.max(1, charsPerToken));
 }
@@ -9,7 +27,7 @@ export function estimateTokens(text: string, charsPerToken = DEFAULT_CHARS_PER_T
 /** One unit of projected text. Truncation only happens between items. */
 export interface ProjectionItem {
   id: string;
-  /** Full text for `full` and `range` modes. */
+  /** Full text for `full`, `section` and `range` modes. */
   text: string;
   /** One-line summary used for `outline` and for the remaining outline after truncation. */
   outline: string;
@@ -32,8 +50,8 @@ function decodeCursor(cursor: string | undefined): number {
 }
 
 /**
- * Joins items under a token budget (spec §9.2). When the budget runs out, the text is cut at an item
- * boundary and a cursor plus the outline of the remaining items is returned.
+ * Joins items under a token budget (spec §10.2 of the reading rules). When the budget runs out, the text is cut at an
+ * item boundary and a cursor plus the outline of the remaining items is returned.
  */
 export function paginate(items: ProjectionItem[], options: PaginateOptions = {}): Projection {
   const start = Math.min(decodeCursor(options.cursor), items.length);
@@ -65,7 +83,7 @@ export function paginate(items: ProjectionItem[], options: PaginateOptions = {})
   return { text: parts.join('\n'), truncated: false };
 }
 
-/** Wraps a projection between explicit data markers so the model treats it as data, not instructions (spec §16). */
+/** Wraps a projection between explicit data markers so the model treats it as data, not instructions (spec §18). */
 export function delimitProjection(artifactId: string, text: string): string {
   return `<artifact-content id="${artifactId}">\n${text}\n</artifact-content>`;
 }
@@ -110,14 +128,14 @@ function resolvePosition(ids: readonly string[], token: string): number | undefi
   return undefined;
 }
 
-/** Applies mode/range/budget to a list of items. Kinds with simple ordered items can use it directly. */
+/** Applies mode/range/budget to a list of items. Adapters with ordered items can use it directly. */
 export function projectItems(
   items: ProjectionItem[],
   options: ProjectionOptions,
   extras: { header?: string; footer?: string } = {},
 ): Projection {
   let selected = items;
-  if (options.mode === 'range') {
+  if (options.mode === 'range' || options.mode === 'statements' || options.mode === 'section') {
     const ids = selectRange(
       items.map((item) => item.id),
       options.range,