tila-sdk 0.1.0 → 0.2.0

package/dist/index.d.cts

@@ -1,13 +1,324 @@
 import { TilaProjectConfig } from './config';
 import { z } from 'zod';
-import { EntityResponse, EntityDetailResponse, EntityListResponse, ArchiveSuccessResponse, CreateEntityRelationshipResponse, EntityArtifactReferenceListResponse, AcquireSuccessResponse, RenewSuccessResponse, ReleaseSuccessResponse, StateListResponse, StateResponse, ArtifactPutResponse, ArtifactListResponse, ArtifactSearchResponse, ArtifactGrepResponse, ArtifactRelationshipOkResponse, ArtifactRelationshipListResponse, TokenIssueResponse, TokenRevokeResponse, TokenListResponse, JournalResponse, PresenceHeartbeatSuccessResponse, PresenceListResponse, PresenceAllListResponse, RecordCreateRequest, RecordMutateResponse, RecordSetRequest, RecordGetResponse, RecordPatchRequest, RecordArchiveRequest, RecordUnarchiveRequest, RecordHistoryResponse, RecordListResponse, RecordTypesResponse, InstantiateTemplateRequest, InstantiateTemplateResponse, SummaryResponse, UnifiedSearchResponse } from './api';
+import { ArtifactPointer, EntityArtifactReference } from './artifact';
+import { ArtifactPutResponse, ArtifactListResponse, ArtifactSearchResponse, ArtifactGrepResponse, ArtifactRelationshipOkResponse, ArtifactRelationshipListResponse, AcquireSuccessResponse, RenewSuccessResponse, ReleaseSuccessResponse, StateListResponse, StateResponse, EntityResponse, EntityDetailResponse, EntityListResponse, ArchiveSuccessResponse, CreateEntityRelationshipResponse, ListEntityRelationshipsResponse, EntityArtifactReferenceListResponse, JournalResponse, PresenceHeartbeatSuccessResponse, PresenceListResponse, PresenceAllListResponse, RecordCreateRequest, RecordMutateResponse, RecordSetRequest, RecordGetResponse, RecordPatchRequest, RecordArchiveRequest, RecordUnarchiveRequest, RecordHistoryResponse, RecordListResponse, RecordTypesResponse, UnifiedSearchResponse, SummaryResponse, InstantiateTemplateRequest, InstantiateTemplateResponse, TokenIssueResponse, TokenRevokeResponse, TokenListResponse, RecordRow, RecordListItem, RecordHistoryItem } from './api';
 export { AcquireSuccessResponse, ArtifactGrepResponse, ArtifactListResponse, ArtifactPutResponse, ArtifactSearchResponse, EntityDetailResponse, EntityListResponse, EntityResponse, InstantiateTemplateRequest, InstantiateTemplateResponse, JournalResponse, PresenceAllListResponse, PresenceListResponse, RecordArchiveRequest, RecordCreateRequest, RecordGetResponse, RecordHistoryItem, RecordHistoryResponse, RecordItem, RecordListItem, RecordListResponse, RecordMutateResponse, RecordPatchRequest, RecordSetRequest, RecordTypesResponse, RecordUnarchiveRequest, ReleaseSuccessResponse, RenewSuccessResponse, SummaryResponse, TokenIssueResponse, TokenListResponse, TokenRevokeResponse, UnifiedSearchQuery, UnifiedSearchResponse, UnifiedSearchResult } from './api';
-import { ClaimMode } from './claim';
-import { ArtifactPointer } from './artifact';
-import { InboxResponse, SendSignalRequest, SendSignalResponse, AckSignalResponse } from './signal';
-export { AckSignalResponse, InboxResponse, SendSignalRequest, SendSignalResponse } from './signal';
+import { ClaimMode, Claim } from './claim';
 import { GateListResponse, CreateGateRequest, GateResponse, ResolveGateRequest } from './gate';
 export { CreateGateRequest, GateListResponse, GateResponse, ResolveGateRequest } from './gate';
