tila-sdk 0.1.2 → 0.2.0

package/dist/index.js

@@ -9,7 +9,8 @@ z.object({
   archived: z.number().int().default(0),
   created_at: z.number().int(),
   updated_at: z.number().int(),
-  created_by: z.string()
+  created_by: z.string(),
+  tags: z.array(z.string()).default([])
 });
 var ClaimModeSchema = z.enum(["exclusive", "owner", "presence"]);
 z.object({
@@ -71,7 +72,8 @@ z.object({
   produced_at: z.number().int(),
   produced_by: z.string(),
   expires_at: z.number().int().nullable(),
-  tombstoned: z.number().int().default(0)
+  tombstoned: z.number().int().default(0),
+  tags: z.array(z.string()).default([])
 });
 z.object({
   entity_id: z.string(),
@@ -159,15 +161,15 @@ z.object({
   payload: z.unknown().optional(),
   ttl_ms: z.number().int().min(1e3).max(864e5).optional()
 });
-z.object({
+var SendSignalResponseSchema = z.object({
   ok: z.literal(true),
   id: z.string()
 });
-z.object({
+var InboxResponseSchema = z.object({
   ok: z.literal(true),
   signals: z.array(SignalSchema)
 });
-z.object({
+var AckSignalResponseSchema = z.object({
   ok: z.literal(true)
 });
 z.object({
@@ -331,6 +333,21 @@ z.object({
   pages_project_name: z.string().optional(),
   infra_slug: z.string().optional()
 });
+var TagSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_:.-]{0,63}$/, "Invalid tag format");
+var TagsSchema = z.array(TagSchema).transform((tags) => {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const tag of tags) {
+    const lower = tag.toLowerCase();
+    if (!seen.has(lower)) {
+      seen.add(lower);
+      result.push(lower);
+    }
+  }
+  return result;
+}).refine((tags) => tags.length <= 20, "may not have more than 20 tags");
+
+// ../schemas/dist/record.js
 var RecordTypeSchema = z.string().regex(/^[a-z][a-z0-9_-]*$/, "Record type must start with lowercase letter and contain only lowercase letters, digits, underscores, and hyphens");
 var RecordKeySchema = z.string().superRefine((val, ctx) => {
   if (val.length === 0) {
@@ -407,18 +424,7 @@ var RecordKeySchema = z.string().superRefine((val, ctx) => {
     }
   }
 });
-var RecordTagSchema = z.array(z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_:.-]{0,63}$/, "Invalid tag format")).transform((tags) => {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const tag of tags) {
-    const lower = tag.toLowerCase();
-    if (!seen.has(lower)) {
-      seen.add(lower);
-      result.push(lower);
-    }
-  }
-  return result;
-}).refine((tags) => tags.length <= 20, "Record may not have more than 20 tags");
+var RecordTagSchema = TagsSchema;
 function sortKeysDeep(v) {
   if (Array.isArray(v))
     return v.map(sortKeysDeep);
@@ -457,7 +463,7 @@ z.object({
   idempotency_key: z.string().optional(),
   metadata: z.record(z.unknown()).optional()
 });
-z.object({
+var AcquireSuccessResponseSchema = z.object({
   ok: z.literal(true),
   fence: z.number().int(),
   expires_at: z.number().int()
@@ -467,7 +473,7 @@ z.object({
   fence: z.number().int(),
   ttl_ms: z.number().int().positive()
 });
-z.object({
+var RenewSuccessResponseSchema = z.object({
   ok: z.literal(true),
   expires_at: z.number().int()
 });
@@ -475,10 +481,10 @@ z.object({
   resource: z.string(),
   fence: z.number().int()
 });
-z.object({
+var ReleaseSuccessResponseSchema = z.object({
   ok: z.literal(true)
 });
-z.object({
+var StateResponseSchema = z.object({
   ok: z.literal(true),
   claim: z.object({
     resource: z.string(),
@@ -507,16 +513,18 @@ z.object({
 z.object({
   id: z.string(),
   type: z.string(),
-  data: z.record(z.unknown()).default({})
+  data: z.record(z.unknown()).default({}),
+  tags: TagsSchema.optional()
 });
 z.object({
   data: z.record(z.unknown()),
-  fence: z.number().int()
+  fence: z.number().int(),
+  tags: TagsSchema.optional()
 });
 z.object({
   fence: z.number().int()
 });
-z.object({
+var EntityResponseSchema = z.object({
   ok: z.literal(true),
   entity: z.object({
     id: z.string(),
@@ -526,7 +534,8 @@ z.object({
     archived: z.number().int(),
     created_at: z.number().int(),
     updated_at: z.number().int(),
-    created_by: z.string()
+    created_by: z.string(),
+    tags: z.array(z.string())
   })
 });
 z.object({
@@ -539,10 +548,11 @@ z.object({
     archived: z.number().int(),
     created_at: z.number().int(),
     updated_at: z.number().int(),
-    created_by: z.string()
+    created_by: z.string(),
+    tags: z.array(z.string())
   }))
 });
-z.object({
+var PaginatedEntityListResponseSchema = z.object({
   ok: z.literal(true),
   entities: z.array(z.object({
     id: z.string(),
@@ -552,14 +562,15 @@ z.object({
     archived: z.number().int(),
     created_at: z.number().int(),
     updated_at: z.number().int(),
-    created_by: z.string()
+    created_by: z.string(),
+    tags: z.array(z.string())
   })),
   total: z.number().int(),
   limit: z.number().int().nullable(),
   offset: z.number().int(),
   has_more: z.boolean()
 });
-z.object({
+var ListReadyEntitiesResponseSchema = z.object({
   ok: z.literal(true),
   entities: z.array(z.object({
     id: z.string(),
@@ -589,7 +600,7 @@ z.object({
   ok: z.literal(true),
   entity: CompactEntitySchema
 });
-z.object({
+var PaginatedCompactEntityListResponseSchema = z.object({
   ok: z.literal(true),
   entities: z.array(CompactEntitySchema),
   total: z.number().int(),
@@ -597,7 +608,7 @@ z.object({
   offset: z.number().int(),
   has_more: z.boolean()
 });
-z.object({
+var SummaryResponseSchema = z.object({
   ok: z.literal(true),
   project: z.object({
     entity_count: z.number().int(),
@@ -616,7 +627,7 @@ z.object({
     }))
   })
 });
-z.object({
+var EntityDetailResponseSchema = z.object({
   ok: z.literal(true),
   entity: z.object({
     id: z.string(),
@@ -626,11 +637,12 @@ z.object({
     archived: z.number().int(),
     created_at: z.number().int(),
     updated_at: z.number().int(),
-    created_by: z.string()
+    created_by: z.string(),
+    tags: z.array(z.string())
   }),
   relationships: z.array(EntityRelationshipSchema).default([])
 });
-z.object({
+var ArchiveSuccessResponseSchema = z.object({
   ok: z.literal(true)
 });
 z.object({
@@ -638,7 +650,7 @@ z.object({
   to_id: z.string().min(1),
   type: EntityRelationshipTypeSchema
 });
-z.object({
+var CreateEntityRelationshipResponseSchema = z.object({
   ok: z.literal(true),
   created: z.boolean().default(true)
 });
@@ -647,7 +659,7 @@ z.object({
   to_id: z.string().min(1).optional(),
   type: EntityRelationshipTypeSchema.optional()
 });
-z.object({
+var ListEntityRelationshipsResponseSchema = z.object({
   ok: z.literal(true),
   relationships: z.array(EntityRelationshipSchema)
 });
@@ -656,7 +668,7 @@ z.object({
   to_id: z.string().min(1),
   type: EntityRelationshipTypeSchema
 });
-z.object({
+var DeleteEntityRelationshipResponseSchema = z.object({
   ok: z.literal(true),
   removed: z.boolean()
 });
@@ -667,7 +679,7 @@ z.object({
   after_seq: z.number().int().optional(),
   limit: z.number().int().positive().default(100)
 });
-z.object({
+var JournalResponseSchema = z.object({
   ok: z.literal(true),
   events: z.array(z.object({
     seq: z.number().int(),
@@ -694,7 +706,7 @@ z.object({
     info: z.record(z.unknown())
   }))
 });
-z.object({
+var PresenceAllListResponseSchema = z.object({
   ok: z.literal(true),
   machines: z.array(z.object({
     machine: z.string(),
@@ -703,7 +715,7 @@ z.object({
     active: z.boolean()
   }))
 });
-z.object({
+var PresenceHeartbeatSuccessResponseSchema = z.object({
   ok: z.literal(true)
 });
 z.object({
@@ -845,7 +857,7 @@ z.object({
   slot: z.string().min(1),
   metadata: z.record(z.unknown()).default({})
 });
-z.object({
+var EntityArtifactReferenceListResponseSchema = z.object({
   ok: z.literal(true),
   references: z.array(z.object({
     entity_id: z.string(),
@@ -855,6 +867,46 @@ z.object({
     created_at: z.number().int()
   }))
 });
+function parseTagFilter(raw) {
+  if (!raw)
+    return void 0;
+  const parts = raw.split(",").map((s) => s.trim().toLowerCase()).filter((s) => s.length > 0);
+  if (parts.length === 0)
+    return void 0;
+  for (const part of parts) {
+    TagSchema.parse(part);
+  }
+  const unique = [...new Set(parts)];
+  if (unique.length > 20) {
+    throw new z.ZodError([
+      {
+        code: z.ZodIssueCode.too_big,
+        maximum: 20,
+        type: "array",
+        inclusive: true,
+        exact: false,
+        message: "tag_filter may not have more than 20 tags",
+        path: ["tag_filter"]
+      }
+    ]);
+  }
+  return unique;
+}
+var tagFilterQueryParam = z.string().optional().superRefine((v, ctx) => {
+  if (!v)
+    return;
+  try {
+    parseTagFilter(v);
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      for (const issue of err.issues) {
+        ctx.addIssue(issue);
+      }
+    } else {
+      throw err;
+    }
+  }
+}).transform((v) => parseTagFilter(v));
 z.object({
   ok: z.literal(true),
   results: z.array(ArtifactSearchResultSchema),
@@ -865,7 +917,8 @@ z.object({
   kind: z.string().optional(),
   resource: z.string().optional(),
   source_only: z.string().optional().transform((v) => v === "true").pipe(z.boolean()),
-  limit: z.string().optional().default("20").transform((v) => Number.parseInt(v, 10)).pipe(z.number().int().min(1).max(100))
+  limit: z.string().optional().default("20").transform((v) => Number.parseInt(v, 10)).pipe(z.number().int().min(1).max(100)),
+  tag_filter: tagFilterQueryParam
 });
 var ArtifactGrepLineSchema = z.object({
   line: z.number().int(),
@@ -883,7 +936,7 @@ var ArtifactGrepResultSchema = z.object({
   truncated: z.boolean().optional()
   // this blob hit the per-blob byte cap
 });
-z.object({
+var ArtifactGrepResponseSchema = z.object({
   ok: z.literal(true),
   results: z.array(ArtifactGrepResultSchema),
   scanned: z.number().int(),
@@ -919,16 +972,18 @@ z.object({
 });
 z.object({
   q: z.string().min(1).max(200),
-  limit: z.string().optional().default("20").transform((v) => Number.parseInt(v, 10)).pipe(z.number().int().min(1).max(100))
+  limit: z.string().optional().default("20").transform((v) => Number.parseInt(v, 10)).pipe(z.number().int().min(1).max(100)),
+  tag_filter: tagFilterQueryParam
 });
 z.object({
   content: z.string().min(1),
   kind: z.string().min(1),
   mime_type: z.string().default("text/markdown"),
   resource: z.string().optional(),
-  fence: z.number().int().optional()
+  fence: z.number().int().optional(),
+  tags: TagsSchema.optional()
 });
-z.object({
+var ArtifactPutResponseSchema = z.object({
   ok: z.literal(true),
   key: z.string(),
   bytes: z.number(),
@@ -947,7 +1002,8 @@ z.object({
     produced_at: z.number(),
     produced_by: z.string(),
     expires_at: z.number().nullable(),
-    tombstoned: z.number()
+    tombstoned: z.number(),
+    tags: z.array(z.string())
   }))
 });
 z.object({
@@ -1034,12 +1090,15 @@ var RecordItemSchema = z.object({
   updated_by: z.string(),
   tags: z.array(z.string())
 });
-z.object({
+RecordItemSchema.extend({
+  fence: z.number().int()
+});
+var RecordGetResponseSchema = z.object({
   ok: z.literal(true),
   record: RecordItemSchema,
   fence: z.number().int()
 });
-z.object({
+var RecordMutateResponseSchema = z.object({
   ok: z.literal(true),
   record: RecordItemSchema,
   fence: z.number().int(),
@@ -1054,7 +1113,7 @@ var RecordListItemSchema = z.object({
   archived: z.number().int(),
   tags: z.array(z.string())
 });
-z.object({
+var RecordListResponseSchema = z.object({
   ok: z.literal(true),
   items: z.array(RecordListItemSchema),
   meta: z.object({
@@ -1074,9 +1133,12 @@ var RecordHistoryItemSchema = z.object({
   source_artifact_key: z.string().nullable(),
   actor: z.string(),
   created_at: z.number().int(),
-  message: z.string().nullable()
+  message: z.string().nullable(),
+  // Populated only when the history is requested with `includeValues=true`
+  // (wire: `?values=true`). Optional so existing parsers stay compatible.
+  value: z.record(z.unknown()).optional()
 });
-z.object({
+var RecordHistoryResponseSchema = z.object({
   ok: z.literal(true),
   items: z.array(RecordHistoryItemSchema),
   meta: z.object({
@@ -1186,393 +1248,208 @@ z.object({
 z.object({
   resolution: z.string().optional()
 });
-z.object({
+var GateResponseSchema = z.object({
   ok: z.literal(true),
   gate: GateSchema
 });
-z.object({
+var GateListResponseSchema = z.object({
   ok: z.literal(true),
   gates: z.array(GateSchema)
 });
 
-// src/version.ts
-var SDK_VERSION = "0.1.2";
-
-// src/client.ts
-var TilaClient = class _TilaClient {
-  baseUrl;
-  token;
-  validate;
-  timeoutMs;
-  extraHeaders;
-  constructor(opts) {
-    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
-    this.token = opts.token;
-    this.validate = opts.validate ?? false;
-    this.timeoutMs = opts.timeoutMs ?? 3e4;
-    this.extraHeaders = {
-      "X-Tila-Source": `sdk/${SDK_VERSION}`,
-      ...opts.extraHeaders
-    };
-  }
-  /**
-   * Creates an AbortSignal that fires after this.timeoutMs.
-   * Uses AbortSignal.timeout() when available (Node 18.8+, Bun 0.5+, browsers),
-   * falls back to manual setTimeout + AbortController for older runtimes.
-   *
-   * Note: Cloudflare Workers has supported AbortSignal.timeout() since 2023;
-   * the fallback branch will never execute there.
-   */
-  createAbortSignal() {
-    if (typeof AbortSignal.timeout === "function") {
-      return AbortSignal.timeout(this.timeoutMs);
-    }
-    const controller = new AbortController();
-    setTimeout(
-      () => controller.abort(
-        new DOMException(
-          "The operation was aborted due to timeout",
-          "TimeoutError"
-        )
-      ),
-      this.timeoutMs
-    );
-    return controller.signal;
-  }
-  static fromConfig(config, token) {
-    if (!config.worker_url) {
-      throw new Error(
-        `Cannot create TilaClient: config has no worker_url. Use 'tila project create' or set backend = "cloudflare" in .tila/config.toml.`
+// src/artifacts.ts
+function createArtifactMethods(client, projectId) {
+  const base = `/projects/${projectId}/artifacts`;
+  return {
+    upload: Object.assign(
+      function upload(input, opts) {
+        if (input instanceof ReadableStream) {
+          if (!opts.mimeType) {
+            throw new TypeError(
+              "mimeType is required when uploading a ReadableStream. Pass opts.mimeType explicitly."
+            );
+          }
+          return new Response(input).arrayBuffer().then((bytes) => {
+            const uploadFile = new Blob([bytes], {
+              type: opts.mimeType
+            });
+            const formData2 = new FormData();
+            formData2.append("file", uploadFile);
+            formData2.append("kind", opts.kind);
+            formData2.append("mime_type", opts.mimeType);
+            if (opts.resource) formData2.append("resource", opts.resource);
+            if (opts.fence !== void 0)
+              formData2.append("fence", String(opts.fence));
+            if (opts.flavor) formData2.append("flavor", opts.flavor);
+            if (opts.tags !== void 0)
+              formData2.append("tags", JSON.stringify(opts.tags));
+            return client.postFormData(base, formData2);
+          });
+        }
+        const contentType = opts.mimeType || (input instanceof File ? input.type : "") || "";
+        if (!contentType) {
+          throw new TypeError(
+            "contentType is required for uploads when file.type is absent. Pass opts.mimeType explicitly."
+          );
+        }
+        const formData = new FormData();
+        formData.append("file", input);
+        formData.append("kind", opts.kind);
+        formData.append("mime_type", contentType);
+        if (opts.resource) formData.append("resource", opts.resource);
+        if (opts.fence !== void 0)
+          formData.append("fence", String(opts.fence));
+        if (opts.flavor) formData.append("flavor", opts.flavor);
+        if (opts.tags !== void 0)
+          formData.append("tags", JSON.stringify(opts.tags));
+        return client.postFormData(base, formData);
+      },
+      {}
+    ),
+    async download(key) {
+      const res = await client.requestRaw(
+        "GET",
+        `${base}/${encodeURIComponent(key)}`
       );
-    }
-    return new _TilaClient({ baseUrl: config.worker_url, token });
-  }
-  async request(method, path, opts) {
-    const url = new URL(path, `${this.baseUrl}/`);
-    if (opts?.query) {
-      for (const [key, value] of Object.entries(opts.query)) {
-        if (value !== void 0) {
-          url.searchParams.set(key, value);
+      return {
+        body: res.body ?? new ReadableStream(),
+        contentType: res.headers.get("content-type") || "application/octet-stream",
+        contentLength: res.headers.has("content-length") ? Number(res.headers.get("content-length")) : null
+      };
+    },
+    async list(query) {
+      const { tagFilter, ...rest } = query ?? {};
+      const q = { ...rest };
+      if (tagFilter?.length) q.tag_filter = tagFilter.join(",");
+      return client.get(base, { query: q });
+    },
+    async search(q, opts) {
+      const { tagFilter, ...rest } = opts ?? {};
+      const query = { q, ...rest };
+      if (tagFilter?.length) query.tag_filter = tagFilter.join(",");
+      return client.get(`${base}/search`, { query });
+    },
+    async grep(pattern, opts) {
+      const query = { pattern };
+      if (opts?.kind) query.kind = opts.kind;
+      if (opts?.resource) query.resource = opts.resource;
+      if (opts?.regex) query.regex = "true";
+      if (opts?.limit != null) query.limit = String(opts.limit);
+      return client.get(`${base}/grep`, { query });
+    },
+    async addRelationship(fromKey, toKeyOrUri, type, metadata) {
+      const isUri = toKeyOrUri.includes("://");
+      return client.post(
+        `${base}/${encodeURIComponent(fromKey)}/relationships`,
+        {
+          [isUri ? "to_uri" : "to_key"]: toKeyOrUri,
+          type,
+          metadata
         }
+      );
+    },
+    async listRelationships(key) {
+      return client.get(
+        `${base}/${encodeURIComponent(key)}/relationships`
+      );
+    },
+    async getLatest(kind, resource) {
+      let res;
+      try {
+        res = await client.requestRaw("GET", `${base}/latest`, {
+          query: { kind, resource }
+        });
+      } catch (err) {
+        if (err instanceof TilaApiError && err.status === 404) return null;
+        throw err;
       }
-    }
-    const headers = {
-      Authorization: `Bearer ${this.token}`,
-      Accept: "application/json",
-      ...this.extraHeaders
-    };
-    const init = {
-      method,
-      headers,
-      signal: this.createAbortSignal()
-    };
-    if (opts?.body !== void 0) {
-      headers["Content-Type"] = "application/json";
-      init.body = JSON.stringify(opts.body);
-    }
-    let res;
-    try {
-      res = await fetch(url.toString(), init);
-    } catch (err) {
-      if (err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError")) {
-        throw new Error(
-          `Request to ${url.origin} timed out after ${this.timeoutMs}ms`
+      const body = await res.json();
+      return body.pointer;
+    },
+    async writeText(content, opts) {
+      const body = {
+        content,
+        kind: opts.kind,
+        mime_type: opts.mimeType ?? "text/markdown",
+        resource: opts.resource,
+        fence: opts.fence
+      };
+      if (opts.tags !== void 0) body.tags = opts.tags;
+      return client.post(`${base}/text`, body);
+    },
+    async readText(key) {
+      const res = await client.requestRaw(
+        "GET",
+        `${base}/${encodeURIComponent(key)}`
+      );
+      const contentType = res.headers.get("content-type") || "application/octet-stream";
+      if (!contentType.startsWith("text/")) {
+        throw new TypeError(
+          `Artifact ${key} has MIME type ${contentType} \u2014 readText only supports text/* artifacts`
         );
       }
-      throw new Error(
-        `Network error connecting to ${url.origin}: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    if (!res.ok) {
-      await this.throwApiError(res);
-    }
-    const body = await res.json();
-    const shouldValidate = opts?.validate ?? this.validate;
-    if (shouldValidate && opts?.schema) {
-      const result = opts.schema.safeParse(body);
-      if (!result.success) {
-        const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-        throw new Error(
-          `Unexpected response shape from ${method} ${path}:
-${issues}`
-        );
-      }
-      return result.data;
-    }
-    return body;
-  }
-  async get(path, opts) {
-    return this.request("GET", path, {
-      schema: opts?.schema,
-      query: opts?.query,
-      validate: opts?.validate
-    });
-  }
-  async post(path, body, opts) {
-    return this.request("POST", path, {
-      body,
-      schema: opts?.schema,
-      validate: opts?.validate
-    });
-  }
-  async put(path, body, opts) {
-    return this.request("PUT", path, {
-      body,
-      schema: opts?.schema,
-      validate: opts?.validate
-    });
-  }
-  async patch(path, body, opts) {
-    return this.request("PATCH", path, {
-      body,
-      schema: opts?.schema,
-      validate: opts?.validate
-    });
-  }
-  async delete(path, opts) {
-    return this.request("DELETE", path, {
-      schema: opts?.schema,
-      validate: opts?.validate
-    });
-  }
-  async requestRaw(method, path, opts) {
-    const url = new URL(path, `${this.baseUrl}/`);
-    if (opts?.query) {
-      for (const [key, value] of Object.entries(opts.query)) {
-        if (value !== void 0) {
-          url.searchParams.set(key, value);
-        }
-      }
+      const text = await res.text();
+      return { content: text, mimeType: contentType };
     }
-    const headers = {
-      Authorization: `Bearer ${this.token}`,
-      ...this.extraHeaders
-    };
-    let res;
-    try {
-      res = await fetch(url.toString(), {
-        method,
-        headers,
-        signal: this.createAbortSignal()
+  };
+}
+
+// src/claims.ts
+function createClaimMethods(client, projectId) {
+  const base = `/projects/${projectId}/claims`;
+  return {
+    async acquire(resource, mode, ttlMs, opts) {
+      return client.post(`${base}/acquire`, {
+        resource,
+        mode,
+        ttl_ms: ttlMs,
+        ...opts
       });
-    } catch (err) {
-      if (err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError")) {
-        throw new Error(
-          `Request to ${url.origin} timed out after ${this.timeoutMs}ms`
-        );
-      }
-      throw new Error(
-        `Network error connecting to ${url.origin}: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    if (!res.ok) {
-      await this.throwApiError(res);
-    }
-    return res;
-  }
-  async postFormData(path, formData, opts) {
-    const url = new URL(path, `${this.baseUrl}/`);
-    const headers = {
-      Authorization: `Bearer ${this.token}`,
-      Accept: "application/json",
-      ...this.extraHeaders
-    };
-    let res;
-    try {
-      res = await fetch(url.toString(), {
-        method: "POST",
-        headers,
-        body: formData,
-        signal: this.createAbortSignal()
+    },
+    async renew(resource, fence, ttlMs) {
+      return client.post(`${base}/renew`, {
+        resource,
+        fence,
+        ttl_ms: ttlMs
       });
-    } catch (err) {
-      if (err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError")) {
-        throw new Error(
-          `Request to ${url.origin} timed out after ${this.timeoutMs}ms`
-        );
-      }
-      throw new Error(
-        `Network error connecting to ${url.origin}: ${err instanceof Error ? err.message : String(err)}`
+    },
+    async release(resource, fence) {
+      return client.post(`${base}/release`, {
+        resource,
+        fence
+      });
+    },
+    async list() {
+      return client.get(base);
+    },
+    async get(resource) {
+      return client.get(
+        `${base}/${encodeURIComponent(resource)}`
       );
     }
-    if (!res.ok) {
-      await this.throwApiError(res);
-    }
-    const body = await res.json();
-    const shouldValidate = opts?.validate ?? this.validate;
-    if (shouldValidate && opts?.schema) {
-      const result = opts.schema.safeParse(body);
-      if (!result.success) {
-        const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-        throw new Error(
-          `Unexpected response shape from POST ${path}:
-${issues}`
-        );
-      }
-      return result.data;
-    }
-    return body;
-  }
-  async throwApiError(res) {
-    try {
-      const body = await res.json();
-      const parsed = ErrorEnvelopeSchema.safeParse(body);
-      if (parsed.success) {
-        const { code, message, retryable } = parsed.data.error;
-        throw new TilaApiError(res.status, code, message, retryable);
-      }
-    } catch (err) {
-      if (err instanceof TilaApiError) throw err;
-    }
-    throw new TilaApiError(
-      res.status,
-      "UNKNOWN",
-      `HTTP ${res.status}: ${res.statusText}`,
-      false
-    );
-  }
-};
-var TilaApiError = class extends Error {
-  constructor(status, code, message, retryable) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.retryable = retryable;
-    this.name = "TilaApiError";
-  }
-  status;
-  code;
-  retryable;
-};
-function isTilaApiError(err) {
-  return err instanceof TilaApiError;
-}
-async function exchangeGitHubToken(baseUrl, projectId, githubToken) {
-  const url = `${baseUrl.replace(/\/+$/, "")}/api/auth/github/exchange`;
-  let res;
-  try {
-    res = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        project_id: projectId,
-        github_token: githubToken
-      })
-    });
-  } catch (err) {
-    throw new Error(
-      `Network error during GitHub token exchange: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  if (!res.ok) {
-    try {
-      const body2 = await res.json();
-      const parsed = ErrorEnvelopeSchema.safeParse(body2);
-      if (parsed.success) {
-        const { code, message, retryable } = parsed.data.error;
-        throw new TilaApiError(res.status, code, message, retryable);
-      }
-    } catch (err) {
-      if (err instanceof TilaApiError) throw err;
-    }
-    throw new TilaApiError(
-      res.status,
-      "UNKNOWN",
-      `HTTP ${res.status}: ${res.statusText}`,
-      false
-    );
-  }
-  const body = await res.json();
-  if (!body.session_token || typeof body.expires_at !== "number") {
-    throw new TypeError(
-      "Exchange returned unexpected response shape: missing session_token or expires_at"
-    );
-  }
-  return {
-    sessionToken: body.session_token,
-    expiresAt: body.expires_at,
-    permission: body.permission ?? "read"
   };
 }
 
-// src/retry.ts
-async function withRetry(fn, opts) {
-  const maxRetries = opts?.maxRetries ?? 3;
-  const baseDelayMs = opts?.baseDelayMs ?? 200;
-  const maxDelayMs = opts?.maxDelayMs ?? 3e4;
-  const jitter = opts?.jitter ?? true;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      if (isTilaApiError(err) && err.retryable === false) {
-        throw err;
-      }
-      if (attempt === maxRetries) {
-        throw err;
-      }
-      const cap = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt);
-      const sleepMs = jitter ? Math.random() * cap : cap;
-      await new Promise((resolve) => setTimeout(resolve, sleepMs));
-    }
-  }
-  throw new Error("withRetry: unreachable");
-}
-
-// src/error-codes.ts
-var TILA_ERRORS = {
-  // Auth / middleware (worker layer — SCREAMING_SNAKE_CASE wire values)
-  UNAUTHORIZED: "UNAUTHORIZED",
-  SESSION_EXPIRED: "SESSION_EXPIRED",
-  RATE_LIMITED: "RATE_LIMITED",
-  PERMISSION_DENIED: "PERMISSION_DENIED",
-  PROJECT_MISMATCH: "PROJECT_MISMATCH",
-  CSRF_MISSING_ORIGIN: "CSRF_MISSING_ORIGIN",
-  CSRF_ORIGIN_MISMATCH: "CSRF_ORIGIN_MISMATCH",
-  INTERNAL_ERROR: "INTERNAL_ERROR",
-  DO_UNREACHABLE: "do-unreachable",
-  // Auth endpoint specific
-  REPO_NOT_ALLOWED: "REPO_NOT_ALLOWED",
-  GITHUB_AUTH_FAILED: "GITHUB_AUTH_FAILED",
-  HMAC_NOT_CONFIGURED: "HMAC_NOT_CONFIGURED",
-  // Token endpoint specific
-  TOKEN_NAME_CONFLICT: "TOKEN_NAME_CONFLICT",
-  TOKEN_AUTHZ_DENIED: "TOKEN_AUTHZ_DENIED",
-  TOKEN_NOT_FOUND: "TOKEN_NOT_FOUND",
-  // Validation (worker layer uses SCREAMING_SNAKE for this code)
-  VALIDATION_ERROR: "VALIDATION_ERROR",
-  // DO errors (project-do-router — kebab-case wire values)
-  STALE_FENCE: "stale-fence",
-  NOT_FOUND: "not-found",
-  GATE_ALREADY_SETTLED: "gate-already-settled",
-  NO_FENCE: "no-fence",
-  INTERNAL: "internal",
-  CONSTRAINT_VIOLATION: "constraint-violation",
-  IDEMPOTENCY_KEY_CONFLICT: "idempotency-key-conflict",
-  // DO-layer validation uses kebab-case (distinct from VALIDATION_ERROR above)
-  VALIDATION_ERROR_DO: "validation-error",
-  ALREADY_HELD: "already-held",
-  RENEW_FAILED: "renew-failed",
-  BAD_REQUEST: "bad-request",
-  MISSING_QUERY: "missing-query",
-  INVALID_QUERY: "invalid-query",
-  INVALID_SLOT: "invalid-slot",
-  INVALID_RELATIONSHIP_TYPE: "invalid-relationship-type",
-  // Fallback (SDK-generated when response is unparseable)
-  UNKNOWN: "UNKNOWN"
-};
-
 // src/entities.ts
 function _createMethods(client, base) {
   return {
-    async create(id, type, data) {
-      return client.post(base, { id, type, data });
+    async create(id, type, data, tags) {
+      return client.post(base, {
+        id,
+        type,
+        data,
+        ...tags !== void 0 ? { tags } : {}
+      });
     },
     async get(id) {
       return client.get(`${base}/${id}`);
     },
     async list(query) {
-      return client.get(base, { query });
+      const { tagFilter, compact, ...rest } = query ?? {};
+      const q = { ...rest };
+      if (tagFilter?.length) q.tag_filter = tagFilter.join(",");
+      if (compact) q.compact = "true";
+      return client.get(base, { query: q });
     },
     async update(id, data, fence) {
       return client.patch(`${base}/${id}`, { data, fence });
@@ -1584,13 +1461,34 @@ function _createMethods(client, base) {
     },
     async addRelationship(fromId, toId, type) {
       return client.post(
-        `${base}/${fromId}/relationships`,
+        `${base}/relationships`,
         {
+          from_id: fromId,
           to_id: toId,
           type
         }
       );
     },
+    async listRelationships(filter) {
+      const query = {
+        from_id: filter?.fromId,
+        to_id: filter?.toId,
+        type: filter?.type
+      };
+      return client.get(
+        `${base}/relationships`,
+        { query }
+      );
+    },
+    async ready(query) {
+      const q = {
+        type: query?.type,
+        parent: query?.parent,
+        limit: query?.limit !== void 0 ? String(query.limit) : void 0
+      };
+      if (query?.includeSoftBlocked) q["include-soft-blocked"] = "true";
+      return client.get(`${base}/ready`, { query: q });
+    },
     async addArtifactRef(entityId, artifactKey, slot, metadata) {
       return client.post(`${base}/${entityId}/artifact-refs`, {
         artifact_key: artifactKey,
@@ -1605,366 +1503,663 @@ function _createMethods(client, base) {
     }
   };
 }
-function createTaskMethods(client, projectId) {
-  return _createMethods(client, `/projects/${projectId}/tasks`);
-}
-function createEntityMethods(client, projectId) {
-  return _createMethods(client, `/projects/${projectId}/entities`);
-}
-function createWorkUnitMethods(client, projectId) {
-  return _createMethods(client, `/projects/${projectId}/work-units`);
-}
+function createTaskMethods(client, projectId) {
+  return _createMethods(client, `/projects/${projectId}/tasks`);
+}
+function createEntityMethods(client, projectId) {
+  return _createMethods(client, `/projects/${projectId}/entities`);
+}
+function createWorkUnitMethods(client, projectId) {
+  return _createMethods(client, `/projects/${projectId}/work-units`);
+}
+
+// src/gates.ts
+function createGateMethods(client, projectId) {
+  const base = `/projects/${projectId}/gates`;
+  return {
+    /** List gates with optional filters. GET /projects/:id/gates */
+    async list(query) {
+      return client.get(base, { query });
+    },
+    /** Create a new gate. POST /projects/:id/gates */
+    async create(req) {
+      return client.post(base, req);
+    },
+    /** Resolve a gate. POST /projects/:id/gates/:gateId/resolve */
+    async resolve(gateId, req) {
+      return client.post(`${base}/${gateId}/resolve`, req ?? {});
+    },
+    /** Delete a gate. DELETE /projects/:id/gates/:gateId */
+    async remove(gateId) {
+      return client.delete(`${base}/${gateId}`);
+    }
+  };
+}
+
+// src/journal.ts
+function createJournalMethods(client, projectId) {
+  const base = `/projects/${projectId}/journal`;
+  return {
+    async query(opts) {
+      return client.get(base, {
+        query: {
+          resource: opts?.resource,
+          kind: opts?.kind,
+          after_seq: opts?.after_seq,
+          limit: opts?.limit
+        }
+      });
+    }
+  };
+}
+
+// src/presence.ts
+function createPresenceMethods(client, projectId) {
+  const base = `/projects/${projectId}/presence`;
+  return {
+    async heartbeat(machine, info) {
+      return client.post(
+        `${base}/heartbeat`,
+        {
+          machine,
+          info: info ?? {}
+        }
+      );
+    },
+    async list() {
+      return client.get(base);
+    },
+    /**
+     * List all presence records across all machines, including whether each is active.
+     * Hits GET /projects/:projectId/presence/all
+     */
+    async listAll() {
+      return client.get(`${base}/all`);
+    }
+  };
+}
+
+// src/records.ts
+function encodeKey(key) {
+  return key.split("/").map(encodeURIComponent).join("/");
+}
+function createRecordMethods(client, projectId) {
+  const base = `/projects/${projectId}/records`;
+  return {
+    async create(type, req) {
+      return client.post(`${base}/${type}`, req);
+    },
+    async set(type, key, req) {
+      return client.put(
+        `${base}/${type}/${encodeKey(key)}`,
+        req
+      );
+    },
+    async get(type, key) {
+      return client.get(`${base}/${type}/${encodeKey(key)}`);
+    },
+    async patch(type, key, req) {
+      return client.patch(
+        `${base}/${type}/${encodeKey(key)}`,
+        req
+      );
+    },
+    async archive(type, key, req) {
+      return client.post(
+        `${base}/${type}/~/archive/${encodeKey(key)}`,
+        req
+      );
+    },
+    async unarchive(type, key, req) {
+      return client.post(
+        `${base}/${type}/~/unarchive/${encodeKey(key)}`,
+        req
+      );
+    },
+    async history(type, key, opts) {
+      const query = {};
+      if (opts?.limit !== void 0) query.limit = String(opts.limit);
+      if (opts?.values !== void 0) query.values = String(opts.values);
+      return client.get(
+        `${base}/${type}/~/history/${encodeKey(key)}`,
+        { query }
+      );
+    },
+    async list(type, query) {
+      const { tagFilter, ...rest } = query ?? {};
+      const q = { ...rest };
+      if (tagFilter?.length) q.tag_filter = tagFilter.join(",");
+      return client.get(`${base}/${type}`, { query: q });
+    },
+    async types() {
+      return client.get(`${base}/_types`);
+    },
+    async typesInUse() {
+      const raw = await client.get(`${base}/_types`);
+      return { ok: true, types: raw.in_use_types ?? [] };
+    }
+  };
+}
+
+// src/schema.ts
+function createSchemaMethods(client, projectId) {
+  const base = `/projects/${projectId}/schema`;
+  return {
+    async get() {
+      return client.get(base);
+    },
+    async apply(schema, strategy) {
+      const definition = typeof schema === "string" ? schema : JSON.stringify(schema);
+      return client.post(base, { definition, strategy });
+    },
+    async history(opts) {
+      return client.get(`${base}/history`, { query: opts });
+    }
+  };
+}
+
+// src/search.ts
+function createSearchMethods(client, projectId) {
+  const base = `/projects/${projectId}`;
+  return {
+    async search(q, opts) {
+      const query = { q };
+      if (opts?.limit !== void 0) query.limit = String(opts.limit);
+      if (opts?.tagFilter?.length) query.tag_filter = opts.tagFilter.join(",");
+      return client.get(`${base}/search`, { query });
+    }
+  };
+}
+
+// src/signals.ts
+function createSignalMethods(client, projectId) {
+  const base = `/projects/${projectId}/signals`;
+  return {
+    /** Fetch the signal inbox for the current token. GET /projects/:id/signals */
+    async inbox() {
+      return client.get(base);
+    },
+    /** Send a signal to a target. POST /projects/:id/signals/send */
+    async send(req) {
+      return client.post(`${base}/send`, req);
+    },
+    /** Acknowledge a signal. POST /projects/:id/signals/:signalId/ack */
+    async ack(signalId) {
+      return client.post(`${base}/${signalId}/ack`, {});
+    }
+  };
+}
+
+// src/summary.ts
+function createSummaryMethods(client, projectId) {
+  return {
+    /** Get project summary. GET /projects/:id/summary */
+    async get() {
+      return client.get(`/projects/${projectId}/summary`);
+    }
+  };
+}
+
+// src/templates.ts
+function createTemplateMethods(client, projectId) {
+  const base = `/projects/${projectId}/templates`;
+  return {
+    /** Instantiate an entity template. POST /projects/:id/templates/instantiate */
+    async instantiate(req) {
+      return client.post(
+        `${base}/instantiate`,
+        req
+      );
+    },
+    /** List available templates from the project schema. GET /projects/:id/templates */
+    async list() {
+      return client.get(base);
+    }
+  };
+}
 
-// src/claims.ts
-function createClaimMethods(client, projectId) {
-  const base = `/projects/${projectId}/claims`;
+// src/tokens.ts
+function createTokenMethods(client) {
+  const base = "/api/tokens";
   return {
-    async acquire(resource, mode, ttlMs, opts) {
-      return client.post(`${base}/acquire`, {
-        resource,
-        mode,
-        ttl_ms: ttlMs,
-        ...opts
-      });
-    },
-    async renew(resource, fence, ttlMs) {
-      return client.post(`${base}/renew`, {
-        resource,
-        fence,
-        ttl_ms: ttlMs
-      });
+    async issue(name, note) {
+      return client.post(base, { name, note });
     },
-    async release(resource, fence) {
-      return client.post(`${base}/release`, {
-        resource,
-        fence
-      });
+    async revoke(name) {
+      return client.delete(
+        `${base}/${encodeURIComponent(name)}`
+      );
     },
     async list() {
       return client.get(base);
-    },
-    async get(resource) {
-      return client.get(
-        `${base}/${encodeURIComponent(resource)}`
-      );
     }
   };
 }
 
-// src/artifacts.ts
-function createArtifactMethods(client, projectId) {
-  const base = `/projects/${projectId}/artifacts`;
-  return {
-    upload: Object.assign(
-      function upload(input, opts) {
-        if (input instanceof ReadableStream) {
-          if (!opts.mimeType) {
-            throw new TypeError(
-              "mimeType is required when uploading a ReadableStream. Pass opts.mimeType explicitly."
-            );
-          }
-          return new Response(input).arrayBuffer().then((bytes) => {
-            const uploadFile = new Blob([bytes], {
-              type: opts.mimeType
-            });
-            const formData2 = new FormData();
-            formData2.append("file", uploadFile);
-            formData2.append("kind", opts.kind);
-            formData2.append("mime_type", opts.mimeType);
-            if (opts.resource) formData2.append("resource", opts.resource);
-            if (opts.fence !== void 0)
-              formData2.append("fence", String(opts.fence));
-            if (opts.flavor) formData2.append("flavor", opts.flavor);
-            return client.postFormData(base, formData2);
-          });
-        }
-        const contentType = opts.mimeType || (input instanceof File ? input.type : "") || "";
-        if (!contentType) {
-          throw new TypeError(
-            "contentType is required for uploads when file.type is absent. Pass opts.mimeType explicitly."
-          );
+// src/version.ts
+var SDK_VERSION = "0.2.0";
+
+// src/client.ts
+var TilaClient = class _TilaClient {
+  baseUrl;
+  token;
+  validate;
+  timeoutMs;
+  extraHeaders;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.token = opts.token;
+    this.validate = opts.validate ?? false;
+    this.timeoutMs = opts.timeoutMs ?? 3e4;
+    this.extraHeaders = {
+      "X-Tila-Source": `sdk/${SDK_VERSION}`,
+      ...opts.extraHeaders
+    };
+  }
+  /**
+   * Creates an AbortSignal that fires after this.timeoutMs.
+   * Uses AbortSignal.timeout() when available (Node 18.8+, Bun 0.5+, browsers),
+   * falls back to manual setTimeout + AbortController for older runtimes.
+   *
+   * Note: Cloudflare Workers has supported AbortSignal.timeout() since 2023;
+   * the fallback branch will never execute there.
+   */
+  createAbortSignal() {
+    if (typeof AbortSignal.timeout === "function") {
+      return AbortSignal.timeout(this.timeoutMs);
+    }
+    const controller = new AbortController();
+    setTimeout(
+      () => controller.abort(
+        new DOMException(
+          "The operation was aborted due to timeout",
+          "TimeoutError"
+        )
+      ),
+      this.timeoutMs
+    );
+    return controller.signal;
+  }
+  static fromConfig(config, token, opts) {
+    if (config.backend === "local") {
+      throw new Error(
+        `Cannot create an HTTP TilaClient for a local backend (backend = "local"). The local backend runs in-process on SQLite \u2014 use createTila(config) (which routes to the in-process backend) or import createTilaLocal from 'tila-sdk/local' directly.`
+      );
+    }
+    if (!config.worker_url) {
+      throw new Error(
+        `Cannot create TilaClient: config has no worker_url. Use 'tila project create' or set backend = "cloudflare" in .tila/config.toml.`
+      );
+    }
+    return new _TilaClient({
+      baseUrl: config.worker_url,
+      token,
+      // Optional caller attribution (e.g. mcp-server/<version>). When omitted,
+      // the constructor's default X-Tila-Source (sdk/<version>) applies.
+      ...opts?.extraHeaders ? { extraHeaders: opts.extraHeaders } : {}
+    });
+  }
+  async request(method, path, opts) {
+    const url = new URL(path, `${this.baseUrl}/`);
+    if (opts?.query) {
+      for (const [key, value] of Object.entries(opts.query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, value);
         }
-        const formData = new FormData();
-        formData.append("file", input);
-        formData.append("kind", opts.kind);
-        formData.append("mime_type", contentType);
-        if (opts.resource) formData.append("resource", opts.resource);
-        if (opts.fence !== void 0)
-          formData.append("fence", String(opts.fence));
-        if (opts.flavor) formData.append("flavor", opts.flavor);
-        return client.postFormData(base, formData);
-      },
-      {}
-    ),
-    async download(key) {
-      const res = await client.requestRaw(
-        "GET",
-        `${base}/${encodeURIComponent(key)}`
+      }
+    }
+    const headers = {
+      Authorization: `Bearer ${this.token}`,
+      Accept: "application/json",
+      ...this.extraHeaders
+    };
+    const init = {
+      method,
+      headers,
+      signal: this.createAbortSignal()
+    };
+    if (opts?.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(opts.body);
+    }
+    let res;
+    try {
+      res = await fetch(url.toString(), init);
+    } catch (err) {
+      if (err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError")) {
+        throw new Error(
+          `Request to ${url.origin} timed out after ${this.timeoutMs}ms`
+        );
+      }
+      throw new Error(
+        `Network error connecting to ${url.origin}: ${err instanceof Error ? err.message : String(err)}`
       );
-      return {
-        body: res.body ?? new ReadableStream(),
-        contentType: res.headers.get("content-type") || "application/octet-stream",
-        contentLength: res.headers.has("content-length") ? Number(res.headers.get("content-length")) : null
-      };
-    },
-    async list(query) {
-      return client.get(base, { query });
-    },
-    async search(q, opts) {
-      return client.get(`${base}/search`, {
-        query: { q, ...opts }
-      });
-    },
-    async grep(pattern, opts) {
-      const query = { pattern };
-      if (opts?.kind) query.kind = opts.kind;
-      if (opts?.resource) query.resource = opts.resource;
-      if (opts?.regex) query.regex = "true";
-      if (opts?.limit != null) query.limit = String(opts.limit);
-      return client.get(`${base}/grep`, { query });
-    },
-    async addRelationship(fromKey, toKeyOrUri, type, metadata) {
-      const isUri = toKeyOrUri.includes("://");
-      return client.post(
-        `${base}/${encodeURIComponent(fromKey)}/relationships`,
-        {
-          [isUri ? "to_uri" : "to_key"]: toKeyOrUri,
-          type,
-          metadata
+    }
+    if (!res.ok) {
+      await this.throwApiError(res);
+    }
+    const body = await res.json();
+    const shouldValidate = opts?.validate ?? this.validate;
+    if (shouldValidate && opts?.schema) {
+      const result = opts.schema.safeParse(body);
+      if (!result.success) {
+        const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+        throw new Error(
+          `Unexpected response shape from ${method} ${path}:
+${issues}`
+        );
+      }
+      return result.data;
+    }
+    return body;
+  }
+  async get(path, opts) {
+    return this.request("GET", path, {
+      schema: opts?.schema,
+      query: opts?.query,
+      validate: opts?.validate
+    });
+  }
+  async post(path, body, opts) {
+    return this.request("POST", path, {
+      body,
+      schema: opts?.schema,
+      validate: opts?.validate
+    });
+  }
+  async put(path, body, opts) {
+    return this.request("PUT", path, {
+      body,
+      schema: opts?.schema,
+      validate: opts?.validate
+    });
+  }
+  async patch(path, body, opts) {
+    return this.request("PATCH", path, {
+      body,
+      schema: opts?.schema,
+      validate: opts?.validate
+    });
+  }
+  async delete(path, opts) {
+    return this.request("DELETE", path, {
+      schema: opts?.schema,
+      validate: opts?.validate
+    });
+  }
+  async requestRaw(method, path, opts) {
+    const url = new URL(path, `${this.baseUrl}/`);
+    if (opts?.query) {
+      for (const [key, value] of Object.entries(opts.query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, value);
         }
-      );
-    },
-    async listRelationships(key) {
-      return client.get(
-        `${base}/${encodeURIComponent(key)}/relationships`
-      );
-    },
-    async getLatest(kind, resource) {
-      const res = await client.requestRaw("GET", `${base}/latest`, {
-        query: { kind, resource }
+      }
+    }
+    const headers = {
+      Authorization: `Bearer ${this.token}`,
+      ...this.extraHeaders
+    };
+    let res;
+    try {
+      res = await fetch(url.toString(), {
+        method,
+        headers,
+        signal: this.createAbortSignal()
       });
-      if (res.status === 404) return null;
-      if (!res.ok) {
-        const body2 = await res.json().catch(() => ({}));
+    } catch (err) {
+      if (err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError")) {
         throw new Error(
-          `getLatest failed with status ${res.status}: ${JSON.stringify(body2)}`
+          `Request to ${url.origin} timed out after ${this.timeoutMs}ms`
         );
       }
-      const body = await res.json();
-      return body.pointer;
-    },
-    async writeText(content, opts) {
-      return client.post(`${base}/text`, {
-        content,
-        kind: opts.kind,
-        mime_type: opts.mimeType ?? "text/markdown",
-        resource: opts.resource,
-        fence: opts.fence
-      });
-    },
-    async readText(key) {
-      const res = await client.requestRaw(
-        "GET",
-        `${base}/${encodeURIComponent(key)}`
+      throw new Error(
+        `Network error connecting to ${url.origin}: ${err instanceof Error ? err.message : String(err)}`
       );
-      const contentType = res.headers.get("content-type") || "application/octet-stream";
-      if (!contentType.startsWith("text/")) {
-        throw new TypeError(
-          `Artifact ${key} has MIME type ${contentType} \u2014 readText only supports text/* artifacts`
+    }
+    if (!res.ok) {
+      await this.throwApiError(res);
+    }
+    return res;
+  }
+  async postFormData(path, formData, opts) {
+    const url = new URL(path, `${this.baseUrl}/`);
+    const headers = {
+      Authorization: `Bearer ${this.token}`,
+      Accept: "application/json",
+      ...this.extraHeaders
+    };
+    let res;
+    try {
+      res = await fetch(url.toString(), {
+        method: "POST",
+        headers,
+        body: formData,
+        signal: this.createAbortSignal()
+      });
+    } catch (err) {
+      if (err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError")) {
+        throw new Error(
+          `Request to ${url.origin} timed out after ${this.timeoutMs}ms`
         );
       }
-      const text = await res.text();
-      return { content: text, mimeType: contentType };
-    }
-  };
-}
-
-// src/tokens.ts
-function createTokenMethods(client) {
-  const base = "/api/tokens";
-  return {
-    async issue(name, note) {
-      return client.post(base, { name, note });
-    },
-    async revoke(name) {
-      return client.delete(
-        `${base}/${encodeURIComponent(name)}`
+      throw new Error(
+        `Network error connecting to ${url.origin}: ${err instanceof Error ? err.message : String(err)}`
       );
-    },
-    async list() {
-      return client.get(base);
     }
-  };
-}
-
-// src/journal.ts
-function createJournalMethods(client, projectId) {
-  const base = `/projects/${projectId}/journal`;
-  return {
-    async query(opts) {
-      return client.get(base, { query: opts });
+    if (!res.ok) {
+      await this.throwApiError(res);
     }
-  };
-}
-
-// src/presence.ts
-function createPresenceMethods(client, projectId) {
-  const base = `/projects/${projectId}/presence`;
-  return {
-    async heartbeat(machine, ttlMs) {
-      return client.post(base, {
-        machine,
-        ttl_ms: ttlMs
-      });
-    },
-    async list() {
-      return client.get(base);
-    },
-    /**
-     * List all presence records across all machines, including whether each is active.
-     * Hits GET /projects/:projectId/presence/all
-     */
-    async listAll() {
-      return client.get(`${base}/all`);
+    const body = await res.json();
+    const shouldValidate = opts?.validate ?? this.validate;
+    if (shouldValidate && opts?.schema) {
+      const result = opts.schema.safeParse(body);
+      if (!result.success) {
+        const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+        throw new Error(
+          `Unexpected response shape from POST ${path}:
+${issues}`
+        );
+      }
+      return result.data;
     }
-  };
-}
-
-// src/records.ts
-function encodeKey(key) {
-  return key.split("/").map(encodeURIComponent).join("/");
+    return body;
+  }
+  async throwApiError(res) {
+    try {
+      const body = await res.json();
+      const parsed = ErrorEnvelopeSchema.safeParse(body);
+      if (parsed.success) {
+        const { code, message, retryable } = parsed.data.error;
+        throw new TilaApiError(res.status, code, message, retryable);
+      }
+    } catch (err) {
+      if (err instanceof TilaApiError) throw err;
+    }
+    throw new TilaApiError(
+      res.status,
+      "UNKNOWN",
+      `HTTP ${res.status}: ${res.statusText}`,
+      false
+    );
+  }
+};
+var TilaApiError = class extends Error {
+  constructor(status, code, message, retryable) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "TilaApiError";
+  }
+  status;
+  code;
+  retryable;
+};
+function isTilaApiError(err) {
+  return err instanceof TilaApiError;
 }
-function createRecordMethods(client, projectId) {
-  const base = `/projects/${projectId}/records`;
-  return {
-    async create(type, req) {
-      return client.post(`${base}/${type}`, req);
-    },
-    async set(type, key, req) {
-      return client.put(
-        `${base}/${type}/${encodeKey(key)}`,
-        req
-      );
-    },
-    async get(type, key) {
-      return client.get(`${base}/${type}/${encodeKey(key)}`);
-    },
-    async patch(type, key, req) {
-      return client.patch(
-        `${base}/${type}/${encodeKey(key)}`,
-        req
-      );
-    },
-    async archive(type, key, req) {
-      return client.post(
-        `${base}/${type}/~/archive/${encodeKey(key)}`,
-        req
-      );
-    },
-    async unarchive(type, key, req) {
-      return client.post(
-        `${base}/${type}/~/unarchive/${encodeKey(key)}`,
-        req
-      );
-    },
-    async history(type, key, opts) {
-      const query = {};
-      if (opts?.limit !== void 0) query.limit = String(opts.limit);
-      if (opts?.values !== void 0) query.values = String(opts.values);
-      return client.get(
-        `${base}/${type}/~/history/${encodeKey(key)}`,
-        { query }
-      );
-    },
-    async list(type, query) {
-      return client.get(`${base}/${type}`, { query });
-    },
-    async types() {
-      return client.get(`${base}/_types`);
-    },
-    async typesInUse() {
-      const raw = await client.get(`${base}/_types`);
-      return { ok: true, types: raw.in_use_types ?? [] };
+async function exchangeGitHubToken(baseUrl, projectId, githubToken) {
+  const url = `${baseUrl.replace(/\/+$/, "")}/api/auth/github/exchange`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        project_id: projectId,
+        github_token: githubToken
+      })
+    });
+  } catch (err) {
+    throw new Error(
+      `Network error during GitHub token exchange: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (!res.ok) {
+    try {
+      const body2 = await res.json();
+      const parsed = ErrorEnvelopeSchema.safeParse(body2);
+      if (parsed.success) {
+        const { code, message, retryable } = parsed.data.error;
+        throw new TilaApiError(res.status, code, message, retryable);
+      }
+    } catch (err) {
+      if (err instanceof TilaApiError) throw err;
     }
-  };
-}
-
-// src/schema.ts
-function createSchemaMethods(client, projectId) {
-  const base = `/projects/${projectId}/schema`;
+    throw new TilaApiError(
+      res.status,
+      "UNKNOWN",
+      `HTTP ${res.status}: ${res.statusText}`,
+      false
+    );
+  }
+  const body = await res.json();
+  if (!body.session_token || typeof body.expires_at !== "number") {
+    throw new TypeError(
+      "Exchange returned unexpected response shape: missing session_token or expires_at"
+    );
+  }
   return {
-    async get() {
-      return client.get(base);
-    },
-    async apply(schema, strategy) {
-      return client.post(`${base}/apply`, { schema, strategy });
-    },
-    async history(opts) {
-      return client.get(`${base}/history`, { query: opts });
-    }
+    sessionToken: body.session_token,
+    expiresAt: body.expires_at,
+    permission: body.permission ?? "read"
   };
 }
-
-// src/signals.ts
-function createSignalMethods(client, projectId) {
-  const base = `/projects/${projectId}/signals`;
+function buildHttpFacade(client, projectId) {
   return {
-    /** Fetch the signal inbox for the current token. GET /projects/:id/signals */
-    async inbox() {
-      return client.get(base);
-    },
-    /** Send a signal to a target. POST /projects/:id/signals/send */
-    async send(req) {
-      return client.post(`${base}/send`, req);
-    },
-    /** Acknowledge a signal. POST /projects/:id/signals/:signalId/ack */
-    async ack(signalId) {
-      return client.post(`${base}/${signalId}/ack`, {});
+    tasks: createTaskMethods(client, projectId),
+    records: createRecordMethods(client, projectId),
+    claims: createClaimMethods(client, projectId),
+    artifacts: createArtifactMethods(client, projectId),
+    gates: createGateMethods(client, projectId),
+    signals: createSignalMethods(client, projectId),
+    journal: createJournalMethods(client, projectId),
+    presence: createPresenceMethods(client, projectId),
+    schema: createSchemaMethods(client, projectId),
+    summary: createSummaryMethods(client, projectId),
+    search: createSearchMethods(client, projectId),
+    templates: createTemplateMethods(client, projectId),
+    tokens: createTokenMethods(client),
+    close: () => {
     }
   };
 }
-
-// src/gates.ts
-function createGateMethods(client, projectId) {
-  const base = `/projects/${projectId}/gates`;
-  return {
-    /** List gates with optional filters. GET /projects/:id/gates */
-    async list(query) {
-      return client.get(base, { query });
-    },
-    /** Create a new gate. POST /projects/:id/gates */
-    async create(req) {
-      return client.post(base, req);
-    },
-    /** Resolve a gate. POST /projects/:id/gates/:gateId/resolve */
-    async resolve(gateId, req) {
-      return client.post(`${base}/${gateId}/resolve`, req ?? {});
-    },
-    /** Delete a gate. DELETE /projects/:id/gates/:gateId */
-    async remove(gateId) {
-      return client.delete(`${base}/${gateId}`);
+async function createTila(config, token, opts) {
+  if (config.backend === "local") {
+    if (!config.local) {
+      throw new Error(
+        'createTila: backend = "local" requires a [local] config section with db_path and artifacts_path.'
+      );
     }
-  };
+    const { createTilaLocal, buildLocalResources } = await import('./local.js');
+    const { project, artifacts, close } = await createTilaLocal({
+      dbPath: config.local.db_path,
+      artifactsPath: config.local.artifacts_path,
+      org: config.local.org,
+      project: config.project_id
+    });
+    const resources = buildLocalResources(project, artifacts);
+    return { ...resources, close };
+  }
+  if (token === void 0) {
+    throw new Error(
+      'createTila: the Cloudflare backend requires a token. Pass createTila(config, token), or set backend = "local".'
+    );
+  }
+  const client = TilaClient.fromConfig(config, token, {
+    extraHeaders: opts?.extraHeaders
+  });
+  return buildHttpFacade(client, config.project_id);
 }
 
-// src/templates.ts
-function createTemplateMethods(client, projectId) {
-  const base = `/projects/${projectId}/templates`;
-  return {
-    /** Instantiate an entity template. POST /projects/:id/templates/instantiate */
-    async instantiate(req) {
-      return client.post(
-        `${base}/instantiate`,
-        req
-      );
-    },
-    /** List available templates from the project schema. GET /projects/:id/templates */
-    async list() {
-      return client.get(base);
+// src/retry.ts
+async function withRetry(fn, opts) {
+  const maxRetries = opts?.maxRetries ?? 3;
+  const baseDelayMs = opts?.baseDelayMs ?? 200;
+  const maxDelayMs = opts?.maxDelayMs ?? 3e4;
+  const jitter = opts?.jitter ?? true;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (isTilaApiError(err) && err.retryable === false) {
+        throw err;
+      }
+      if (attempt === maxRetries) {
+        throw err;
+      }
+      const cap = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt);
+      const sleepMs = jitter ? Math.random() * cap : cap;
+      await new Promise((resolve) => setTimeout(resolve, sleepMs));
     }
-  };
+  }
+  throw new Error("withRetry: unreachable");
 }
 
+// src/error-codes.ts
+var TILA_ERRORS = {
+  // Auth / middleware (worker layer — SCREAMING_SNAKE_CASE wire values)
+  UNAUTHORIZED: "UNAUTHORIZED",
+  SESSION_EXPIRED: "SESSION_EXPIRED",
+  RATE_LIMITED: "RATE_LIMITED",
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  PROJECT_MISMATCH: "PROJECT_MISMATCH",
+  CSRF_MISSING_ORIGIN: "CSRF_MISSING_ORIGIN",
+  CSRF_ORIGIN_MISMATCH: "CSRF_ORIGIN_MISMATCH",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  DO_UNREACHABLE: "do-unreachable",
+  // Auth endpoint specific
+  REPO_NOT_ALLOWED: "REPO_NOT_ALLOWED",
+  GITHUB_AUTH_FAILED: "GITHUB_AUTH_FAILED",
+  HMAC_NOT_CONFIGURED: "HMAC_NOT_CONFIGURED",
+  // Token endpoint specific
+  TOKEN_NAME_CONFLICT: "TOKEN_NAME_CONFLICT",
+  TOKEN_AUTHZ_DENIED: "TOKEN_AUTHZ_DENIED",
+  TOKEN_NOT_FOUND: "TOKEN_NOT_FOUND",
+  // Validation (worker layer uses SCREAMING_SNAKE for this code)
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  // DO errors (project-do-router — kebab-case wire values)
+  STALE_FENCE: "stale-fence",
+  NOT_FOUND: "not-found",
+  GATE_ALREADY_SETTLED: "gate-already-settled",
+  NO_FENCE: "no-fence",
+  INTERNAL: "internal",
+  CONSTRAINT_VIOLATION: "constraint-violation",
+  IDEMPOTENCY_KEY_CONFLICT: "idempotency-key-conflict",
+  // DO-layer validation uses kebab-case (distinct from VALIDATION_ERROR above)
+  VALIDATION_ERROR_DO: "validation-error",
+  ALREADY_HELD: "already-held",
+  RENEW_FAILED: "renew-failed",
+  BAD_REQUEST: "bad-request",
+  MISSING_QUERY: "missing-query",
+  INVALID_QUERY: "invalid-query",
+  INVALID_SLOT: "invalid-slot",
+  INVALID_RELATIONSHIP_TYPE: "invalid-relationship-type",
+  // Fallback (SDK-generated when response is unparseable)
+  UNKNOWN: "UNKNOWN"
+};
+
 // src/indexes.ts
 function createIndexMethods(client, projectId) {
   const base = `/projects/${projectId}/artifacts`;
@@ -2007,26 +2202,240 @@ function createIndexMethods(client, projectId) {
     }
   };
 }
-
-// src/summary.ts
-function createSummaryMethods(client, projectId) {
+
+// src/namespace-prefix.ts
+function validateNamespace(ns) {
+  if (!/^[a-z][a-z0-9_-]*$/.test(ns)) {
+    throw new TypeError(
+      `Invalid namespace "${ns}": must match /^[a-z][a-z0-9_-]*$/ (lowercase letter start, then lowercase letters, digits, underscores, or hyphens).`
+    );
+  }
+}
+function applyPrefix(ns, name) {
+  if (name.startsWith(`${ns}_`)) {
+    throw new Error(
+      `Namespace collision: "${name}" already starts with prefix "${ns}_". Call the raw factory if this name is intentional.`
+    );
+  }
+  return `${ns}_${name}`;
+}
+function stripPrefix(ns, name) {
+  const prefix = `${ns}_`;
+  if (name.startsWith(prefix)) {
+    return name.slice(prefix.length);
+  }
+  return name;
+}
+
+// src/namespace.ts
+function namespacedTaskMethods(client, projectId, ns) {
+  const inner = createTaskMethods(client, projectId);
+  return {
+    ...inner,
+    async create(id, type, data) {
+      const result = await inner.create(id, applyPrefix(ns, type), data);
+      return {
+        ...result,
+        entity: { ...result.entity, type: stripPrefix(ns, result.entity.type) }
+      };
+    },
+    async get(id) {
+      const result = await inner.get(id);
+      return {
+        ...result,
+        entity: { ...result.entity, type: stripPrefix(ns, result.entity.type) }
+      };
+    },
+    async update(id, data, fence) {
+      const result = await inner.update(id, data, fence);
+      return {
+        ...result,
+        entity: { ...result.entity, type: stripPrefix(ns, result.entity.type) }
+      };
+    },
+    async list(query) {
+      const prefixedQuery = query ? {
+        ...query,
+        type: query.type !== void 0 ? applyPrefix(ns, query.type) : void 0
+      } : void 0;
+      const result = await inner.list(prefixedQuery);
+      return {
+        ...result,
+        entities: result.entities.map((e) => ({
+          ...e,
+          type: stripPrefix(ns, e.type)
+        }))
+      };
+    }
+  };
+}
+function namespacedRecordMethods(client, projectId, ns) {
+  const inner = createRecordMethods(client, projectId);
+  function stripRecordType(result) {
+    return {
+      ...result,
+      record: { ...result.record, type: stripPrefix(ns, result.record.type) }
+    };
+  }
+  return {
+    async create(type, req) {
+      return stripRecordType(await inner.create(applyPrefix(ns, type), req));
+    },
+    async set(type, key, req) {
+      return stripRecordType(await inner.set(applyPrefix(ns, type), key, req));
+    },
+    async get(type, key) {
+      return stripRecordType(await inner.get(applyPrefix(ns, type), key));
+    },
+    async patch(type, key, req) {
+      return stripRecordType(
+        await inner.patch(applyPrefix(ns, type), key, req)
+      );
+    },
+    async archive(type, key, req) {
+      return stripRecordType(
+        await inner.archive(applyPrefix(ns, type), key, req)
+      );
+    },
+    async unarchive(type, key, req) {
+      return stripRecordType(
+        await inner.unarchive(applyPrefix(ns, type), key, req)
+      );
+    },
+    async history(type, key, opts) {
+      const result = await inner.history(applyPrefix(ns, type), key, opts);
+      return {
+        ...result,
+        items: result.items.map((item) => ({
+          ...item,
+          type: stripPrefix(ns, item.type)
+        }))
+      };
+    },
+    async list(type, query) {
+      const result = await inner.list(applyPrefix(ns, type), query);
+      return {
+        ...result,
+        items: result.items.map((item) => ({
+          ...item,
+          type: stripPrefix(ns, item.type)
+        }))
+      };
+    },
+    async types() {
+      const result = await inner.types();
+      return {
+        ...result,
+        types: result.types.map((t) => stripPrefix(ns, t))
+      };
+    },
+    async typesInUse() {
+      const result = await inner.typesInUse();
+      return {
+        ...result,
+        types: result.types.map((t) => stripPrefix(ns, t))
+      };
+    }
+  };
+}
+function namespacedArtifactMethods(client, projectId, ns) {
+  const inner = createArtifactMethods(client, projectId);
+  return {
+    ...inner,
+    upload(input, opts) {
+      return inner.upload(input, { ...opts, kind: applyPrefix(ns, opts.kind) });
+    },
+    async writeText(content, opts) {
+      return inner.writeText(content, {
+        ...opts,
+        kind: applyPrefix(ns, opts.kind)
+      });
+    },
+    async list(query) {
+      const prefixedQuery = query ? {
+        ...query,
+        kind: query.kind !== void 0 ? applyPrefix(ns, query.kind) : void 0
+      } : void 0;
+      const result = await inner.list(prefixedQuery);
+      return {
+        ...result,
+        pointers: result.pointers.map((p) => ({
+          ...p,
+          kind: stripPrefix(ns, p.kind)
+        }))
+      };
+    },
+    async search(q, opts) {
+      const prefixedOpts = opts ? {
+        ...opts,
+        kind: opts.kind !== void 0 ? applyPrefix(ns, opts.kind) : void 0
+      } : void 0;
+      const result = await inner.search(q, prefixedOpts);
+      return {
+        ...result,
+        results: result.results.map((r) => ({
+          ...r,
+          kind: stripPrefix(ns, r.kind)
+        }))
+      };
+    },
+    async grep(pattern, opts) {
+      const prefixedOpts = opts ? {
+        ...opts,
+        kind: opts.kind !== void 0 ? applyPrefix(ns, opts.kind) : void 0
+      } : void 0;
+      const result = await inner.grep(pattern, prefixedOpts);
+      return {
+        ...result,
+        results: result.results.map((r) => ({
+          ...r,
+          kind: stripPrefix(ns, r.kind)
+        }))
+      };
+    },
+    async getLatest(kind, resource) {
+      let pointer;
+      try {
+        pointer = await inner.getLatest(applyPrefix(ns, kind), resource);
+      } catch (err) {
+        if (err instanceof TilaApiError && err.status === 404) return null;
+        throw err;
+      }
+      if (pointer === null) return null;
+      return { ...pointer, kind: stripPrefix(ns, pointer.kind) };
+    }
+  };
+}
+function namespacedTemplateMethods(client, projectId, ns) {
+  const inner = createTemplateMethods(client, projectId);
   return {
-    /** Get project summary. GET /projects/:id/summary */
-    async get() {
-      return client.get(`/projects/${projectId}/summary`);
+    ...inner,
+    async instantiate(req) {
+      return inner.instantiate({
+        ...req,
+        template_name: applyPrefix(ns, req.template_name)
+      });
+    },
+    async list() {
+      const result = await inner.list();
+      return {
+        ...result,
+        templates: result.templates.map((t) => ({
+          ...t,
+          name: stripPrefix(ns, t.name),
+          type: stripPrefix(ns, t.type)
+        }))
+      };
     }
   };
 }
-
-// src/search.ts
-function createSearchMethods(client, projectId) {
-  const base = `/projects/${projectId}`;
+function createNamespace(client, projectId, ns) {
+  validateNamespace(ns);
   return {
-    async search(q, opts) {
-      const query = { q };
-      if (opts?.limit !== void 0) query.limit = String(opts.limit);
-      return client.get(`${base}/search`, { query });
-    }
+    tasks: namespacedTaskMethods(client, projectId, ns),
+    records: namespacedRecordMethods(client, projectId, ns),
+    artifacts: namespacedArtifactMethods(client, projectId, ns),
+    templates: namespacedTemplateMethods(client, projectId, ns)
   };
 }
 
@@ -2138,5 +2547,867 @@ async function withClaim(client, projectId, resource, mode, ttlMs, callback) {
     }
   }
 }
+var ArtifactPointerInternalSchema = z.object({
+  r2_key: z.string(),
+  resource: z.string().nullable(),
+  kind: z.string(),
+  sha256: z.string(),
+  bytes: z.number(),
+  mime_type: z.string(),
+  produced_at: z.number(),
+  produced_by: z.string(),
+  expires_at: z.number().nullable(),
+  tombstoned: z.number()
+}).passthrough();
+var ArtifactListInternalSchema = z.object({
+  ok: z.literal(true),
+  pointers: z.array(ArtifactPointerInternalSchema)
+});
+var OkSchema = z.object({ ok: z.literal(true) }).passthrough();
+var RecordTypesInternalSchema = z.object({
+  ok: z.literal(true),
+  types: z.array(z.string()),
+  in_use_types: z.array(z.string()).optional()
+});
+var SchemaShowResponseSchema = z.object({
+  ok: z.literal(true),
+  schema: z.record(z.unknown()).nullable(),
+  version: z.number().int().nullable()
+});
+var SchemaApplyLenientSchema = z.object({
+  ok: z.literal(true),
+  version: z.number().int().nullable().optional(),
+  changes: z.array(z.string()).optional(),
+  noChange: z.boolean().optional()
+});
+var StateListInternalSchema = z.object({
+  ok: z.literal(true),
+  claims: z.array(
+    z.object({
+      resource: z.string(),
+      machine: z.string(),
+      user: z.string(),
+      mode: z.enum(["exclusive", "owner", "presence"]),
+      fence: z.number(),
+      acquired_at: z.number(),
+      expires_at: z.number(),
+      metadata: z.record(z.unknown()).optional()
+    })
+  )
+});
+var ArtifactSearchResponseSchema2 = z.object({
+  ok: z.literal(true),
+  results: z.array(
+    z.object({
+      r2_key: z.string(),
+      kind: z.string(),
+      title: z.string().nullable(),
+      snippet: z.string().nullable()
+    }).passthrough()
+  )
+});
+var RelListResponseSchema = z.object({
+  ok: z.literal(true),
+  relationships: z.array(
+    z.object({
+      from_key: z.string(),
+      to_key: z.string().nullable(),
+      to_uri: z.string().nullable(),
+      type: z.string(),
+      created_at: z.number()
+    }).passthrough()
+  )
+});
+var IndexEntriesResponseSchema = z.object({
+  ok: z.literal(true),
+  entries: z.array(
+    z.object({
+      r2_key: z.string(),
+      resource: z.string().nullable(),
+      kind: z.string(),
+      sha256: z.string(),
+      bytes: z.number(),
+      mime_type: z.string(),
+      produced_at: z.number(),
+      produced_by: z.string(),
+      expires_at: z.number().nullable(),
+      tombstoned: z.number(),
+      exists: z.boolean()
+    })
+  )
+});
+var RemoteBackend = class {
+  constructor(client, projectId) {
+    this.client = client;
+    this.projectId = projectId;
+  }
+  client;
+  projectId;
+  // --- EntityBackend ---
+  async create(input) {
+    const body = {
+      id: input.id,
+      type: input.type,
+      data: input.data,
+      created_by: input.created_by
+    };
+    if (input.tags !== void 0) body.tags = input.tags;
+    const result = await this.client.post(
+      `/projects/${this.projectId}/tasks`,
+      body,
+      { schema: EntityResponseSchema, validate: true }
+    );
+    return result.entity;
+  }
+  async get(id) {
+    try {
+      const result = await this.client.get(
+        `/projects/${this.projectId}/tasks/${encodeURIComponent(id)}`,
+        { schema: EntityDetailResponseSchema, validate: true }
+      );
+      return result.entity;
+    } catch (err) {
+      if (err instanceof TilaApiError && err.status === 404) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async list(filter) {
+    const query = {};
+    if (filter?.type) query.type = filter.type;
+    if (filter?.archived !== void 0)
+      query.archived = String(filter.archived);
+    const DATA_FIELD_TO_QUERY_PARAM = {
+      parent_id: "parent"
+    };
+    if (filter?.dataFilter) {
+      for (const [key, value] of Object.entries(filter.dataFilter)) {
+        if (value !== void 0 && value !== null) {
+          const param = DATA_FIELD_TO_QUERY_PARAM[key] ?? key;
+          query[param] = String(value);
+        }
+      }
+    }
+    if (filter?.tagFilter?.length)
+      query.tag_filter = filter.tagFilter.join(",");
+    if (filter?.sort) query.sort = filter.sort;
+    if (filter?.order) query.order = filter.order;
+    if (filter?.limit !== void 0) query.limit = String(filter.limit);
+    if (filter?.offset !== void 0) query.offset = String(filter.offset);
+    const result = await this.client.get(`/projects/${this.projectId}/tasks`, {
+      schema: PaginatedEntityListResponseSchema,
+      validate: true,
+      query
+    });
+    return result.entities;
+  }
+  async update(id, data) {
+    const acquired = await this.acquire(id, "cli", "cli", "exclusive", 3e4);
+    try {
+      const result = await this.client.patch(
+        `/projects/${this.projectId}/tasks/${encodeURIComponent(id)}`,
+        { data, fence: acquired.fence },
+        { schema: EntityResponseSchema, validate: true }
+      );
+      return result.entity;
+    } finally {
+      try {
+        await this.release(id, acquired.fence);
+      } catch {
+      }
+    }
+  }
+  async archive(id) {
+    const acquired = await this.acquire(id, "cli", "cli", "exclusive", 3e4);
+    await this.client.post(
+      `/projects/${this.projectId}/tasks/${encodeURIComponent(id)}/archive`,
+      { fence: acquired.fence },
+      { schema: ArchiveSuccessResponseSchema, validate: true }
+    );
+  }
+  async addRelationship(input) {
+    const result = await this.client.post(
+      `/projects/${this.projectId}/tasks/relationships`,
+      { from_id: input.from_id, to_id: input.to_id, type: input.type },
+      { schema: CreateEntityRelationshipResponseSchema, validate: true }
+    );
+    return { created: result.created ?? true };
+  }
+  async listRelationships(filter) {
+    const query = {};
+    if (filter?.from_id) query.from_id = filter.from_id;
+    if (filter?.to_id) query.to_id = filter.to_id;
+    if (filter?.type) query.type = filter.type;
+    const result = await this.client.get(
+      `/projects/${this.projectId}/tasks/relationships`,
+      { schema: ListEntityRelationshipsResponseSchema, validate: true, query }
+    );
+    return result.relationships;
+  }
+  async removeRelationship(input) {
+    const params = new URLSearchParams({
+      from_id: input.from_id,
+      to_id: input.to_id,
+      type: input.type
+    });
+    const result = await this.client.delete(
+      `/projects/${this.projectId}/tasks/relationships?${params.toString()}`,
+      { schema: DeleteEntityRelationshipResponseSchema, validate: true }
+    );
+    return { removed: result.removed };
+  }
+  // GET /projects/:projectId/tasks/ready (worker entities.ts ~129 -> DO /entity/ready)
+  async listReady(filter) {
+    const query = {};
+    if (filter?.type) query.type = filter.type;
+    if (filter?.parent) query.parent = filter.parent;
+    if (filter?.limit !== void 0) query.limit = String(filter.limit);
+    if (filter?.includeSoftBlocked) query["include-soft-blocked"] = "true";
+    const result = await this.client.get(
+      `/projects/${this.projectId}/tasks/ready`,
+      { schema: ListReadyEntitiesResponseSchema, validate: true, query }
+    );
+    return result.entities.map((e) => ({ ...e, tags: [] }));
+  }
+  // Tree = compact list (GET /tasks?compact=true) + parent-child edges
+  // (GET /tasks/relationships?type=parent-child). The Worker has no dedicated
+  // tree endpoint; these are the two routes the DO/worker already expose.
+  async tree(_rootId) {
+    const listResult = await this.client.get(
+      `/projects/${this.projectId}/tasks`,
+      {
+        schema: PaginatedCompactEntityListResponseSchema,
+        validate: true,
+        query: { compact: "true" }
+      }
+    );
+    const relResult = await this.client.get(
+      `/projects/${this.projectId}/tasks/relationships`,
+      {
+        schema: ListEntityRelationshipsResponseSchema,
+        validate: true,
+        query: { type: "parent-child" }
+      }
+    );
+    return { nodes: listResult.entities, edges: relResult.relationships };
+  }
+  // PATCH /projects/:projectId/tasks/:id with a caller-supplied fence.
+  // Unlike update() (which auto-acquires), the caller owns the fence here, so a
+  // stale fence surfaces the Worker's fence-conflict error verbatim.
+  async updateWithFence(id, data, fence) {
+    const result = await this.client.patch(
+      `/projects/${this.projectId}/tasks/${encodeURIComponent(id)}`,
+      { data, fence },
+      { schema: EntityResponseSchema, validate: true }
+    );
+    return result.entity;
+  }
+  // POST /projects/:projectId/tasks/:entityId/artifact-refs (worker entities.ts ~264)
+  async addArtifactRef(input) {
+    const body = {
+      artifact_key: input.artifact_key,
+      slot: input.slot
+    };
+    if (input.metadata !== void 0) body.metadata = input.metadata;
+    await this.client.post(
+      `/projects/${this.projectId}/tasks/${encodeURIComponent(input.entity_id)}/artifact-refs`,
+      body,
+      { schema: OkSchema, validate: true }
+    );
+  }
+  // GET /projects/:projectId/tasks/:entityId/artifact-refs (worker entities.ts ~340)
+  async listArtifactRefs(entityId) {
+    const result = await this.client.get(
+      `/projects/${this.projectId}/tasks/${encodeURIComponent(entityId)}/artifact-refs`,
+      { schema: EntityArtifactReferenceListResponseSchema, validate: true }
+    );
+    return result.references;
+  }
+  // --- CoordinationBackend ---
+  async acquire(resource, machine, user, mode, ttlMs) {
+    const result = await this.client.post(
+      `/projects/${this.projectId}/claims/acquire`,
+      { resource, mode, ttl_ms: ttlMs },
+      { schema: AcquireSuccessResponseSchema, validate: true }
+    );
+    return {
+      acquired: true,
+      fence: result.fence,
+      expires_at: result.expires_at
+    };
+  }
+  async renew(resource, _machine, _user, fence, ttlMs) {
+    const result = await this.client.post(
+      `/projects/${this.projectId}/claims/renew`,
+      { resource, fence, ttl_ms: ttlMs },
+      { schema: RenewSuccessResponseSchema, validate: true }
+    );
+    return { renewed: true, expires_at: result.expires_at };
+  }
+  async release(resource, fence) {
+    await this.client.post(
+      `/projects/${this.projectId}/claims/release`,
+      { resource, fence },
+      { schema: ReleaseSuccessResponseSchema, validate: true }
+    );
+  }
+  async state(resource) {
+    const result = await this.client.get(
+      `/projects/${this.projectId}/claims/state/${encodeURIComponent(resource)}`,
+      { schema: StateResponseSchema, validate: true }
+    );
+    return result.claim ?? null;
+  }
+  async heartbeat(machine, info) {
+    await this.client.post(
+      `/projects/${this.projectId}/presence/heartbeat`,
+      { machine, info: info ?? {} },
+      { schema: PresenceHeartbeatSuccessResponseSchema, validate: true }
+    );
+  }
+  async listPresence() {
+    const result = await this.client.get(
+      `/projects/${this.projectId}/presence/all`,
+      { schema: PresenceAllListResponseSchema, validate: true }
+    );
+    return result.machines.map(({ machine, last_seen, info }) => ({
+      machine,
+      last_seen,
+      info
+    }));
+  }
+  async listClaims() {
+    const result = await this.client.get(`/projects/${this.projectId}/claims`, {
+      schema: StateListInternalSchema,
+      validate: true
+    });
+    return result.claims.map((c) => ({
+      resource: c.resource,
+      machine: c.machine,
+      user: c.user,
+      mode: c.mode,
+      fence: c.fence,
+      acquired_at: c.acquired_at,
+      expires_at: c.expires_at,
+      metadata: c.metadata ?? {}
+    }));
+  }
+  // --- JournalBackend ---
+  async listJournal(query) {
+    const result = await this.client.get(
+      `/projects/${this.projectId}/journal`,
+      {
+        schema: JournalResponseSchema,
+        validate: true,
+        query: {
+          resource: query.resource,
+          kind: query.kind,
+          limit: query.limit !== void 0 ? String(query.limit) : void 0
+        }
+      }
+    );
+    return result.events.map((ev) => ({
+      seq: ev.seq,
+      t: ev.t,
+      kind: ev.kind,
+      resource: ev.resource,
+      actor: ev.actor,
+      fence: ev.fence
+    }));
+  }
+  // --- GateBackend ---
+  async createGate(resource, awaitType, fence, timeoutAt) {
+    const body = {
+      resource,
+      await_type: awaitType,
+      fence
+    };
+    if (timeoutAt !== void 0) body.timeout_at = timeoutAt;
+    const result = await this.client.post(
+      `/projects/${this.projectId}/gates`,
+      body,
+      { schema: GateResponseSchema, validate: true }
+    );
+    return {
+      id: result.gate.id,
+      resource: result.gate.resource,
+      await_type: result.gate.await_type,
+      status: result.gate.status,
+      fence: result.gate.fence,
+      timeout_at: result.gate.timeout_at,
+      resolved_at: result.gate.resolved_at,
+      resolution: result.gate.resolution,
+      created_at: result.gate.created_at,
+      created_by: result.gate.created_by
+    };
+  }
+  async listGates(filter) {
+    const params = new URLSearchParams();
+    if (filter?.resource) params.set("resource", filter.resource);
+    if (filter?.status) params.set("status", filter.status);
+    const qs = params.toString();
+    const url = `/projects/${this.projectId}/gates${qs ? `?${qs}` : ""}`;
+    const result = await this.client.get(url, {
+      schema: GateListResponseSchema,
+      validate: true
+    });
+    return result.gates.map((g) => ({
+      id: g.id,
+      resource: g.resource,
+      await_type: g.await_type,
+      status: g.status,
+      fence: g.fence,
+      timeout_at: g.timeout_at,
+      resolved_at: g.resolved_at,
+      resolution: g.resolution,
+      created_at: g.created_at,
+      created_by: g.created_by
+    }));
+  }
+  async resolveGate(gateId, resolution) {
+    const body = {};
+    if (resolution) body.resolution = resolution;
+    await this.client.post(
+      `/projects/${this.projectId}/gates/${gateId}/resolve`,
+      body,
+      { schema: OkSchema, validate: true }
+    );
+  }
+  async cancelGate(gateId) {
+    await this.client.delete(`/projects/${this.projectId}/gates/${gateId}`, {
+      schema: OkSchema,
+      validate: true
+    });
+  }
+  // --- SignalBackend ---
+  async sendSignal(input, _createdBy) {
+    const body = {
+      target: input.target,
+      kind: input.kind
+    };
+    if (input.resource) body.resource = input.resource;
+    if (input.payload !== void 0) body.payload = input.payload;
+    if (input.ttl_ms !== void 0) body.ttl_ms = input.ttl_ms;
+    const result = await this.client.post(
+      `/projects/${this.projectId}/signals/send`,
+      body,
+      { schema: SendSignalResponseSchema, validate: true }
+    );
+    return { id: result.id };
+  }
+  async listSignals(_tokenName) {
+    const result = await this.client.get(
+      `/projects/${this.projectId}/signals`,
+      { schema: InboxResponseSchema, validate: true }
+    );
+    return result.signals.map((s) => ({
+      id: s.id,
+      target: s.target,
+      kind: s.kind,
+      resource: s.resource ?? null,
+      payload: s.payload,
+      created_by: s.created_by,
+      created_at: s.created_at,
+      expires_at: s.expires_at,
+      acked_at: s.acked_at
+    }));
+  }
+  async ackSignal(signalId) {
+    await this.client.post(
+      `/projects/${this.projectId}/signals/${signalId}/ack`,
+      {},
+      { schema: AckSignalResponseSchema, validate: true }
+    );
+    return { found: true };
+  }
+  // --- SchemaBackend ---
+  async getCurrentSchema() {
+    const result = await this.client.get(`/projects/${this.projectId}/schema`, {
+      schema: SchemaShowResponseSchema,
+      validate: true
+    });
+    return {
+      version: result.version,
+      definition: result.schema ? JSON.stringify(result.schema) : null
+    };
+  }
+  async applySchema(input) {
+    const body = {
+      definition: input.definition
+    };
+    if (input.strategy) body.strategy = input.strategy;
+    const result = await this.client.post(
+      `/projects/${this.projectId}/schema`,
+      body,
+      { schema: SchemaApplyLenientSchema, validate: true }
+    );
+    return {
+      ok: true,
+      version: result.version ?? null,
+      changes: result.changes ?? [],
+      noChange: result.noChange ?? false
+    };
+  }
+  // --- SummaryBackend ---
+  async getSummary() {
+    const result = await this.client.get(
+      `/projects/${this.projectId}/summary`,
+      { schema: SummaryResponseSchema, validate: true }
+    );
+    return result.project;
+  }
+};
+var RemoteArtifactBackend = class {
+  constructor(client, projectId) {
+    this.client = client;
+    this.projectId = projectId;
+  }
+  client;
+  projectId;
+  // --- ArtifactBackend ---
+  async put(options) {
+    let bodyBlob;
+    if (typeof options.body === "string") {
+      bodyBlob = new Blob([options.body], { type: options.contentType });
+    } else if (options.body instanceof ArrayBuffer) {
+      bodyBlob = new Blob([options.body], { type: options.contentType });
+    } else {
+      const arrayBuf = await new Response(options.body).arrayBuffer();
+      bodyBlob = new Blob([arrayBuf], { type: options.contentType });
+    }
+    const formData = new FormData();
+    formData.append("file", bodyBlob, options.key.split("/").pop() ?? "file");
+    if (options.kind) formData.append("kind", options.kind);
+    if (options.resource) formData.append("resource", options.resource);
+    if (options.fence !== void 0)
+      formData.append("fence", String(options.fence));
+    if (options.flavor) formData.append("flavor", options.flavor);
+    const result = await this.client.postFormData(
+      `/projects/${this.projectId}/artifacts`,
+      formData,
+      { schema: ArtifactPutResponseSchema, validate: true }
+    );
+    return { key: result.key, bytes: result.bytes };
+  }
+  async get(key) {
+    let response;
+    try {
+      response = await this.client.requestRaw(
+        "GET",
+        `/projects/${this.projectId}/artifacts/${encodeURIComponent(key)}`
+      );
+    } catch (err) {
+      if (err instanceof TilaApiError && err.status === 404) {
+        return null;
+      }
+      throw err;
+    }
+    if (response.status === 404) return null;
+    if (!response.ok) {
+      throw new TilaApiError(
+        response.status,
+        "artifact-get-failed",
+        `GET artifact ${key} failed: ${response.statusText}`,
+        false
+      );
+    }
+    return {
+      body: response.body,
+      contentType: response.headers.get("Content-Type") ?? "application/octet-stream",
+      metadata: {}
+    };
+  }
+  async list(prefix) {
+    const result = await this.client.get(
+      `/projects/${this.projectId}/artifacts`,
+      {
+        schema: ArtifactListInternalSchema,
+        validate: true,
+        query: { resource: prefix }
+      }
+    );
+    return result.pointers.map((p) => ({
+      key: p.r2_key,
+      size: p.bytes
+    }));
+  }
+  async delete(key) {
+    await this.client.delete(
+      `/projects/${this.projectId}/artifacts/${encodeURIComponent(key)}`,
+      {
+        schema: OkSchema,
+        validate: true
+      }
+    );
+  }
+  async listPointers(query) {
+    const q = {};
+    if (query.resource) q.resource = query.resource;
+    if (query.kind) q.kind = query.kind;
+    const result = await this.client.get(
+      `/projects/${this.projectId}/artifacts`,
+      {
+        schema: ArtifactListInternalSchema,
+        validate: true,
+        query: q
+      }
+    );
+    return result.pointers;
+  }
+  async addRelationship(fromKey, toKeyOrUri, type) {
+    const body = {
+      from_key: fromKey,
+      type
+    };
+    if (toKeyOrUri.to_key) body.to_key = toKeyOrUri.to_key;
+    if (toKeyOrUri.to_uri) body.to_uri = toKeyOrUri.to_uri;
+    await this.client.post(
+      `/projects/${this.projectId}/artifacts/relationship`,
+      body,
+      { schema: OkSchema, validate: true }
+    );
+  }
+  async listRelationships(key) {
+    const result = await this.client.get(
+      `/projects/${this.projectId}/artifacts/${encodeURIComponent(key)}/relationships`,
+      { schema: RelListResponseSchema, validate: true }
+    );
+    return result.relationships;
+  }
+  async searchArtifacts(query) {
+    const q = {
+      q: query.q
+    };
+    if (query.kind) q.kind = query.kind;
+    if (query.resource) q.resource = query.resource;
+    if (query.limit !== void 0) q.limit = String(query.limit);
+    const result = await this.client.get(
+      `/projects/${this.projectId}/artifacts/search`,
+      { schema: ArtifactSearchResponseSchema2, validate: true, query: q }
+    );
+    return result.results;
+  }
+  async grepArtifacts(query) {
+    const q = { pattern: query.pattern };
+    if (query.kind) q.kind = query.kind;
+    if (query.resource) q.resource = query.resource;
+    if (query.regex) q.regex = "true";
+    if (query.limit != null) q.limit = String(query.limit);
+    const result = await this.client.get(
+      `/projects/${this.projectId}/artifacts/grep`,
+      { schema: ArtifactGrepResponseSchema, validate: true, query: q }
+    );
+    return result;
+  }
+  async listIndexEntries(indexKey) {
+    const result = await this.client.get(
+      `/projects/${this.projectId}/artifacts/index/entries`,
+      {
+        schema: IndexEntriesResponseSchema,
+        validate: true,
+        query: { index_key: indexKey }
+      }
+    );
+    return result.entries;
+  }
+  async getLatest(kind, resource) {
+    let response;
+    try {
+      response = await this.client.requestRaw(
+        "GET",
+        `/projects/${this.projectId}/artifacts/latest`,
+        { query: { kind, resource } }
+      );
+    } catch (err) {
+      if (err instanceof TilaApiError && err.status === 404) {
+        return null;
+      }
+      throw err;
+    }
+    if (response.status === 404) return null;
+    if (!response.ok) {
+      throw new TilaApiError(
+        response.status,
+        "artifact-get-latest-failed",
+        `GET artifact latest failed: ${response.statusText}`,
+        false
+      );
+    }
+    const body = await response.json();
+    return body.pointer;
+  }
+  async writeText(content, opts) {
+    const result = await this.client.post(
+      `/projects/${this.projectId}/artifacts/text`,
+      {
+        content,
+        kind: opts.kind,
+        mime_type: opts.mimeType ?? "text/markdown",
+        resource: opts.resource,
+        fence: opts.fence
+      },
+      { schema: ArtifactPutResponseSchema, validate: true }
+    );
+    return { key: result.key, bytes: result.bytes };
+  }
+  async readText(key) {
+    let response;
+    try {
+      response = await this.client.requestRaw(
+        "GET",
+        `/projects/${this.projectId}/artifacts/${encodeURIComponent(key)}`
+      );
+    } catch (err) {
+      if (err instanceof TilaApiError && err.status === 404) {
+        return null;
+      }
+      throw err;
+    }
+    if (response.status === 404) return null;
+    const contentType = response.headers.get("content-type") || "application/octet-stream";
+    if (!contentType.startsWith("text/")) {
+      throw new TypeError(
+        `Artifact ${key} has MIME type ${contentType} \u2014 readText only supports text/* artifacts`
+      );
+    }
+    const text = await response.text();
+    return { content: text, mimeType: contentType };
+  }
+};
+var RemoteRecordBackend = class {
+  constructor(client, projectId) {
+    this.client = client;
+    this.projectId = projectId;
+  }
+  client;
+  projectId;
+  base() {
+    return `/projects/${this.projectId}/records`;
+  }
+  /** Encode a record key per-segment so embedded `/` separators are preserved. */
+  encodeKey(key) {
+    return key.split("/").map(encodeURIComponent).join("/");
+  }
+  async createRecord(input) {
+    const body = {
+      key: input.key,
+      value: input.value
+    };
+    if (input.tags) body.tags = input.tags;
+    if (input.message != null) body.message = input.message;
+    if (input.sourceArtifactKey != null)
+      body.source_artifact_key = input.sourceArtifactKey;
+    const result = await this.client.post(
+      `${this.base()}/${input.type}`,
+      body,
+      { schema: RecordMutateResponseSchema, validate: true }
+    );
+    return { ...result.record, fence: result.fence };
+  }
+  async setRecord(input) {
+    const body = {
+      value: input.value,
+      fence: input.fence
+    };
+    if (input.tags) body.tags = input.tags;
+    if (input.message != null) body.message = input.message;
+    if (input.sourceArtifactKey != null)
+      body.source_artifact_key = input.sourceArtifactKey;
+    const result = await this.client.put(
+      `${this.base()}/${input.type}/${this.encodeKey(input.key)}`,
+      body,
+      { schema: RecordMutateResponseSchema, validate: true }
+    );
+    return { ...result.record, fence: result.fence };
+  }
+  async getRecord(type, key) {
+    try {
+      const result = await this.client.get(
+        `${this.base()}/${type}/${this.encodeKey(key)}`,
+        { schema: RecordGetResponseSchema, validate: true }
+      );
+      return { ...result.record, fence: result.fence };
+    } catch (err) {
+      if (err instanceof TilaApiError && err.status === 404) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async patchRecord(input) {
+    const body = {
+      patch: input.patch,
+      fence: input.fence
+    };
+    if (input.message != null) body.message = input.message;
+    const result = await this.client.patch(
+      `${this.base()}/${input.type}/${this.encodeKey(input.key)}`,
+      body,
+      { schema: RecordMutateResponseSchema, validate: true }
+    );
+    return { ...result.record, fence: result.fence };
+  }
+  async archiveRecord(input) {
+    const body = { fence: input.fence };
+    if (input.message != null) body.message = input.message;
+    const result = await this.client.post(
+      `${this.base()}/${input.type}/~/archive/${this.encodeKey(input.key)}`,
+      body,
+      { schema: RecordMutateResponseSchema, validate: true }
+    );
+    return { ...result.record, fence: result.fence };
+  }
+  async unarchiveRecord(input) {
+    const body = { fence: input.fence };
+    if (input.message != null) body.message = input.message;
+    const result = await this.client.post(
+      `${this.base()}/${input.type}/~/unarchive/${this.encodeKey(input.key)}`,
+      body,
+      { schema: RecordMutateResponseSchema, validate: true }
+    );
+    return { ...result.record, fence: result.fence };
+  }
+  async listRecords(filter) {
+    const query = {};
+    if (filter.tag) query.tag = filter.tag;
+    if (filter.includeArchived) query["include-archived"] = "true";
+    if (filter.tagFilter?.length) query.tag_filter = filter.tagFilter.join(",");
+    if (filter.dataFilter) query.filter = JSON.stringify(filter.dataFilter);
+    if (filter.limit !== void 0) query.limit = String(filter.limit);
+    const result = await this.client.get(`${this.base()}/${filter.type}`, {
+      schema: RecordListResponseSchema,
+      validate: true,
+      query
+    });
+    return {
+      items: result.items,
+      total: result.meta.total,
+      next_cursor: result.meta.next_cursor
+    };
+  }
+  async listRecordHistory(type, key, opts) {
+    const query = {};
+    if (opts?.limit !== void 0) query.limit = String(opts.limit);
+    if (opts?.includeValues !== void 0)
+      query.values = String(opts.includeValues);
+    const result = await this.client.get(
+      `${this.base()}/${type}/~/history/${this.encodeKey(key)}`,
+      { schema: RecordHistoryResponseSchema, validate: true, query }
+    );
+    return {
+      items: result.items,
+      total: result.meta.total,
+      next_cursor: result.meta.next_cursor
+    };
+  }
+  async listRecordTypesInUse() {
+    const result = await this.client.get(`${this.base()}/_types`, {
+      schema: RecordTypesInternalSchema,
+      validate: true
+    });
+    return result.in_use_types ?? [];
+  }
+};
 
-export { ClaimHandle, TILA_ERRORS, TilaApiError, TilaClient, createArtifactMethods, createClaimMethods, createEntityMethods, createGateMethods, createIndexMethods, createJournalMethods, createPresenceMethods, createRecordMethods, createSchemaMethods, createSearchMethods, createSignalMethods, createSummaryMethods, createTaskMethods, createTemplateMethods, createTokenMethods, createWorkUnitMethods, exchangeGitHubToken, isTilaApiError, withClaim, withRetry };
+export { ClaimHandle, RemoteArtifactBackend, RemoteBackend, RemoteRecordBackend, TILA_ERRORS, TilaApiError, TilaClient, 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 };