+import { InboxResponse, SendSignalRequest, SendSignalResponse, AckSignalResponse } from './signal';
+export { AckSignalResponse, InboxResponse, SendSignalRequest, SendSignalResponse } from './signal';
+import { EntityBackend, CreateEntityInput, EntityListFilter, RelationshipInput, RelationshipFilter, ReadyFilter, EntityTree, AddArtifactRefInput } from './interfaces/entity-backend';
+import { CoordinationBackend, AcquireResult, RenewResult } from './interfaces/coordination-backend';
+import { ArtifactBackend, ArtifactPutOptions, ArtifactPointerRecord, ArtifactRelationship, ArtifactSearchResultRecord, ArtifactIndexEntry } from './interfaces/artifact-backend';
+import { JournalBackend, JournalQuery, JournalEvent } from './interfaces/journal-backend';
+import { GateBackend, GateRecord, GateFilter } from './interfaces/gate-backend';
+import { SignalBackend, SendSignalInput, SignalRecord } from './interfaces/signal-backend';
+import { SchemaBackend, SchemaRecord, ApplySchemaInput, ApplySchemaOutput } from './interfaces/schema-backend';
+import { SummaryBackend, ProjectSummary } from './interfaces/summary-backend';
+import { RecordBackend, CreateRecordInput, SetRecordInput, PatchRecordInput, ArchiveRecordInput, RecordListFilter, RecordPage, RecordHistoryOptions } from './interfaces/record-backend';
+import { Entity } from './entity';
+import { Presence } from './presence';
+import { EntityRelationship } from './relationship';
+
+interface ArtifactUploadOpts {
+    kind: string;
+    resource?: string;
+    fence?: number;
+    mimeType?: string;
+    flavor?: string;
+    tags?: string[];
+}
+declare function createArtifactMethods(client: TilaClient, projectId: string): {
+    upload: {
+        (file: File | Blob, opts: ArtifactUploadOpts): Promise<ArtifactPutResponse>;
+        (stream: ReadableStream, opts: ArtifactUploadOpts & {
+            mimeType: string;
+        }): Promise<ArtifactPutResponse>;
+    };
+    download(key: string): Promise<{
+        body: ReadableStream;
+        contentType: string;
+        contentLength: number | null;
+    }>;
+    list(query?: {
+        resource?: string;
+        kind?: string;
+        limit?: string;
+        tagFilter?: string[];
+    }): Promise<ArtifactListResponse>;
+    search(q: string, opts?: {
+        kind?: string;
+        resource?: string;
+        limit?: string;
+        tagFilter?: string[];
+    }): Promise<ArtifactSearchResponse>;
+    grep(pattern: string, opts?: {
+        kind?: string;
+        resource?: string;
+        regex?: boolean;
+        limit?: number;
+    }): Promise<ArtifactGrepResponse>;
+    addRelationship(fromKey: string, toKeyOrUri: string, type: string, metadata?: Record<string, unknown>): Promise<ArtifactRelationshipOkResponse>;
+    listRelationships(key: string): Promise<ArtifactRelationshipListResponse>;
+    getLatest(kind: string, resource: string): Promise<ArtifactPointer | null>;
+    writeText(content: string, opts: {
+        kind: string;
+        mimeType?: string;
+        resource?: string;
+        fence?: number;
+        tags?: string[];
+    }): Promise<ArtifactPutResponse>;
+    readText(key: string): Promise<{
+        content: string;
+        mimeType: string;
+    }>;
+};
+
+declare function createClaimMethods(client: TilaClient, projectId: string): {
+    acquire(resource: string, mode: ClaimMode, ttlMs: number, opts?: {
+        metadata?: Record<string, unknown>;
+        idempotency_key?: string;
+    }): Promise<AcquireSuccessResponse>;
+    renew(resource: string, fence: number, ttlMs: number): Promise<RenewSuccessResponse>;
+    release(resource: string, fence: number): Promise<ReleaseSuccessResponse>;
+    list(): Promise<StateListResponse>;
+    get(resource: string): Promise<StateResponse>;
+};
+
+/**
+ * Creates task API methods using the canonical /tasks public path.
+ */
+declare function createTaskMethods(client: TilaClient, projectId: string): {
+    create(id: string, type: string, data?: Record<string, unknown>, tags?: string[]): Promise<EntityResponse>;
+    get(id: string): Promise<EntityDetailResponse>;
+    list(query?: {
+        type?: string;
+        status?: string;
+        limit?: string;
+        cursor?: string;
+        tagFilter?: string[];
+        /**
+         * Request the Worker's compact projection (id/type/title/status/...). HTTP
+         * only — the embedded backend has no compact list, so the local adapter
+         * ignores this and returns full entities (a documented local divergence).
+         */
+        compact?: boolean;
+    }): Promise<EntityListResponse>;
+    update(id: string, data: Record<string, unknown>, fence: number): Promise<EntityResponse>;
+    archive(id: string, fence: number): Promise<ArchiveSuccessResponse>;
+    addRelationship(fromId: string, toId: string, type: string): Promise<CreateEntityRelationshipResponse>;
+    listRelationships(filter?: {
+        fromId?: string;
+        toId?: string;
+        type?: string;
+    }): Promise<ListEntityRelationshipsResponse>;
+    ready(query?: {
+        type?: string;
+        parent?: string;
+        limit?: number;
+        includeSoftBlocked?: boolean;
+    }): Promise<EntityListResponse>;
+    addArtifactRef(entityId: string, artifactKey: string, slot: string, metadata?: Record<string, unknown>): Promise<{
+        ok: true;
+    }>;
+    listArtifactRefs(entityId: string): Promise<EntityArtifactReferenceListResponse>;
+};
+/**
+ * @deprecated Use createTaskMethods instead.
+ */
+declare function createEntityMethods(client: TilaClient, projectId: string): {
+    create(id: string, type: string, data?: Record<string, unknown>, tags?: string[]): Promise<EntityResponse>;
+    get(id: string): Promise<EntityDetailResponse>;
+    list(query?: {
+        type?: string;
+        status?: string;
+        limit?: string;
+        cursor?: string;
+        tagFilter?: string[];
+        /**
+         * Request the Worker's compact projection (id/type/title/status/...). HTTP
+         * only — the embedded backend has no compact list, so the local adapter
+         * ignores this and returns full entities (a documented local divergence).
+         */
+        compact?: boolean;
+    }): Promise<EntityListResponse>;
+    update(id: string, data: Record<string, unknown>, fence: number): Promise<EntityResponse>;
+    archive(id: string, fence: number): Promise<ArchiveSuccessResponse>;
+    addRelationship(fromId: string, toId: string, type: string): Promise<CreateEntityRelationshipResponse>;
+    listRelationships(filter?: {
+        fromId?: string;
+        toId?: string;
+        type?: string;
+    }): Promise<ListEntityRelationshipsResponse>;
+    ready(query?: {
+        type?: string;
+        parent?: string;
+        limit?: number;
+        includeSoftBlocked?: boolean;
+    }): Promise<EntityListResponse>;
+    addArtifactRef(entityId: string, artifactKey: string, slot: string, metadata?: Record<string, unknown>): Promise<{
+        ok: true;
+    }>;
+    listArtifactRefs(entityId: string): Promise<EntityArtifactReferenceListResponse>;
+};
+/**
+ * @deprecated Use createTaskMethods instead.
+ */
+declare function createWorkUnitMethods(client: TilaClient, projectId: string): {
+    create(id: string, type: string, data?: Record<string, unknown>, tags?: string[]): Promise<EntityResponse>;
+    get(id: string): Promise<EntityDetailResponse>;
+    list(query?: {
+        type?: string;
+        status?: string;
+        limit?: string;
+        cursor?: string;
+        tagFilter?: string[];
+        /**
+         * Request the Worker's compact projection (id/type/title/status/...). HTTP
+         * only — the embedded backend has no compact list, so the local adapter
+         * ignores this and returns full entities (a documented local divergence).
+         */
+        compact?: boolean;
+    }): Promise<EntityListResponse>;
+    update(id: string, data: Record<string, unknown>, fence: number): Promise<EntityResponse>;
+    archive(id: string, fence: number): Promise<ArchiveSuccessResponse>;
+    addRelationship(fromId: string, toId: string, type: string): Promise<CreateEntityRelationshipResponse>;
+    listRelationships(filter?: {
+        fromId?: string;
+        toId?: string;
+        type?: string;
+    }): Promise<ListEntityRelationshipsResponse>;
+    ready(query?: {
+        type?: string;
+        parent?: string;
+        limit?: number;
+        includeSoftBlocked?: boolean;
+    }): Promise<EntityListResponse>;
+    addArtifactRef(entityId: string, artifactKey: string, slot: string, metadata?: Record<string, unknown>): Promise<{
+        ok: true;
+    }>;
+    listArtifactRefs(entityId: string): Promise<EntityArtifactReferenceListResponse>;
+};
+
+declare function createGateMethods(client: TilaClient, projectId: string): {
+    /** List gates with optional filters. GET /projects/:id/gates */
+    list(query?: {
+        resource?: string;
+        status?: string;
+        limit?: string;
+    }): Promise<GateListResponse>;
+    /** Create a new gate. POST /projects/:id/gates */
+    create(req: CreateGateRequest): Promise<GateResponse>;
+    /** Resolve a gate. POST /projects/:id/gates/:gateId/resolve */
+    resolve(gateId: string, req?: ResolveGateRequest): Promise<GateResponse>;
+    /** Delete a gate. DELETE /projects/:id/gates/:gateId */
+    remove(gateId: string): Promise<{
+        ok: true;
+    }>;
+};
+
+declare function createJournalMethods(client: TilaClient, projectId: string): {
+    query(opts?: {
+        resource?: string;
+        kind?: string;
+        after_seq?: string;
+        limit?: string;
+    }): Promise<JournalResponse>;
+};
+
+declare function createPresenceMethods(client: TilaClient, projectId: string): {
+    heartbeat(machine: string, info?: Record<string, unknown>): Promise<PresenceHeartbeatSuccessResponse>;
+    list(): Promise<PresenceListResponse>;
+    /**
+     * List all presence records across all machines, including whether each is active.
+     * Hits GET /projects/:projectId/presence/all
+     */
+    listAll(): Promise<PresenceAllListResponse>;
+};
+
+declare function createRecordMethods(client: TilaClient, projectId: string): {
+    create(type: string, req: RecordCreateRequest): Promise<RecordMutateResponse>;
+    set(type: string, key: string, req: RecordSetRequest): Promise<RecordMutateResponse>;
+    get(type: string, key: string): Promise<RecordGetResponse>;
+    patch(type: string, key: string, req: RecordPatchRequest): Promise<RecordMutateResponse>;
+    archive(type: string, key: string, req: RecordArchiveRequest): Promise<RecordMutateResponse>;
+    unarchive(type: string, key: string, req: RecordUnarchiveRequest): Promise<RecordMutateResponse>;
+    history(type: string, key: string, opts?: {
+        limit?: number;
+        values?: boolean;
+    }): Promise<RecordHistoryResponse>;
+    list(type: string, query?: {
+        tag?: string;
+        filter?: string;
+        "include-archived"?: string;
+        limit?: string;
+        tagFilter?: string[];
+    }): Promise<RecordListResponse>;
+    types(): Promise<RecordTypesResponse>;
+    typesInUse(): Promise<RecordTypesResponse>;
+};
+
+declare function createSchemaMethods(client: TilaClient, projectId: string): {
+    get(): Promise<{
+        ok: true;
+        schema: unknown;
+        version: number;
+    }>;
+    apply(schema: unknown, strategy?: string): Promise<{
+        ok: true;
+        version: number;
+        diff: unknown;
+    }>;
+    history(opts?: {
+        limit?: string;
+    }): Promise<{
+        ok: true;
+        entries: unknown[];
+    }>;
+};
+
+declare function createSearchMethods(client: TilaClient, projectId: string): {
+    search(q: string, opts?: {
+        limit?: number;
+        tagFilter?: string[];
+    }): Promise<UnifiedSearchResponse>;
+};
+
+declare function createSignalMethods(client: TilaClient, projectId: string): {
+    /** Fetch the signal inbox for the current token. GET /projects/:id/signals */
+    inbox(): Promise<InboxResponse>;
+    /** Send a signal to a target. POST /projects/:id/signals/send */
+    send(req: SendSignalRequest): Promise<SendSignalResponse>;
+    /** Acknowledge a signal. POST /projects/:id/signals/:signalId/ack */
+    ack(signalId: string): Promise<AckSignalResponse>;
+};
+
+declare function createSummaryMethods(client: TilaClient, projectId: string): {
+    /** Get project summary. GET /projects/:id/summary */
+    get(): Promise<SummaryResponse>;
+};
+
+declare function createTemplateMethods(client: TilaClient, projectId: string): {
+    /** Instantiate an entity template. POST /projects/:id/templates/instantiate */
+    instantiate(req: InstantiateTemplateRequest): Promise<InstantiateTemplateResponse>;
+    /** List available templates from the project schema. GET /projects/:id/templates */
+    list(): Promise<{
+        ok: true;
+        templates: Array<{
+            name: string;
+            type: string;
+            description: string | null;
+            variables: string[];
+        }>;
+    }>;
+};
+
+declare function createTokenMethods(client: TilaClient): {
+    issue(name: string, note?: string): Promise<TokenIssueResponse>;
+    revoke(name: string): Promise<TokenRevokeResponse>;
+    list(): Promise<TokenListResponse>;
+};
 
 interface ClientOptions {
     baseUrl: string;
@@ -34,7 +345,9 @@ declare class TilaClient {
      * the fallback branch will never execute there.
      */
     private createAbortSignal;
-    static fromConfig(config: TilaProjectConfig, token: string): TilaClient;
+    static fromConfig(config: TilaProjectConfig, token: string, opts?: {
+        extraHeaders?: Record<string, string>;
+    }): TilaClient;
     request<T>(method: string, path: string, opts?: {
         body?: unknown;
         query?: Record<string, string | undefined>;
@@ -83,12 +396,73 @@ declare function exchangeGitHubToken(baseUrl: string, projectId: string, githubT
     expiresAt: number;
     permission: string;
 }>;
-
-interface RetryOptions {
-    /** Maximum number of retry attempts after the first failure. Default: 3. */
-    maxRetries?: number;
-    /** Base delay in milliseconds for exponential backoff. Default: 200. */
-    baseDelayMs?: number;
+/**
+ * The HTTP resource-method surface. Built from the zod-only factories
+ * (`createTaskMethods`, `createRecordMethods`, …) so the type is derived from a
+ * single source of truth and never drifts from the factory signatures.
+ *
+ * The LOCAL branch's `buildLocalResources` (in `./local/resource-adapters`)
+ * presents the SAME shape, so consumers swap backends without changing call
+ * sites. `tokens.issue` etc. throw `LocalUnsupportedError` under the local
+ * backend (HTTP-only — D1 global token store).
+ */
+interface TilaFacade {
+    tasks: ReturnType<typeof createTaskMethods>;
+    records: ReturnType<typeof createRecordMethods>;
+    claims: ReturnType<typeof createClaimMethods>;
+    artifacts: ReturnType<typeof createArtifactMethods>;
+    gates: ReturnType<typeof createGateMethods>;
+    signals: ReturnType<typeof createSignalMethods>;
+    journal: ReturnType<typeof createJournalMethods>;
+    presence: ReturnType<typeof createPresenceMethods>;
+    schema: ReturnType<typeof createSchemaMethods>;
+    summary: ReturnType<typeof createSummaryMethods>;
+    search: ReturnType<typeof createSearchMethods>;
+    templates: ReturnType<typeof createTemplateMethods>;
+    tokens: ReturnType<typeof createTokenMethods>;
+    /**
+     * Release backend resources. No-op for the HTTP backend; closes the SQLite
+     * connection for the local backend. Always safe (and idempotent) to call.
+     */
+    close: () => void;
+}
+/**
+ * Create a uniform tila facade over either the local (in-process SQLite) or the
+ * Cloudflare (HTTP) backend, selected by `config.backend`. Both branches expose
+ * the EXACT same resource-method surface ({@link TilaFacade}); a consumer can
+ * swap backends without touching any call site.
+ *
+ * - `backend: "cloudflare"` (default) → constructs a {@link TilaClient} from
+ *   `config.worker_url` + `token` and wires the zod-only HTTP factories.
+ * - `backend: "local"` → DYNAMICALLY imports `tila-sdk/local`'s
+ *   `createTilaLocal` (the better-sqlite3 + node:fs stack) and the local
+ *   resource adapters, then presents them through the same facade.
+ *
+ * ## Entry / bundle hygiene
+ *
+ * `createTila` lives in the MAIN (zod-only) entry. Its local branch must NOT be
+ * statically reachable from the main bundle — the heavy SQLite stack belongs to
+ * `tila-sdk/local`. So the local branch uses dynamic `import()` (mirroring how
+ * `createTilaLocal` itself dynamically imports the native driver). Nothing heavy
+ * is statically imported here, keeping `dist/index.js` zod-only (enforced by
+ * `__tests__/bundle-hygiene.test.ts`).
+ *
+ * @param token Required for the Cloudflare backend; ignored for local.
+ * @param opts  Optional Cloudflare-backend tuning. `opts.extraHeaders` is
+ *   forwarded to the underlying `TilaClient` (e.g. a caller-attribution
+ *   `X-Tila-Source: mcp-server/<version>` header). Ignored for the local
+ *   backend, which makes no HTTP requests. Additive/back-compat: existing
+ *   `createTila(config, token)` callers are unaffected.
+ */
+declare function createTila(config: TilaProjectConfig, token?: string, opts?: {
+    extraHeaders?: Record<string, string>;
+}): Promise<TilaFacade>;
+
+interface RetryOptions {
+    /** Maximum number of retry attempts after the first failure. Default: 3. */
+    maxRetries?: number;
+    /** Base delay in milliseconds for exponential backoff. Default: 200. */
+    baseDelayMs?: number;
     /** Maximum delay cap in milliseconds. Default: 30000. */
     maxDelayMs?: number;
     /** Whether to apply full jitter to the delay. Default: true. */
@@ -158,234 +532,6 @@ declare const TILA_ERRORS: {
 };
 type TilaErrorCode = (typeof TILA_ERRORS)[keyof typeof TILA_ERRORS];
 
-/**
- * Creates task API methods using the canonical /tasks public path.
- */
-declare function createTaskMethods(client: TilaClient, projectId: string): {
-    create(id: string, type: string, data?: Record<string, unknown>): Promise<EntityResponse>;
-    get(id: string): Promise<EntityDetailResponse>;
-    list(query?: {
-        type?: string;
-        status?: string;
-        limit?: string;
-        cursor?: string;
-    }): Promise<EntityListResponse>;
-    update(id: string, data: Record<string, unknown>, fence: number): Promise<EntityResponse>;
-    archive(id: string, fence: number): Promise<ArchiveSuccessResponse>;
-    addRelationship(fromId: string, toId: string, type: string): Promise<CreateEntityRelationshipResponse>;
-    addArtifactRef(entityId: string, artifactKey: string, slot: string, metadata?: Record<string, unknown>): Promise<{
-        ok: true;
-    }>;
-    listArtifactRefs(entityId: string): Promise<EntityArtifactReferenceListResponse>;
-};
-/**
- * @deprecated Use createTaskMethods instead.
- */
-declare function createEntityMethods(client: TilaClient, projectId: string): {
-    create(id: string, type: string, data?: Record<string, unknown>): Promise<EntityResponse>;
-    get(id: string): Promise<EntityDetailResponse>;
-    list(query?: {
-        type?: string;
-        status?: string;
-        limit?: string;
-        cursor?: string;
-    }): Promise<EntityListResponse>;
-    update(id: string, data: Record<string, unknown>, fence: number): Promise<EntityResponse>;
-    archive(id: string, fence: number): Promise<ArchiveSuccessResponse>;
-    addRelationship(fromId: string, toId: string, type: string): Promise<CreateEntityRelationshipResponse>;
-    addArtifactRef(entityId: string, artifactKey: string, slot: string, metadata?: Record<string, unknown>): Promise<{
-        ok: true;
-    }>;
-    listArtifactRefs(entityId: string): Promise<EntityArtifactReferenceListResponse>;
-};
-/**
- * @deprecated Use createTaskMethods instead.
- */
-declare function createWorkUnitMethods(client: TilaClient, projectId: string): {
-    create(id: string, type: string, data?: Record<string, unknown>): Promise<EntityResponse>;
-    get(id: string): Promise<EntityDetailResponse>;
-    list(query?: {
-        type?: string;
-        status?: string;
-        limit?: string;
-        cursor?: string;
-    }): Promise<EntityListResponse>;
-    update(id: string, data: Record<string, unknown>, fence: number): Promise<EntityResponse>;
-    archive(id: string, fence: number): Promise<ArchiveSuccessResponse>;
-    addRelationship(fromId: string, toId: string, type: string): Promise<CreateEntityRelationshipResponse>;
-    addArtifactRef(entityId: string, artifactKey: string, slot: string, metadata?: Record<string, unknown>): Promise<{
-        ok: true;
-    }>;
-    listArtifactRefs(entityId: string): Promise<EntityArtifactReferenceListResponse>;
-};
-
-declare function createClaimMethods(client: TilaClient, projectId: string): {
-    acquire(resource: string, mode: ClaimMode, ttlMs: number, opts?: {
-        metadata?: Record<string, unknown>;
-        idempotency_key?: string;
-    }): Promise<AcquireSuccessResponse>;
-    renew(resource: string, fence: number, ttlMs: number): Promise<RenewSuccessResponse>;
-    release(resource: string, fence: number): Promise<ReleaseSuccessResponse>;
-    list(): Promise<StateListResponse>;
-    get(resource: string): Promise<StateResponse>;
-};
-
-interface ArtifactUploadOpts {
-    kind: string;
-    resource?: string;
-    fence?: number;
-    mimeType?: string;
-    flavor?: string;
-}
-declare function createArtifactMethods(client: TilaClient, projectId: string): {
-    upload: {
-        (file: File | Blob, opts: ArtifactUploadOpts): Promise<ArtifactPutResponse>;
-        (stream: ReadableStream, opts: ArtifactUploadOpts & {
-            mimeType: string;
-        }): Promise<ArtifactPutResponse>;
-    };
-    download(key: string): Promise<{
-        body: ReadableStream;
-        contentType: string;
-        contentLength: number | null;
-    }>;
-    list(query?: {
-        resource?: string;
-        kind?: string;
-        limit?: string;
-    }): Promise<ArtifactListResponse>;
-    search(q: string, opts?: {
-        kind?: string;
-        resource?: string;
-        limit?: string;
-    }): Promise<ArtifactSearchResponse>;
-    grep(pattern: string, opts?: {
-        kind?: string;
-        resource?: string;
-        regex?: boolean;
-        limit?: number;
-    }): Promise<ArtifactGrepResponse>;
-    addRelationship(fromKey: string, toKeyOrUri: string, type: string, metadata?: Record<string, unknown>): Promise<ArtifactRelationshipOkResponse>;
-    listRelationships(key: string): Promise<ArtifactRelationshipListResponse>;
-    getLatest(kind: string, resource: string): Promise<ArtifactPointer | null>;
-    writeText(content: string, opts: {
-        kind: string;
-        mimeType?: string;
-        resource?: string;
-        fence?: number;
-    }): Promise<ArtifactPutResponse>;
-    readText(key: string): Promise<{
-        content: string;
-        mimeType: string;
-    }>;
-};
-
-declare function createTokenMethods(client: TilaClient): {
-    issue(name: string, note?: string): Promise<TokenIssueResponse>;
-    revoke(name: string): Promise<TokenRevokeResponse>;
-    list(): Promise<TokenListResponse>;
-};
-
-declare function createJournalMethods(client: TilaClient, projectId: string): {
-    query(opts?: {
-        entity_id?: string;
-        event_kind?: string;
-        limit?: string;
-        cursor?: string;
-    }): Promise<JournalResponse>;
-};
-
-declare function createPresenceMethods(client: TilaClient, projectId: string): {
-    heartbeat(machine: string, ttlMs?: number): Promise<PresenceHeartbeatSuccessResponse>;
-    list(): Promise<PresenceListResponse>;
-    /**
-     * List all presence records across all machines, including whether each is active.
-     * Hits GET /projects/:projectId/presence/all
-     */
-    listAll(): Promise<PresenceAllListResponse>;
-};
-
-declare function createRecordMethods(client: TilaClient, projectId: string): {
-    create(type: string, req: RecordCreateRequest): Promise<RecordMutateResponse>;
-    set(type: string, key: string, req: RecordSetRequest): Promise<RecordMutateResponse>;
-    get(type: string, key: string): Promise<RecordGetResponse>;
-    patch(type: string, key: string, req: RecordPatchRequest): Promise<RecordMutateResponse>;
-    archive(type: string, key: string, req: RecordArchiveRequest): Promise<RecordMutateResponse>;
-    unarchive(type: string, key: string, req: RecordUnarchiveRequest): Promise<RecordMutateResponse>;
-    history(type: string, key: string, opts?: {
-        limit?: number;
-        values?: boolean;
-    }): Promise<RecordHistoryResponse>;
-    list(type: string, query?: {
-        tag?: string;
-        filter?: string;
-        "include-archived"?: string;
-        limit?: string;
-    }): Promise<RecordListResponse>;
-    types(): Promise<RecordTypesResponse>;
-    typesInUse(): Promise<RecordTypesResponse>;
-};
-
-declare function createSchemaMethods(client: TilaClient, projectId: string): {
-    get(): Promise<{
-        ok: true;
-        schema: unknown;
-        version: number;
-    }>;
-    apply(schema: unknown, strategy?: string): Promise<{
-        ok: true;
-        version: number;
-        diff: unknown;
-    }>;
-    history(opts?: {
-        limit?: string;
-    }): Promise<{
-        ok: true;
-        entries: unknown[];
-    }>;
-};
-
-declare function createSignalMethods(client: TilaClient, projectId: string): {
-    /** Fetch the signal inbox for the current token. GET /projects/:id/signals */
-    inbox(): Promise<InboxResponse>;
-    /** Send a signal to a target. POST /projects/:id/signals/send */
-    send(req: SendSignalRequest): Promise<SendSignalResponse>;
-    /** Acknowledge a signal. POST /projects/:id/signals/:signalId/ack */
-    ack(signalId: string): Promise<AckSignalResponse>;
-};
-
-declare function createGateMethods(client: TilaClient, projectId: string): {
-    /** List gates with optional filters. GET /projects/:id/gates */
-    list(query?: {
-        resource?: string;
-        status?: string;
-        limit?: string;
-    }): Promise<GateListResponse>;
-    /** Create a new gate. POST /projects/:id/gates */
-    create(req: CreateGateRequest): Promise<GateResponse>;
-    /** Resolve a gate. POST /projects/:id/gates/:gateId/resolve */
-    resolve(gateId: string, req?: ResolveGateRequest): Promise<GateResponse>;
-    /** Delete a gate. DELETE /projects/:id/gates/:gateId */
-    remove(gateId: string): Promise<{
-        ok: true;
-    }>;
-};
-
-declare function createTemplateMethods(client: TilaClient, projectId: string): {
-    /** Instantiate an entity template. POST /projects/:id/templates/instantiate */
-    instantiate(req: InstantiateTemplateRequest): Promise<InstantiateTemplateResponse>;
-    /** List available templates from the project schema. GET /projects/:id/templates */
-    list(): Promise<{
-        ok: true;
-        templates: Array<{
-            name: string;
-            type: string;
-            description: string | null;
-            variables: string[];
-        }>;
-    }>;
-};
-
 interface IndexCreateOpts {
     kind?: string;
     resource?: string;
@@ -413,16 +559,412 @@ declare function createIndexMethods(client: TilaClient, projectId: string): {
     listEntries(indexKey: string): Promise<ArtifactRelationshipListResponse>;
 };
 
-declare function createSummaryMethods(client: TilaClient, projectId: string): {
-    /** Get project summary. GET /projects/:id/summary */
-    get(): Promise<SummaryResponse>;
+declare function createNamespace(client: TilaClient, projectId: string, ns: string): {
+    tasks: {
+        create(id: string, type: string, data?: Record<string, unknown>): Promise<{
+            entity: {
+                type: string;
+                tags: string[];
+                created_at: number;
+                data: Record<string, unknown>;
+                schema_version: number;
+                id: string;
+                archived: number;
+                updated_at: number;
+                created_by: string;
+            };
+            ok: true;
+        }>;
+        get(id: string): Promise<{
+            entity: {
+                type: string;
+                tags: string[];
+                created_at: number;
+                data: Record<string, unknown>;
+                schema_version: number;
+                id: string;
+                archived: number;
+                updated_at: number;
+                created_by: string;
+            };
+            ok: true;
+            relationships: {
+                type: "parent-child" | "blocks" | "soft-blocks" | "related" | "discovered-from";
+                created_at: number;
+                from_id: string;
+                to_id: string;
+                schema_version: number;
+            }[];
+        }>;
+        update(id: string, data: Record<string, unknown>, fence: number): Promise<{
+            entity: {
+                type: string;
+                tags: string[];
+                created_at: number;
+                data: Record<string, unknown>;
+                schema_version: number;
+                id: string;
+                archived: number;
+                updated_at: number;
+                created_by: string;
+            };
+            ok: true;
+        }>;
+        list(query?: {
+            type?: string;
+            status?: string;
+            limit?: string;
+            cursor?: string;
+        }): Promise<{
+            entities: {
+                type: string;
+                tags: string[];
+                created_at: number;
+                data: Record<string, unknown>;
+                schema_version: number;
+                id: string;
+                archived: number;
+                updated_at: number;
+                created_by: string;
+            }[];
+            ok: true;
+        }>;
+        archive(id: string, fence: number): Promise<ArchiveSuccessResponse>;
+        addRelationship(fromId: string, toId: string, type: string): Promise<CreateEntityRelationshipResponse>;
+        listRelationships(filter?: {
+            fromId?: string;
+            toId?: string;
+            type?: string;
+        }): Promise<ListEntityRelationshipsResponse>;
+        ready(query?: {
+            type?: string;
+            parent?: string;
+            limit?: number;
+            includeSoftBlocked?: boolean;
+        }): Promise<EntityListResponse>;
+        addArtifactRef(entityId: string, artifactKey: string, slot: string, metadata?: Record<string, unknown>): Promise<{
+            ok: true;
+        }>;
+        listArtifactRefs(entityId: string): Promise<EntityArtifactReferenceListResponse>;
+    };
+    records: {
+        create(type: string, req: Parameters<(type: string, req: RecordCreateRequest) => Promise<RecordMutateResponse>>[1]): Promise<{
+            fence: number;
+            ok: true;
+            record: {
+                value: Record<string, unknown>;
+                type: string;
+                tags: string[];
+                created_at: number;
+                schema_version: number;
+                archived: number;
+                updated_at: number;
+                key: string;
+                value_sha256: string;
+                revision: number;
+                updated_by: string;
+            };
+            revision: number;
+        }>;
+        set(type: string, key: string, req: Parameters<(type: string, key: string, req: RecordSetRequest) => Promise<RecordMutateResponse>>[2]): Promise<{
+            fence: number;
+            ok: true;
+            record: {
+                value: Record<string, unknown>;
+                type: string;
+                tags: string[];
+                created_at: number;
+                schema_version: number;
+                archived: number;
+                updated_at: number;
+                key: string;
+                value_sha256: string;
+                revision: number;
+                updated_by: string;
+            };
+            revision: number;
+        }>;
+        get(type: string, key: string): Promise<{
+            fence: number;
+            ok: true;
+            record: {
+                value: Record<string, unknown>;
+                type: string;
+                tags: string[];
+                created_at: number;
+                schema_version: number;
+                archived: number;
+                updated_at: number;
+                key: string;
+                value_sha256: string;
+                revision: number;
+                updated_by: string;
+            };
+        }>;
+        patch(type: string, key: string, req: Parameters<(type: string, key: string, req: RecordPatchRequest) => Promise<RecordMutateResponse>>[2]): Promise<{
+            fence: number;
+            ok: true;
+            record: {
+                value: Record<string, unknown>;
+                type: string;
+                tags: string[];
+                created_at: number;
+                schema_version: number;
+                archived: number;
+                updated_at: number;
+                key: string;
+                value_sha256: string;
+                revision: number;
+                updated_by: string;
+            };
+            revision: number;
+        }>;
+        archive(type: string, key: string, req: Parameters<(type: string, key: string, req: RecordArchiveRequest) => Promise<RecordMutateResponse>>[2]): Promise<{
+            fence: number;
+            ok: true;
+            record: {
+                value: Record<string, unknown>;
+                type: string;
+                tags: string[];
+                created_at: number;
+                schema_version: number;
+                archived: number;
+                updated_at: number;
+                key: string;
+                value_sha256: string;
+                revision: number;
+                updated_by: string;
+            };
+            revision: number;
+        }>;
+        unarchive(type: string, key: string, req: Parameters<(type: string, key: string, req: RecordUnarchiveRequest) => Promise<RecordMutateResponse>>[2]): Promise<{
+            fence: number;
+            ok: true;
+            record: {
+                value: Record<string, unknown>;
+                type: string;
+                tags: string[];
+                created_at: number;
+                schema_version: number;
+                archived: number;
+                updated_at: number;
+                key: string;
+                value_sha256: string;
+                revision: number;
+                updated_by: string;
+            };
+            revision: number;
+        }>;
+        history(type: string, key: string, opts?: Parameters<(type: string, key: string, opts?: {
+            limit?: number;
+            values?: boolean;
+        }) => Promise<RecordHistoryResponse>>[2]): Promise<{
+            items: {
+                type: string;
+                message: string | null;
+                created_at: number;
+                actor: string;
+                schema_version: number;
+                key: string;
+                source_artifact_key: string | null;
+                value_sha256: string;
+                revision: number;
+                operation: "set" | "archived" | "created" | "patch" | "unarchived";
+                canonical_artifact_key: string | null;
+                value?: Record<string, unknown> | undefined;
+            }[];
+            ok: true;
+            meta: {
+                total: number;
+                limit: number;
+                next_cursor: string | null;
+            };
+        }>;
+        list(type: string, query?: Parameters<(type: string, query?: {
+            tag?: string;
+            filter?: string;
+            "include-archived"?: string;
+            limit?: string;
+            tagFilter?: string[];
+        }) => Promise<RecordListResponse>>[1]): Promise<{
+            items: {
+                type: string;
+                tags: string[];
+                archived: number;
+                updated_at: number;
+                key: string;
+                revision: number;
+                updated_by: string;
+            }[];
+            ok: true;
+            meta: {
+                total: number;
+                limit: number;
+                next_cursor: string | null;
+            };
+        }>;
+        types(): Promise<{
+            types: string[];
+            ok: true;
+        }>;
+        typesInUse(): Promise<{
+            types: string[];
+            ok: true;
+        }>;
+    };
+    artifacts: {
+        upload(input: File | Blob | ReadableStream, opts: Parameters<{
+            (file: File | Blob, opts: ArtifactUploadOpts): Promise<ArtifactPutResponse>;
+            (stream: ReadableStream, opts: ArtifactUploadOpts & {
+                mimeType: string;
+            }): Promise<ArtifactPutResponse>;
+        }>[1] & {
+            mimeType?: string;
+        }): Promise<{
+            bytes: number;
+            ok: true;
+            key: string;
+            deduplicated: boolean;
+        }>;
+        writeText(content: string, opts: Parameters<(content: string, opts: {
+            kind: string;
+            mimeType?: string;
+            resource?: string;
+            fence?: number;
+            tags?: string[];
+        }) => Promise<ArtifactPutResponse>>[1]): Promise<{
+            bytes: number;
+            ok: true;
+            key: string;
+            deduplicated: boolean;
+        }>;
+        list(query?: Parameters<(query?: {
+            resource?: string;
+            kind?: string;
+            limit?: string;
+            tagFilter?: string[];
+        }) => Promise<ArtifactListResponse>>[0]): Promise<{
+            pointers: {
+                kind: string;
+                r2_key: string;
+                resource: string | null;
+                sha256: string;
+                bytes: number;
+                fence: number | null;
+                mime_type: string;
+                produced_at: number;
+                produced_by: string;
+                expires_at: number | null;
+                tombstoned: number;
+                tags: string[];
+            }[];
+            ok: true;
+        }>;
+        search(q: string, opts?: Parameters<(q: string, opts?: {
+            kind?: string;
+            resource?: string;
+            limit?: string;
+            tagFilter?: string[];
+        }) => Promise<ArtifactSearchResponse>>[1]): Promise<{
+            results: {
+                kind: string;
+                r2_key: string;
+                resource: string | null;
+                mime_type: string;
+                produced_at: number;
+                title: string | null;
+                snippet: string | null;
+                indexed_at: number;
+            }[];
+            ok: true;
+            total: number;
+        }>;
+        grep(pattern: string, opts?: Parameters<(pattern: string, opts?: {
+            kind?: string;
+            resource?: string;
+            regex?: boolean;
+            limit?: number;
+        }) => Promise<ArtifactGrepResponse>>[1]): Promise<{
+            results: {
+                kind: string;
+                resource: string | null;
+                key: string;
+                lines: {
+                    line: number;
+                    text: string;
+                    col: number;
+                }[];
+                truncated?: boolean | undefined;
+            }[];
+            ok: true;
+            skipped: number;
+            truncated: boolean;
+            scanned: number;
+        }>;
+        getLatest(kind: string, resource: string): Promise<{
+            kind: string;
+            r2_key: string;
+            resource: string | null;
+            sha256: string;
+            bytes: number;
+            fence: number | null;
+            mime_type: string;
+            produced_at: number;
+            produced_by: string;
+            expires_at: number | null;
+            tombstoned: number;
+            tags: string[];
+        } | null>;
+        download(key: string): Promise<{
+            body: ReadableStream;
+            contentType: string;
+            contentLength: number | null;
+        }>;
+        addRelationship(fromKey: string, toKeyOrUri: string, type: string, metadata?: Record<string, unknown>): Promise<ArtifactRelationshipOkResponse>;
+        listRelationships(key: string): Promise<ArtifactRelationshipListResponse>;
+        readText(key: string): Promise<{
+            content: string;
+            mimeType: string;
+        }>;
+    };
+    templates: {
+        instantiate(req: Parameters<(req: InstantiateTemplateRequest) => Promise<InstantiateTemplateResponse>>[0]): Promise<{
+            ok: true;
+            created_entities: string[];
+            created_relationships: number;
+            journal_seq: number;
+        }>;
+        list(): Promise<{
+            templates: {
+                name: string;
+                type: string;
+                description: string | null;
+                variables: string[];
+            }[];
+            ok: true;
+        }>;
+    };
 };
 
-declare function createSearchMethods(client: TilaClient, projectId: string): {
-    search(q: string, opts?: {
-        limit?: number;
-    }): Promise<UnifiedSearchResponse>;
-};
+/**
+ * Pure prefix/strip primitives for the namespace coexistence convention.
+ * No I/O — shared by all four resource adapters in namespace.ts.
+ */
+/**
+ * Validates that a namespace string matches /^[a-z][a-z0-9_-]*$/.
+ * Throws TypeError for empty strings or strings containing invalid characters.
+ */
+declare function validateNamespace(ns: string): void;
+/**
+ * Returns "${ns}_${name}".
+ * Throws a plain Error (not TilaApiError) if the name already starts with "${ns}_".
+ */
+declare function applyPrefix(ns: string, name: string): string;
+/**
+ * Returns the name with a leading "${ns}_" removed if present; otherwise returns name unchanged.
+ * Never throws — tolerant strip for mixed-namespace lists.
+ */
+declare function stripPrefix(ns: string, name: string): string;
 
 type ErrorListener = (err: TilaApiError | Error) => void;
 interface ClaimHandleOptions {
@@ -461,4 +1003,154 @@ declare class ClaimHandle {
 }
 declare function withClaim<T>(client: TilaClient, projectId: string, resource: string, mode: ClaimMode, ttlMs: number, callback: (handle: ClaimHandle) => Promise<T>): Promise<T>;
 
-export { type ArtifactUploadOpts, ClaimHandle, type ClaimHandleOptions, type ClientOptions, type IndexCreateOpts, type RetryOptions, TILA_ERRORS, TilaApiError, TilaClient, type TilaErrorCode, createArtifactMethods, createClaimMethods, createEntityMethods, createGateMethods, createIndexMethods, createJournalMethods, createPresenceMethods, createRecordMethods, createSchemaMethods, createSearchMethods, createSignalMethods, createSummaryMethods, createTaskMethods, createTemplateMethods, createTokenMethods, createWorkUnitMethods, exchangeGitHubToken, isTilaApiError, withClaim, withRetry };
+/**
+ * RemoteBackend implements EntityBackend, CoordinationBackend, and the five
+ * new domain backends (JournalBackend, GateBackend, SignalBackend, SchemaBackend,
+ * SummaryBackend) by delegating to TilaClient HTTP calls and unwrapping response
+ * envelopes.
+ *
+ * ArtifactBackend is intentionally NOT implemented here because EntityBackend
+ * and ArtifactBackend both declare `get` and `list` with incompatible return
+ * types — a single class cannot satisfy both interfaces simultaneously.
+ * See RemoteArtifactBackend below.
+ */
+declare class RemoteBackend implements EntityBackend, CoordinationBackend, JournalBackend, GateBackend, SignalBackend, SchemaBackend, SummaryBackend {
+    private client;
+    private projectId;
+    constructor(client: TilaClient, projectId: string);
+    create(input: CreateEntityInput): Promise<Entity>;
+    get(id: string): Promise<Entity | null>;
+    list(filter?: EntityListFilter): Promise<Entity[]>;
+    update(id: string, data: Partial<Entity["data"]>): Promise<Entity>;
+    archive(id: string): Promise<void>;
+    addRelationship(input: RelationshipInput): Promise<{
+        created: boolean;
+    }>;
+    listRelationships(filter?: RelationshipFilter): Promise<EntityRelationship[]>;
+    removeRelationship(input: RelationshipInput): Promise<{
+        removed: boolean;
+    }>;
+    listReady(filter?: ReadyFilter): Promise<Entity[]>;
+    tree(_rootId?: string): Promise<EntityTree>;
+    updateWithFence(id: string, data: Partial<Entity["data"]>, fence: number): Promise<Entity>;
+    addArtifactRef(input: AddArtifactRefInput): Promise<void>;
+    listArtifactRefs(entityId: string): Promise<EntityArtifactReference[]>;
+    acquire(resource: string, machine: string, user: string, mode: "exclusive" | "owner" | "presence", ttlMs: number): Promise<AcquireResult>;
+    renew(resource: string, _machine: string, _user: string, fence: number, ttlMs: number): Promise<RenewResult>;
+    release(resource: string, fence: number): Promise<void>;
+    state(resource: string): Promise<Claim | null>;
+    heartbeat(machine: string, info?: Record<string, unknown>): Promise<void>;
+    listPresence(): Promise<Presence[]>;
+    listClaims(): Promise<Claim[]>;
+    listJournal(query: JournalQuery): Promise<JournalEvent[]>;
+    createGate(resource: string, awaitType: string, fence: number, timeoutAt?: number): Promise<GateRecord>;
+    listGates(filter?: GateFilter): Promise<GateRecord[]>;
+    resolveGate(gateId: string, resolution?: string): Promise<void>;
+    cancelGate(gateId: string): Promise<void>;
+    sendSignal(input: SendSignalInput, _createdBy: string): Promise<{
+        id: string;
+    }>;
+    listSignals(_tokenName: string): Promise<SignalRecord[]>;
+    ackSignal(signalId: string): Promise<{
+        found: boolean;
+    }>;
+    getCurrentSchema(): Promise<SchemaRecord>;
+    applySchema(input: ApplySchemaInput): Promise<ApplySchemaOutput>;
+    getSummary(): Promise<ProjectSummary>;
+}
+/**
+ * RemoteArtifactBackend implements ArtifactBackend separately from RemoteBackend
+ * because EntityBackend and ArtifactBackend both declare `get` and `list` with
+ * incompatible return types. A single class cannot implement both interfaces.
+ *
+ * Both classes are constructed in resolveContext() and wired into their
+ * respective CommandContext slots independently.
+ */
+declare class RemoteArtifactBackend implements ArtifactBackend {
+    private client;
+    private projectId;
+    constructor(client: TilaClient, projectId: string);
+    put(options: ArtifactPutOptions): Promise<{
+        key: string;
+        bytes: number;
+    }>;
+    get(key: string): Promise<{
+        body: ReadableStream;
+        contentType: string;
+        metadata: Record<string, string>;
+    } | null>;
+    list(prefix: string): Promise<{
+        key: string;
+        size: number;
+    }[]>;
+    delete(key: string): Promise<void>;
+    listPointers(query: {
+        resource?: string;
+        kind?: string;
+    }): Promise<ArtifactPointerRecord[]>;
+    addRelationship(fromKey: string, toKeyOrUri: {
+        to_key?: string;
+        to_uri?: string;
+    }, type: string): Promise<void>;
+    listRelationships(key: string): Promise<ArtifactRelationship[]>;
+    searchArtifacts(query: {
+        q: string;
+        kind?: string;
+        resource?: string;
+        limit?: number;
+    }): Promise<ArtifactSearchResultRecord[]>;
+    grepArtifacts(query: {
+        pattern: string;
+        kind?: string;
+        resource?: string;
+        regex?: boolean;
+        limit?: number;
+    }): Promise<ArtifactGrepResponse>;
+    listIndexEntries(indexKey: string): Promise<ArtifactIndexEntry[]>;
+    getLatest(kind: string, resource: string): Promise<ArtifactPointerRecord | null>;
+    writeText(content: string, opts: {
+        kind: string;
+        mimeType?: string;
+        resource?: string;
+        fence?: number;
+    }): Promise<{
+        key: string;
+        bytes: number;
+    }>;
+    readText(key: string): Promise<{
+        content: string;
+        mimeType: string;
+    } | null>;
+}
+/**
+ * RemoteRecordBackend implements RecordBackend over the Worker record HTTP
+ * routes (see `packages/worker/src/routes/records.ts`). Paths mirror the SDK
+ * record methods (`packages/sdk/src/records.ts`) so the two stay in lockstep.
+ *
+ * Wire ↔ RecordRow mapping: the mutate/get responses return a `record`
+ * (`RecordItem`, no fence) plus a top-level `fence`. RecordBackend returns
+ * `RecordRow`, which is `RecordItem` extended with `fence`, so each method
+ * merges the two: `{ ...result.record, fence: result.fence }`.
+ *
+ * Like the SDK, multi-segment keys are encoded segment-by-segment so embedded
+ * slashes survive routing (the Worker matches `:key{.+}`).
+ */
+declare class RemoteRecordBackend implements RecordBackend {
+    private client;
+    private projectId;
+    constructor(client: TilaClient, projectId: string);
+    private base;
+    /** Encode a record key per-segment so embedded `/` separators are preserved. */
+    private encodeKey;
+    createRecord(input: CreateRecordInput): Promise<RecordRow>;
+    setRecord(input: SetRecordInput): Promise<RecordRow>;
+    getRecord(type: string, key: string): Promise<RecordRow | null>;
+    patchRecord(input: PatchRecordInput): Promise<RecordRow>;
+    archiveRecord(input: ArchiveRecordInput): Promise<RecordRow>;
+    unarchiveRecord(input: ArchiveRecordInput): Promise<RecordRow>;
+    listRecords(filter: RecordListFilter): Promise<RecordPage<RecordListItem>>;
+    listRecordHistory(type: string, key: string, opts?: RecordHistoryOptions): Promise<RecordPage<RecordHistoryItem>>;
+    listRecordTypesInUse(): Promise<string[]>;
+}
+
+export { type ArtifactUploadOpts, ClaimHandle, type ClaimHandleOptions, type ClientOptions, type IndexCreateOpts, RemoteArtifactBackend, RemoteBackend, RemoteRecordBackend, type RetryOptions, TILA_ERRORS, TilaApiError, TilaClient, type TilaErrorCode, type TilaFacade, applyPrefix, createArtifactMethods, createClaimMethods, createEntityMethods, createGateMethods, createIndexMethods, createJournalMethods, createNamespace, createPresenceMethods, createRecordMethods, createSchemaMethods, createSearchMethods, createSignalMethods, createSummaryMethods, createTaskMethods, createTemplateMethods, createTila, createTokenMethods, createWorkUnitMethods, exchangeGitHubToken, isTilaApiError, stripPrefix, validateNamespace, withClaim, withRetry };