@org-quicko/silo-client 1.0.0

package/dist/index.js

@@ -0,0 +1,2053 @@
+// src/pagination/page-window.ts
+class PageWindow {
+  limit;
+  offset;
+  constructor(limit, offset) {
+    this.limit = limit;
+    this.offset = offset;
+  }
+  next() {
+    return new PageWindow(this.limit, this.offset + this.limit);
+  }
+  previous() {
+    if (this.offset <= 0)
+      return null;
+    return new PageWindow(this.limit, Math.max(0, this.offset - this.limit));
+  }
+}
+
+// src/transport/api-path.ts
+class ApiPath {
+  static health() {
+    return "/api/health";
+  }
+  static projects() {
+    return "/api/projects";
+  }
+  static project(project) {
+    return `/api/projects/${encodeURIComponent(project)}`;
+  }
+  static environments(project) {
+    return `${ApiPath.project(project)}/envs`;
+  }
+  static environment(project, env) {
+    return `${ApiPath.environments(project)}/${encodeURIComponent(env)}`;
+  }
+  static projectVariables(project) {
+    return `${ApiPath.project(project)}/variables`;
+  }
+  static projectVariable(project, name) {
+    return `${ApiPath.projectVariables(project)}/${encodeURIComponent(name)}`;
+  }
+  static environmentVariables(project, env) {
+    return `${ApiPath.environment(project, env)}/variables`;
+  }
+  static environmentVariable(project, env, name) {
+    return `${ApiPath.environmentVariables(project, env)}/${encodeURIComponent(name)}`;
+  }
+  static collections(project, env) {
+    return `${ApiPath.environment(project, env)}/collections`;
+  }
+  static collection(project, env, name) {
+    return `${ApiPath.collections(project, env)}/${encodeURIComponent(name)}`;
+  }
+  static schemas(project, env) {
+    return `${ApiPath.environment(project, env)}/schemas`;
+  }
+  static collectionSchema(project, env, name) {
+    return `${ApiPath.collection(project, env, name)}/schema`;
+  }
+  static entries(project, env, name) {
+    return ApiPath.collection(project, env, name);
+  }
+  static entry(project, env, name, id) {
+    return `${ApiPath.collection(project, env, name)}/${encodeURIComponent(id)}`;
+  }
+  static collectionSearch(project, env, name) {
+    return `${ApiPath.collection(project, env, name)}/search`;
+  }
+  static environmentSearch(project, env) {
+    return `${ApiPath.environment(project, env)}/search`;
+  }
+  static instanceSearch() {
+    return "/api/search";
+  }
+  static media() {
+    return "/api/media";
+  }
+  static mediaExtensions() {
+    return "/api/media/extensions";
+  }
+  static mediaAsset(id) {
+    return `/api/media/${encodeURIComponent(id)}`;
+  }
+  static mediaAssetUsages(id) {
+    return `${ApiPath.mediaAsset(id)}/usages`;
+  }
+  static mediaBulkDelete() {
+    return "/api/media/delete";
+  }
+  static mediaFolders() {
+    return "/api/media/folders";
+  }
+}
+
+// src/media/media-asset-mapper.ts
+class MediaAssetMapper {
+  static toRecord(payload) {
+    return {
+      id: payload.id,
+      filename: payload.filename,
+      folder: payload.folder,
+      blobKey: payload.blob_key,
+      sizeInBytes: payload.size,
+      contentType: payload.content_type,
+      hash: payload.hash,
+      state: payload.state,
+      tags: payload.tags,
+      url: payload.url,
+      usageCount: payload.usage_count ?? 0,
+      createdAt: new Date(payload.created_at),
+      updatedAt: new Date(payload.updated_at)
+    };
+  }
+  static toUsage(payload) {
+    return {
+      mediaId: typeof payload.media_id === "string" ? payload.media_id : "",
+      project: typeof payload.project === "string" ? payload.project : "",
+      environment: typeof payload.env === "string" ? payload.env : "",
+      collection: typeof payload.collection === "string" ? payload.collection : "",
+      entryId: typeof payload.entry_id === "string" ? payload.entry_id : ""
+    };
+  }
+  static toUsagePage(body) {
+    return {
+      items: body.items.map((item) => MediaAssetMapper.toUsage(item)),
+      total: body.total,
+      visible: body.visible,
+      visibleCapped: body.visible_capped
+    };
+  }
+}
+
+// src/media/media-reference.ts
+class MediaReference {
+  static Scheme = "silo://media/";
+  static of(id) {
+    return MediaReference.Scheme + id;
+  }
+  static idOf(value) {
+    if (typeof value !== "string" || !value.startsWith(MediaReference.Scheme))
+      return null;
+    const id = value.slice(MediaReference.Scheme.length).split(/[#?/]/)[0];
+    return id ? id : null;
+  }
+}
+
+// src/pagination/page.ts
+class Page {
+  rows;
+  window;
+  total;
+  truncated;
+  constructor(rows, total, window, truncated = false) {
+    this.rows = rows;
+    this.total = total;
+    this.window = window;
+    this.truncated = truncated;
+  }
+  get limit() {
+    return this.window.limit;
+  }
+  get offset() {
+    return this.window.offset;
+  }
+  get pageNumber() {
+    return Math.floor(this.offset / this.limit) + 1;
+  }
+  get pageCount() {
+    if (this.truncated)
+      return null;
+    return Math.max(1, Math.ceil(this.total / this.limit));
+  }
+  get hasMore() {
+    if (this.truncated)
+      return this.rows.length === this.limit;
+    return this.offset + this.rows.length < this.total;
+  }
+  windowForNext() {
+    return this.hasMore ? this.window.next() : null;
+  }
+  [Symbol.iterator]() {
+    return this.rows[Symbol.iterator]();
+  }
+}
+
+// src/media/media-usage-page.ts
+var DefaultUsageLimit = 50;
+
+class MediaUsagePage extends Page {
+  transport;
+  assetId;
+  visible;
+  visibleCapped;
+  constructor(rows, total, visible, visibleCapped, window, transport, assetId) {
+    super(rows, total, window);
+    this.transport = transport;
+    this.assetId = assetId;
+    this.visible = visible;
+    this.visibleCapped = visibleCapped;
+  }
+  get usages() {
+    return this.rows;
+  }
+  get pageCount() {
+    return Math.max(1, Math.ceil(this.visible / this.limit));
+  }
+  get hasMore() {
+    return this.offset + this.rows.length < this.visible;
+  }
+  async next(options) {
+    const window = this.windowForNext();
+    return window ? MediaUsagePage.loadWindow(this.transport, this.assetId, window, options) : null;
+  }
+  async previous(options) {
+    const window = this.window.previous();
+    return window ? MediaUsagePage.loadWindow(this.transport, this.assetId, window, options) : null;
+  }
+  static load(transport, assetId, query, options) {
+    const window = new PageWindow(query.limit ?? DefaultUsageLimit, query.offset ?? 0);
+    return MediaUsagePage.loadWindow(transport, assetId, window, options);
+  }
+  static async loadWindow(transport, assetId, window, options) {
+    const body = await transport.json({
+      method: "GET",
+      path: ApiPath.mediaAssetUsages(assetId),
+      query: { limit: window.limit, offset: window.offset },
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+    const mapped = MediaAssetMapper.toUsagePage(body);
+    return new MediaUsagePage(mapped.items, mapped.total, mapped.visible, mapped.visibleCapped, window, transport, assetId);
+  }
+}
+
+// src/media/media-asset.ts
+class MediaAsset {
+  transport;
+  record;
+  constructor(transport, record) {
+    this.transport = transport;
+    this.record = record;
+  }
+  get id() {
+    return this.record.id;
+  }
+  get filename() {
+    return this.record.filename;
+  }
+  get folder() {
+    return this.record.folder;
+  }
+  get sizeInBytes() {
+    return this.record.sizeInBytes;
+  }
+  get contentType() {
+    return this.record.contentType;
+  }
+  get hash() {
+    return this.record.hash;
+  }
+  get state() {
+    return this.record.state;
+  }
+  get tags() {
+    return this.record.tags;
+  }
+  get url() {
+    return this.record.url;
+  }
+  get usageCount() {
+    return this.record.usageCount;
+  }
+  get createdAt() {
+    return this.record.createdAt;
+  }
+  get updatedAt() {
+    return this.record.updatedAt;
+  }
+  get blobKey() {
+    return this.record.blobKey;
+  }
+  get reference() {
+    return MediaReference.of(this.id);
+  }
+  async rename(filename, options) {
+    return this.patch({ filename }, options);
+  }
+  async moveTo(folder, options) {
+    return this.patch({ folder }, options);
+  }
+  async setTags(tags, options) {
+    return this.patch({ tags: [...tags] }, options);
+  }
+  async delete(options) {
+    await this.transport.empty({
+      method: "DELETE",
+      path: ApiPath.mediaAsset(this.id),
+      query: options?.force ? { force: true } : undefined,
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+  }
+  usages(query = {}, options) {
+    return MediaUsagePage.load(this.transport, this.id, query, options);
+  }
+  async refresh(options) {
+    const payload = await this.transport.json({
+      method: "GET",
+      path: ApiPath.mediaAsset(this.id),
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+    this.record = MediaAssetMapper.toRecord(payload);
+    return this;
+  }
+  toJSON() {
+    return { ...this.record };
+  }
+  async patch(body, options) {
+    const payload = await this.transport.json({
+      method: "PATCH",
+      path: ApiPath.mediaAsset(this.id),
+      body,
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+    this.record = MediaAssetMapper.toRecord(payload);
+    return this;
+  }
+}
+
+// src/media/media-delete-report.ts
+class MediaDeleteReport {
+  deleted;
+  failed;
+  constructor(deleted, failed) {
+    this.deleted = deleted;
+    this.failed = failed;
+  }
+  static fromWireBody(body) {
+    return new MediaDeleteReport(body.deleted, body.failed.map(MediaDeleteReport.toFailure));
+  }
+  static toFailure(entry) {
+    const failure = {
+      id: String(entry.id),
+      code: String(entry.code),
+      message: String(entry.message)
+    };
+    if (typeof entry.usage_count === "number")
+      failure.usageCount = entry.usage_count;
+    if (typeof entry.visible_count === "number")
+      failure.visibleCount = entry.visible_count;
+    if (typeof entry.visible_capped === "boolean")
+      failure.visibleCapped = entry.visible_capped;
+    if (Array.isArray(entry.referrers)) {
+      failure.referrers = entry.referrers.map((usage) => MediaAssetMapper.toUsage(usage));
+    }
+    return failure;
+  }
+}
+
+// src/media/media-folders.ts
+class MediaFolders {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(options) {
+    const body = await this.transport.json({
+      method: "GET",
+      path: ApiPath.mediaFolders(),
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+    return body.items;
+  }
+  async create(path, options) {
+    const body = await this.transport.json({
+      method: "POST",
+      path: ApiPath.mediaFolders(),
+      body: { path },
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+    return body.path;
+  }
+  rename(from, to, options) {
+    return this.transport.json({
+      method: "PATCH",
+      path: ApiPath.mediaFolders(),
+      body: { from, to, merge: options?.merge === true },
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+  }
+  async delete(path, options) {
+    await this.transport.empty({
+      method: "DELETE",
+      path: ApiPath.mediaFolders(),
+      query: {
+        path,
+        ...options?.recursive ? { recursive: true } : {},
+        ...options?.force ? { force: true } : {}
+      },
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+  }
+}
+
+// src/media/media-page.ts
+class MediaPage extends Page {
+  transport;
+  wireQuery;
+  constructor(rows, total, window, transport, wireQuery) {
+    super(rows, total, window);
+    this.transport = transport;
+    this.wireQuery = wireQuery;
+  }
+  get files() {
+    return this.rows;
+  }
+  async next(options) {
+    const window = this.windowForNext();
+    return window ? MediaPage.loadWindow(this.transport, this.wireQuery, window, options) : null;
+  }
+  async previous(options) {
+    const window = this.window.previous();
+    return window ? MediaPage.loadWindow(this.transport, this.wireQuery, window, options) : null;
+  }
+  static async loadWindow(transport, wireQuery, window, options) {
+    const body = await transport.json({
+      method: "GET",
+      path: ApiPath.media(),
+      query: { ...wireQuery, limit: window.limit, offset: window.offset },
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+    const rows = body.items.map((payload) => new MediaAsset(transport, MediaAssetMapper.toRecord(payload)));
+    return new MediaPage(rows, body.total, new PageWindow(body.limit, body.offset), transport, wireQuery);
+  }
+}
+
+// src/errors/request-aborted-error.ts
+class RequestAbortedError extends Error {
+  method;
+  path;
+  constructor(method, path) {
+    super(`${method} ${path} was aborted by the caller`);
+    this.name = "RequestAbortedError";
+    this.method = method;
+    this.path = path;
+    Object.setPrototypeOf(this, RequestAbortedError.prototype);
+  }
+}
+
+// src/media/media-page-stream.ts
+class MediaPageStream {
+  first;
+  options;
+  constructor(first, options = {}) {
+    this.first = first;
+    this.options = options;
+  }
+  async* [Symbol.asyncIterator]() {
+    let page = await this.first();
+    while (page) {
+      if (this.options.signal?.aborted) {
+        throw new RequestAbortedError("GET", "stream");
+      }
+      yield page;
+      page = page.hasMore ? await page.next(this.options) : null;
+    }
+  }
+}
+
+// src/pagination/row-stream.ts
+class RowStream {
+  loader;
+  startingLimit;
+  options;
+  constructor(loader, startingLimit, options = {}) {
+    this.loader = loader;
+    this.startingLimit = startingLimit;
+    this.options = options;
+  }
+  async* [Symbol.asyncIterator]() {
+    let window = new PageWindow(this.startingLimit, 0);
+    while (window) {
+      if (this.options.signal?.aborted) {
+        throw new RequestAbortedError("GET", "stream");
+      }
+      const page = await this.loader(window);
+      yield* page.rows;
+      const short = page.rows.length === 0 || page.rows.length < page.window.limit;
+      window = short ? null : page.window.next();
+    }
+  }
+  async toArray() {
+    const rows = [];
+    for await (const row of this)
+      rows.push(row);
+    return rows;
+  }
+}
+
+// src/media/media-stream.ts
+class MediaStream extends RowStream {
+}
+
+// src/media/media.ts
+var BulkDeleteCap = 100;
+
+class Media {
+  transport;
+  folders;
+  constructor(transport) {
+    this.transport = transport;
+    this.folders = new MediaFolders(transport);
+  }
+  async upload(input, second, third) {
+    const form = new FormData;
+    let folder;
+    let options;
+    if (input instanceof Blob) {
+      const fileOptions = second ?? {};
+      form.set("file", input, Media.filenameOf(input, fileOptions.filename));
+      folder = fileOptions.folder;
+      options = third ?? fileOptions;
+    } else {
+      form.set("file", Media.toBlob(input.bytes, input.contentType), input.filename);
+      folder = input.folder;
+      options = second;
+    }
+    if (folder)
+      form.set("folder", folder);
+    const payload = await this.transport.upload({ method: "POST", path: ApiPath.media(), signal: options?.signal, timeoutMilliseconds: options?.timeoutMilliseconds }, form);
+    return new MediaAsset(this.transport, MediaAssetMapper.toRecord(payload));
+  }
+  list(query = {}, options) {
+    const window = new PageWindow(query.limit ?? 50, query.offset ?? 0);
+    return MediaPage.loadWindow(this.transport, Media.toWireQuery(query), window, options);
+  }
+  all(query = {}, options) {
+    const wireQuery = Media.toWireQuery(query);
+    const loader = async (window) => {
+      const page = await MediaPage.loadWindow(this.transport, wireQuery, window, options);
+      return { rows: [...page], window: new PageWindow(page.limit, page.offset) };
+    };
+    return new MediaStream(loader, query.limit ?? 50, options);
+  }
+  pages(query = {}, options) {
+    return new MediaPageStream(() => this.list(query, options), options);
+  }
+  async get(id, options) {
+    const payload = await this.transport.json({
+      method: "GET",
+      path: ApiPath.mediaAsset(id),
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+    return new MediaAsset(this.transport, MediaAssetMapper.toRecord(payload));
+  }
+  async extensions(options) {
+    const body = await this.transport.json({
+      method: "GET",
+      path: ApiPath.mediaExtensions(),
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+    return body.items;
+  }
+  async deleteMany(ids, options) {
+    if (ids.length > BulkDeleteCap) {
+      throw new Error(`deleteMany accepts at most ${BulkDeleteCap} ids per request, got ${ids.length}`);
+    }
+    const body = await this.transport.json({
+      method: "POST",
+      path: ApiPath.mediaBulkDelete(),
+      body: { ids: [...ids], force: options?.force === true },
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+    return MediaDeleteReport.fromWireBody(body);
+  }
+  static toWireQuery(query) {
+    return {
+      q: query.text,
+      folder: query.folder,
+      recursive: query.recursive,
+      type: query.type,
+      ext: query.extension,
+      tag: query.tag,
+      modified_after: query.modifiedAfter,
+      modified_before: query.modifiedBefore,
+      sort: query.sort
+    };
+  }
+  static toBlob(bytes, contentType) {
+    if (bytes instanceof Blob)
+      return bytes;
+    return new Blob([bytes], contentType ? { type: contentType } : undefined);
+  }
+  static filenameOf(input, explicit) {
+    if (explicit)
+      return explicit;
+    if (input instanceof File && input.name)
+      return input.name;
+    throw new Error("media upload: a Blob has no filename — pass { filename } explicitly");
+  }
+}
+
+// src/variables/variable.ts
+class Variable {
+  name;
+  description;
+  value;
+  setIn;
+  createdAt;
+  updatedAt;
+  constructor(name, description, value, setIn, createdAt, updatedAt) {
+    this.name = name;
+    this.description = description;
+    this.value = value;
+    this.setIn = setIn;
+    this.createdAt = createdAt;
+    this.updatedAt = updatedAt;
+  }
+  static fromWire(payload) {
+    return new Variable(payload.name, payload.description, payload.value, payload.set_in, new Date(payload.created_at), new Date(payload.updated_at));
+  }
+}
+
+// src/variables/project-variables.ts
+class ProjectVariables {
+  transport;
+  project;
+  constructor(transport, project) {
+    this.transport = transport;
+    this.project = project;
+  }
+  async declare(name, options = {}) {
+    const payload = await this.transport.json({
+      method: "POST",
+      path: ApiPath.projectVariables(this.project),
+      query: { env: options.environment },
+      body: { name, description: options.description, value: options.value },
+      signal: options.signal,
+      timeoutMilliseconds: options.timeoutMilliseconds
+    });
+    return Variable.fromWire(payload);
+  }
+  async rename(name, to, options = {}) {
+    return this.updateDeclaration(name, { name: to }, options);
+  }
+  async describe(name, description, options = {}) {
+    return this.updateDeclaration(name, { description }, options);
+  }
+  async undeclare(name, options = {}) {
+    await this.transport.empty({
+      method: "DELETE",
+      path: ApiPath.projectVariable(this.project, name),
+      query: { env: options.environment },
+      signal: options.signal,
+      timeoutMilliseconds: options.timeoutMilliseconds
+    });
+  }
+  async updateDeclaration(name, body, options) {
+    const payload = await this.transport.json({
+      method: "PATCH",
+      path: ApiPath.projectVariable(this.project, name),
+      query: { env: options.environment },
+      body,
+      signal: options.signal,
+      timeoutMilliseconds: options.timeoutMilliseconds
+    });
+    return Variable.fromWire(payload);
+  }
+}
+
+// src/entries/entry-mapper.ts
+class EntryMapper {
+  static fieldsOf(payload) {
+    const { id: _id, rev: _rev, created_at: _createdAt, updated_at: _updatedAt, ...fields } = payload;
+    return fields;
+  }
+  static toPayload(id, rev, fields, createdAt, updatedAt) {
+    return {
+      id,
+      rev,
+      ...fields,
+      created_at: createdAt.toISOString(),
+      updated_at: updatedAt.toISOString()
+    };
+  }
+}
+
+// src/entries/entry-base.ts
+class EntryBase {
+  context;
+  id;
+  rev;
+  createdAt;
+  updatedAt;
+  fields;
+  constructor(context, payload) {
+    this.context = context;
+    this.id = String(payload.id);
+    this.rev = Number(payload.rev);
+    this.createdAt = new Date(payload.created_at);
+    this.updatedAt = new Date(payload.updated_at);
+    this.fields = EntryMapper.fieldsOf(payload);
+  }
+  toJSON() {
+    return EntryMapper.toPayload(this.id, this.rev, this.fields, this.createdAt, this.updatedAt);
+  }
+  async delete(options = {}) {
+    await this.context.transport.empty({
+      method: "DELETE",
+      path: ApiPath.entry(this.context.project, this.context.environment, this.context.collection, this.id),
+      query: { rev: this.rev },
+      ...options
+    });
+  }
+}
+
+// src/entries/resolved-entry.ts
+class ResolvedEntry extends EntryBase {
+}
+
+// src/entries/entry.ts
+class Entry extends ResolvedEntry {
+  saving = false;
+  async save(options = {}) {
+    if (this.saving) {
+      throw new Error(`cannot save entry "${this.id}": a previous save() on this instance has not finished yet`);
+    }
+    this.saving = true;
+    try {
+      const payload = await this.context.transport.json({
+        method: "PUT",
+        path: ApiPath.entry(this.context.project, this.context.environment, this.context.collection, this.id),
+        query: { rev: this.rev, variables: "raw" },
+        body: this.fields,
+        ...options
+      });
+      this.adopt(payload);
+      return this;
+    } finally {
+      this.saving = false;
+    }
+  }
+  async refresh(options = {}) {
+    const payload = await this.context.transport.json({
+      method: "GET",
+      path: ApiPath.entry(this.context.project, this.context.environment, this.context.collection, this.id),
+      query: { variables: "raw" },
+      ...options
+    });
+    this.adopt(payload);
+    return this;
+  }
+  adopt(payload) {
+    this.rev = Number(payload.rev);
+    this.createdAt = new Date(payload.created_at);
+    this.updatedAt = new Date(payload.updated_at);
+    this.fields = EntryMapper.fieldsOf(payload);
+  }
+}
+
+// src/transport/page-payload.ts
+class PagePayload {
+  static read(body) {
+    const rows = Array.isArray(body.data) ? body.data : Array.isArray(body.items) ? body.items : [];
+    return {
+      rows,
+      total: typeof body.total === "number" ? body.total : rows.length,
+      limit: typeof body.limit === "number" ? body.limit : undefined,
+      offset: typeof body.offset === "number" ? body.offset : undefined
+    };
+  }
+}
+
+// src/entries/entry-page.ts
+class EntryPage extends Page {
+  loader;
+  constructor(rows, total, window, loader) {
+    super(rows, total, window);
+    this.loader = loader;
+  }
+  get entries() {
+    return this.rows;
+  }
+  next() {
+    const window = this.windowForNext();
+    return window ? this.loader(window) : Promise.resolve(null);
+  }
+  previous() {
+    const window = this.window.previous();
+    return window ? this.loader(window) : Promise.resolve(null);
+  }
+}
+
+// src/entries/entry-page-stream.ts
+class EntryPageStream {
+  loadFirst;
+  options;
+  constructor(loadFirst, options = {}) {
+    this.loadFirst = loadFirst;
+    this.options = options;
+  }
+  async* [Symbol.asyncIterator]() {
+    let page = await this.loadFirst();
+    while (page) {
+      if (this.options.signal?.aborted) {
+        throw new RequestAbortedError("GET", "stream");
+      }
+      yield page;
+      const short = page.entries.length === 0 || page.entries.length < page.limit;
+      page = short ? null : await page.next();
+    }
+  }
+}
+
+// src/entries/entry-stream.ts
+class EntryStream extends RowStream {
+}
+
+// src/entries/entry-reader.ts
+class EntryReader {
+  context;
+  variables;
+  wrap;
+  constructor(context, variables, wrap) {
+    this.context = context;
+    this.variables = variables;
+    this.wrap = wrap;
+  }
+  async get(id, options = {}) {
+    const payload = await this.context.transport.json({
+      method: "GET",
+      path: ApiPath.entry(this.context.project, this.context.environment, this.context.collection, id),
+      query: { variables: this.variables },
+      ...options
+    });
+    return this.wrap(payload);
+  }
+  async list(query = {}, options = {}) {
+    const loader = (window2) => this.list({ ...query, limit: window2.limit, offset: window2.offset }, options);
+    const body = await this.context.transport.json({
+      method: "GET",
+      path: ApiPath.entries(this.context.project, this.context.environment, this.context.collection),
+      query: {
+        limit: query.limit,
+        offset: query.offset,
+        filter: query.where?.toJSON(),
+        sort: query.sort === undefined ? undefined : String(query.sort),
+        variables: this.variables
+      },
+      ...options
+    });
+    const page = PagePayload.read(body);
+    const window = new PageWindow(page.limit ?? query.limit ?? 50, page.offset ?? query.offset ?? 0);
+    return new EntryPage(page.rows.map((payload) => this.wrap(payload)), page.total, window, loader);
+  }
+  all(query = {}, options = {}) {
+    const loader = async (window) => {
+      const page = await this.list({ ...query, limit: window.limit, offset: window.offset }, options);
+      return { rows: [...page.entries], window: new PageWindow(page.limit, page.offset) };
+    };
+    return new EntryStream(loader, query.limit ?? 50, options);
+  }
+  pages(query = {}, options = {}) {
+    return new EntryPageStream(() => this.list(query, options), options);
+  }
+}
+
+// src/query/field-path.ts
+class FieldPath {
+  static field(name) {
+    return `$.data.${name}`;
+  }
+  static each(name) {
+    return `$.data.${name}[*]`;
+  }
+  static meta(name) {
+    return `$.${name}`;
+  }
+}
+
+// src/query/filter-expression.ts
+class FilterExpression {
+  node;
+  constructor(node) {
+    this.node = node;
+  }
+  and(other) {
+    return new FilterExpression({ op: "and", args: [this.node, other.node] });
+  }
+  or(other) {
+    return new FilterExpression({ op: "or", args: [this.node, other.node] });
+  }
+  not() {
+    return new FilterExpression({ op: "not", args: [this.node] });
+  }
+  toJSON() {
+    return this.node;
+  }
+}
+
+// src/query/filter-field.ts
+class FilterField {
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+  equals(value) {
+    return new FilterExpression({ op: "eq", path: this.path, value });
+  }
+  notEquals(value) {
+    return new FilterExpression({ op: "neq", path: this.path, value });
+  }
+  contains(value) {
+    return new FilterExpression({ op: "contains", path: this.path, value });
+  }
+  greaterThan(value) {
+    return new FilterExpression({ op: "gt", path: this.path, value });
+  }
+  atLeast(value) {
+    return new FilterExpression({ op: "gte", path: this.path, value });
+  }
+  lessThan(value) {
+    return new FilterExpression({ op: "lt", path: this.path, value });
+  }
+  atMost(value) {
+    return new FilterExpression({ op: "lte", path: this.path, value });
+  }
+  oneOf(values) {
+    return new FilterExpression({ op: "in", path: this.path, value: values });
+  }
+  exists() {
+    return new FilterExpression({ op: "exists", path: this.path });
+  }
+}
+
+// src/query/typed-filter.ts
+class TypedFilter {
+  field(name) {
+    return new FilterField(FieldPath.field(name));
+  }
+  each(name) {
+    return new FilterField(FieldPath.each(name));
+  }
+  meta(name) {
+    return new FilterField(FieldPath.meta(name));
+  }
+  and(left, right) {
+    return left.and(right);
+  }
+  or(left, right) {
+    return left.or(right);
+  }
+  not(expression) {
+    return expression.not();
+  }
+  raw(node) {
+    return new FilterExpression(node);
+  }
+}
+
+// src/scope/rename-report.ts
+class RenameReport {
+  id;
+  from;
+  to;
+  rewrittenClaims;
+  patternAffectedClaims;
+  constructor(id, from, to, rewrittenClaims, patternAffectedClaims) {
+    this.id = id;
+    this.from = from;
+    this.to = to;
+    this.rewrittenClaims = rewrittenClaims;
+    this.patternAffectedClaims = patternAffectedClaims;
+  }
+  static fromWire(payload) {
+    return new RenameReport(payload.id, payload.from, payload.to, payload.rewritten_claims, payload.pattern_affected_claims);
+  }
+}
+
+// src/search/search-page.ts
+class SearchPage extends Page {
+  loader;
+  engine;
+  constructor(rows, total, window, truncated, engine, loader) {
+    super(rows, total, window, truncated);
+    this.loader = loader;
+    this.engine = engine;
+  }
+  get hits() {
+    return this.rows;
+  }
+  next() {
+    const window = this.windowForNext();
+    return window ? this.loader(window) : Promise.resolve(null);
+  }
+  previous() {
+    const window = this.window.previous();
+    return window ? this.loader(window) : Promise.resolve(null);
+  }
+}
+
+// src/search/search.ts
+class Search {
+  transport;
+  reach;
+  constructor(transport, reach) {
+    this.transport = transport;
+    this.reach = reach;
+  }
+  async run(query, options = {}) {
+    const loader = (window2) => this.run({ ...query, limit: window2.limit, offset: window2.offset }, options);
+    const body = await this.transport.json({
+      method: "GET",
+      path: this.reach.path,
+      query: {
+        q: query.query,
+        filter: query.where?.toJSON(),
+        sort: query.sort === undefined ? undefined : String(query.sort),
+        limit: query.limit,
+        offset: query.offset
+      },
+      ...options
+    });
+    const page = PagePayload.read(body);
+    const window = new PageWindow(page.limit ?? query.limit ?? 50, page.offset ?? query.offset ?? 0);
+    const truncated = body.truncated === true;
+    const engine = body.engine;
+    const hits = page.rows.map((hit) => this.toHit(hit));
+    return new SearchPage(hits, page.total, window, truncated, engine, loader);
+  }
+  toHit(payload) {
+    return {
+      project: payload.project,
+      environment: payload.env,
+      collection: payload.collection,
+      entry: new ResolvedEntry({ transport: this.transport, project: payload.project, environment: payload.env, collection: payload.collection }, payload.entry),
+      snippets: payload.snippets
+    };
+  }
+}
+
+// src/search/search-reach.ts
+class SearchReach {
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+  static collection(project, environment, name) {
+    return new SearchReach(ApiPath.collectionSearch(project, environment, name));
+  }
+  static environment(project, environment) {
+    return new SearchReach(ApiPath.environmentSearch(project, environment));
+  }
+  static instance() {
+    return new SearchReach(ApiPath.instanceSearch());
+  }
+}
+
+// src/collections/collection-schema.ts
+class CollectionSchema {
+  scope;
+  name;
+  constructor(scope, name) {
+    this.scope = scope;
+    this.name = name;
+  }
+  async get(options = {}) {
+    return this.scope.transport.json({
+      method: "GET",
+      path: ApiPath.collectionSchema(this.scope.project, this.scope.environment, this.name),
+      ...options
+    });
+  }
+  async put(schema, options = {}) {
+    return this.scope.transport.json({
+      method: "PUT",
+      path: ApiPath.collectionSchema(this.scope.project, this.scope.environment, this.name),
+      body: schema,
+      ...options
+    });
+  }
+  async delete(options = {}) {
+    await this.scope.transport.empty({
+      method: "DELETE",
+      path: ApiPath.collectionSchema(this.scope.project, this.scope.environment, this.name),
+      query: { force: options.force || undefined },
+      signal: options.signal,
+      timeoutMilliseconds: options.timeoutMilliseconds
+    });
+  }
+}
+
+// src/collections/collection-handle.ts
+class CollectionHandle {
+  scope;
+  name;
+  filter = new TypedFilter;
+  schema;
+  editable;
+  context;
+  resolved;
+  constructor(scope, name) {
+    this.scope = scope;
+    this.name = name;
+    this.schema = new CollectionSchema(scope, name);
+    this.context = {
+      transport: scope.transport,
+      project: scope.project,
+      environment: scope.environment,
+      collection: name
+    };
+    this.resolved = new EntryReader(this.context, undefined, (payload) => new ResolvedEntry(this.context, payload));
+    this.editable = new EntryReader(this.context, "raw", (payload) => new Entry(this.context, payload));
+  }
+  get(id, options = {}) {
+    return this.resolved.get(id, options);
+  }
+  edit(id, options = {}) {
+    return this.editable.get(id, options);
+  }
+  list(query = {}, options = {}) {
+    return this.resolved.list(query, options);
+  }
+  all(query = {}, options = {}) {
+    return this.resolved.all(query, options);
+  }
+  pages(query = {}, options = {}) {
+    return this.resolved.pages(query, options);
+  }
+  create(fields, options = {}) {
+    return this.write("POST", ApiPath.entries(this.scope.project, this.scope.environment, this.name), fields, undefined, options);
+  }
+  replace(id, rev, fields, options = {}) {
+    return this.write("PUT", ApiPath.entry(this.scope.project, this.scope.environment, this.name, id), fields, rev, options);
+  }
+  async delete(id, rev, options = {}) {
+    await this.scope.transport.empty({
+      method: "DELETE",
+      path: ApiPath.entry(this.scope.project, this.scope.environment, this.name, id),
+      query: { rev },
+      ...options
+    });
+  }
+  search(query, options = {}) {
+    return new Search(this.scope.transport, SearchReach.collection(this.scope.project, this.scope.environment, this.name)).run(query, options);
+  }
+  async rename(name, options = {}) {
+    const payload = await this.scope.transport.json({
+      method: "PATCH",
+      path: ApiPath.collection(this.scope.project, this.scope.environment, this.name),
+      query: { dry_run: options.dryRun || undefined, expected_id: options.expectedId },
+      body: { name },
+      signal: options.signal,
+      timeoutMilliseconds: options.timeoutMilliseconds
+    });
+    return RenameReport.fromWire(payload);
+  }
+  async write(method, path, fields, rev, options) {
+    const payload = await this.scope.transport.json({
+      method,
+      path,
+      query: { rev, variables: "raw" },
+      body: fields,
+      ...options
+    });
+    return new Entry(this.context, payload);
+  }
+}
+
+// src/collections/reserved-field-names.ts
+class ReservedFieldNames {
+  static all = ["id", "rev", "seq", "created_at", "updated_at"];
+  static isReserved(name) {
+    return ReservedFieldNames.all.includes(name);
+  }
+}
+
+// src/collections/collections.ts
+class Collections {
+  scope;
+  constructor(scope) {
+    this.scope = scope;
+  }
+  async list(options = {}) {
+    const body = await this.scope.transport.json({
+      method: "GET",
+      path: ApiPath.collections(this.scope.project, this.scope.environment),
+      ...options
+    });
+    return body.items.map(Collections.toSummary);
+  }
+  async create(name, schema, options = {}) {
+    Collections.warnOnReservedFields(schema);
+    return this.scope.transport.json({
+      method: "POST",
+      path: ApiPath.collections(this.scope.project, this.scope.environment),
+      body: { name, schema },
+      ...options
+    });
+  }
+  static toSummary(payload) {
+    return {
+      id: payload.id,
+      name: payload.name,
+      entries: payload.entries,
+      requiresAuth: payload.requires_auth,
+      createdAt: new Date(payload.created_at),
+      updatedAt: new Date(payload.updated_at)
+    };
+  }
+  static warnOnReservedFields(schema) {
+    for (const name of Object.keys(schema.properties ?? {})) {
+      if (ReservedFieldNames.isReserved(name)) {
+        console.warn(`@org-quicko/silo-client: collection schema declares reserved field "${name}", which the server never returns`);
+      }
+    }
+  }
+}
+
+// src/variables/environment-variables.ts
+class EnvironmentVariables {
+  scope;
+  constructor(scope) {
+    this.scope = scope;
+  }
+  async list(options = {}) {
+    const body = await this.scope.transport.json({
+      method: "GET",
+      path: ApiPath.environmentVariables(this.scope.project, this.scope.environment),
+      ...options
+    });
+    return body.items.map(Variable.fromWire);
+  }
+  async set(name, value, options = {}) {
+    const payload = await this.scope.transport.json({
+      method: "PUT",
+      path: ApiPath.environmentVariable(this.scope.project, this.scope.environment, name),
+      body: { value },
+      ...options
+    });
+    return Variable.fromWire(payload);
+  }
+  async unset(name, options = {}) {
+    const payload = await this.scope.transport.json({
+      method: "DELETE",
+      path: ApiPath.environmentVariable(this.scope.project, this.scope.environment, name),
+      ...options
+    });
+    return Variable.fromWire(payload);
+  }
+}
+
+// src/scope/environment-handle.ts
+class EnvironmentHandle {
+  scope;
+  name;
+  project;
+  collections;
+  variables;
+  constructor(scope) {
+    this.scope = scope;
+    this.name = scope.environment;
+    this.project = scope.project;
+    this.collections = new Collections(scope);
+    this.variables = new EnvironmentVariables(scope);
+  }
+  collection(name) {
+    return new CollectionHandle(this.scope, name);
+  }
+  async schemas(options = {}) {
+    const body = await this.scope.transport.json({
+      method: "GET",
+      path: ApiPath.schemas(this.scope.project, this.scope.environment),
+      ...options
+    });
+    return body.items;
+  }
+  async search(query, options = {}) {
+    return new Search(this.scope.transport, SearchReach.environment(this.scope.project, this.scope.environment)).run(query, options);
+  }
+  async rename(name, options = {}) {
+    const payload = await this.scope.transport.json({
+      method: "PATCH",
+      path: ApiPath.environment(this.scope.project, this.scope.environment),
+      query: { dry_run: options.dryRun || undefined, expected_id: options.expectedId },
+      body: { name },
+      signal: options.signal,
+      timeoutMilliseconds: options.timeoutMilliseconds
+    });
+    return RenameReport.fromWire(payload);
+  }
+  async delete(options = {}) {
+    await this.scope.transport.empty({
+      method: "DELETE",
+      path: ApiPath.environment(this.scope.project, this.scope.environment),
+      query: { force: options.force || undefined },
+      signal: options.signal,
+      timeoutMilliseconds: options.timeoutMilliseconds
+    });
+  }
+}
+
+// src/scope/environments.ts
+class Environments {
+  transport;
+  project;
+  constructor(transport, project) {
+    this.transport = transport;
+    this.project = project;
+  }
+  async list(options = {}) {
+    const body = await this.transport.json({
+      method: "GET",
+      path: ApiPath.environments(this.project),
+      ...options
+    });
+    return body.items.map((item) => ({ id: item.id, name: item.name }));
+  }
+  async create(name, options = {}) {
+    const payload = await this.transport.json({
+      method: "POST",
+      path: ApiPath.environments(this.project),
+      body: { id: name },
+      ...options
+    });
+    return { id: payload.id, name: payload.name };
+  }
+}
+
+// src/scope/scope-reference.ts
+class ScopeReference {
+  transport;
+  project;
+  environment;
+  constructor(transport, project, environment) {
+    this.transport = transport;
+    this.project = project;
+    this.environment = environment;
+  }
+}
+
+// src/scope/project-handle.ts
+class ProjectHandle {
+  transport;
+  name;
+  environments;
+  variables;
+  constructor(transport, name) {
+    this.transport = transport;
+    this.name = name;
+    this.environments = new Environments(transport, name);
+    this.variables = new ProjectVariables(transport, name);
+  }
+  environment(name) {
+    return new EnvironmentHandle(new ScopeReference(this.transport, this.name, name));
+  }
+  async rename(name, options = {}) {
+    const payload = await this.transport.json({
+      method: "PATCH",
+      path: ApiPath.project(this.name),
+      query: { dry_run: options.dryRun || undefined, expected_id: options.expectedId },
+      body: { name },
+      signal: options.signal,
+      timeoutMilliseconds: options.timeoutMilliseconds
+    });
+    return RenameReport.fromWire(payload);
+  }
+  async delete(options = {}) {
+    await this.transport.empty({
+      method: "DELETE",
+      path: ApiPath.project(this.name),
+      query: { force: options.force || undefined },
+      signal: options.signal,
+      timeoutMilliseconds: options.timeoutMilliseconds
+    });
+  }
+}
+
+// src/scope/projects.ts
+class Projects {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(options = {}) {
+    const body = await this.transport.json({
+      method: "GET",
+      path: ApiPath.projects(),
+      ...options
+    });
+    return body.items.map((item) => ({ id: item.id, name: item.name }));
+  }
+  async create(name, options = {}) {
+    const payload = await this.transport.json({
+      method: "POST",
+      path: ApiPath.projects(),
+      body: { id: name },
+      ...options
+    });
+    return { id: payload.id, name: payload.name };
+  }
+}
+
+// src/errors/silo-error.ts
+class SiloError extends Error {
+  status;
+  code;
+  method;
+  path;
+  constructor(status, code, message, method, path) {
+    super(message);
+    this.name = "SiloError";
+    this.status = status;
+    this.code = code;
+    this.method = method;
+    this.path = path;
+    Object.setPrototypeOf(this, SiloError.prototype);
+  }
+}
+
+// src/errors/conflict-error.ts
+class ConflictError extends SiloError {
+  constructor(message, method, path, code = "conflict") {
+    super(409, code, message, method, path);
+    this.name = "ConflictError";
+    Object.setPrototypeOf(this, ConflictError.prototype);
+  }
+}
+
+// src/errors/forbidden-error.ts
+class ForbiddenError extends SiloError {
+  constructor(message, method, path) {
+    super(403, "forbidden", message, method, path);
+    this.name = "ForbiddenError";
+    Object.setPrototypeOf(this, ForbiddenError.prototype);
+  }
+}
+
+// src/errors/internal-error.ts
+class InternalError extends SiloError {
+  constructor(message, method, path) {
+    super(500, "internal", message, method, path);
+    this.name = "InternalError";
+    Object.setPrototypeOf(this, InternalError.prototype);
+  }
+}
+
+// src/errors/media-delete-stalled-error.ts
+class MediaDeleteStalledError extends SiloError {
+  remedy;
+  constructor(message, method, path, remedy) {
+    super(500, "media_delete_stalled", message, method, path);
+    this.name = "MediaDeleteStalledError";
+    this.remedy = remedy;
+    Object.setPrototypeOf(this, MediaDeleteStalledError.prototype);
+  }
+  static fromWireDetails(message, method, path, details) {
+    const object = details && typeof details === "object" ? details : {};
+    const remedy = typeof object.remedy === "string" ? object.remedy : "";
+    return new MediaDeleteStalledError(message, method, path, remedy);
+  }
+}
+
+// src/errors/media-in-use-error.ts
+class MediaInUseError extends ConflictError {
+  usageCount;
+  visibleCount;
+  visibleCapped;
+  referrers;
+  constructor(message, method, path, usageCount, visibleCount, visibleCapped, referrers) {
+    super(message, method, path, "media_in_use");
+    this.name = "MediaInUseError";
+    this.usageCount = usageCount;
+    this.visibleCount = visibleCount;
+    this.visibleCapped = visibleCapped;
+    this.referrers = referrers;
+    Object.setPrototypeOf(this, MediaInUseError.prototype);
+  }
+  static fromWireDetails(message, method, path, details) {
+    const object = details && typeof details === "object" ? details : {};
+    const referrers = Array.isArray(object.referrers) ? object.referrers.map((referrer) => MediaAssetMapper.toUsage(referrer)) : [];
+    return new MediaInUseError(message, method, path, typeof object.usage_count === "number" ? object.usage_count : 0, typeof object.visible_count === "number" ? object.visible_count : 0, object.visible_capped === true, referrers);
+  }
+}
+
+// src/errors/not-found-error.ts
+class NotFoundError extends SiloError {
+  constructor(message, method, path) {
+    super(404, "not_found", message, method, path);
+    this.name = "NotFoundError";
+    Object.setPrototypeOf(this, NotFoundError.prototype);
+  }
+}
+
+// src/errors/unauthorized-error.ts
+class UnauthorizedError extends SiloError {
+  constructor(message, method, path) {
+    super(401, "unauthorized", message, method, path);
+    this.name = "UnauthorizedError";
+    Object.setPrototypeOf(this, UnauthorizedError.prototype);
+  }
+}
+
+// src/errors/validation-failed-error.ts
+class ValidationFailedError extends SiloError {
+  details;
+  constructor(message, method, path, details) {
+    super(400, "validation_failed", message, method, path);
+    this.name = "ValidationFailedError";
+    this.details = details;
+    Object.setPrototypeOf(this, ValidationFailedError.prototype);
+  }
+  static fromWireDetails(message, method, path, details) {
+    const array = Array.isArray(details) ? details : [];
+    return new ValidationFailedError(message, method, path, array);
+  }
+}
+
+// src/errors/error-factory.ts
+class ErrorFactory {
+  static fromResponseBody(status, method, path, rawBody) {
+    const payload = ErrorFactory.parse(rawBody);
+    if (!payload) {
+      const message2 = rawBody.trim().length > 0 ? rawBody : `request failed with status ${status}`;
+      return ErrorFactory.byStatus(status, message2, method, path);
+    }
+    const { code, message, details } = payload.error;
+    switch (code) {
+      case "validation_failed":
+        return ValidationFailedError.fromWireDetails(message, method, path, details);
+      case "unauthorized":
+        return new UnauthorizedError(message, method, path);
+      case "forbidden":
+        return new ForbiddenError(message, method, path);
+      case "not_found":
+        return new NotFoundError(message, method, path);
+      case "conflict":
+        return new ConflictError(message, method, path);
+      case "media_in_use":
+        return MediaInUseError.fromWireDetails(message, method, path, details);
+      case "media_delete_stalled":
+        return MediaDeleteStalledError.fromWireDetails(message, method, path, details);
+      case "internal":
+        return new InternalError(message, method, path);
+      default:
+        return ErrorFactory.byStatus(status, message, method, path);
+    }
+  }
+  static byStatus(status, message, method, path) {
+    switch (status) {
+      case 400:
+        return new ValidationFailedError(message, method, path, []);
+      case 401:
+        return new UnauthorizedError(message, method, path);
+      case 403:
+        return new ForbiddenError(message, method, path);
+      case 404:
+        return new NotFoundError(message, method, path);
+      case 409:
+        return new ConflictError(message, method, path);
+      default:
+        return new SiloError(status, "unknown", message, method, path);
+    }
+  }
+  static parse(rawBody) {
+    if (!rawBody)
+      return null;
+    try {
+      const parsed = JSON.parse(rawBody);
+      if (parsed && typeof parsed === "object" && "error" in parsed)
+        return parsed;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+}
+
+// src/errors/network-error.ts
+class NetworkError extends Error {
+  method;
+  path;
+  constructor(method, path, cause) {
+    super(`network error on ${method} ${path}: the request never reached the server`, { cause });
+    this.name = "NetworkError";
+    this.method = method;
+    this.path = path;
+    Object.setPrototypeOf(this, NetworkError.prototype);
+  }
+}
+
+// src/errors/timeout-error.ts
+class TimeoutError extends Error {
+  method;
+  path;
+  timeoutMilliseconds;
+  constructor(method, path, timeoutMilliseconds) {
+    super(`${method} ${path} timed out after ${timeoutMilliseconds}ms`);
+    this.name = "TimeoutError";
+    this.method = method;
+    this.path = path;
+    this.timeoutMilliseconds = timeoutMilliseconds;
+    Object.setPrototypeOf(this, TimeoutError.prototype);
+  }
+}
+
+// src/transport/abort-signals.ts
+class AbortSignals {
+  signal;
+  reason;
+  cleanups = [];
+  constructor(callerSignal, timeoutMilliseconds) {
+    const controller = new AbortController;
+    const fire = (reason) => {
+      if (this.reason)
+        return;
+      this.reason = reason;
+      controller.abort();
+    };
+    if (callerSignal) {
+      if (callerSignal.aborted) {
+        fire("caller");
+      } else {
+        const onAbort = () => fire("caller");
+        callerSignal.addEventListener("abort", onAbort);
+        this.cleanups.push(() => callerSignal.removeEventListener("abort", onAbort));
+      }
+    }
+    if (timeoutMilliseconds !== undefined) {
+      const timer = setTimeout(() => fire("timeout"), timeoutMilliseconds);
+      this.cleanups.push(() => clearTimeout(timer));
+    }
+    this.signal = controller.signal;
+  }
+  firedBy() {
+    return this.reason;
+  }
+  dispose() {
+    for (const cleanup of this.cleanups.splice(0))
+      cleanup();
+  }
+}
+
+// src/transport/query-string.ts
+class QueryString {
+  static build(query) {
+    if (!query)
+      return "";
+    const parts = [];
+    for (const [key, value] of Object.entries(query)) {
+      if (value === undefined || value === null)
+        continue;
+      const encoded = typeof value === "object" ? JSON.stringify(value) : String(value);
+      parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(encoded)}`);
+    }
+    return parts.length > 0 ? `?${parts.join("&")}` : "";
+  }
+}
+
+// src/errors/invalid-response-error.ts
+class InvalidResponseError extends Error {
+  method;
+  path;
+  contentType;
+  constructor(method, path, contentType) {
+    super(`${method} ${path} answered with content-type "${contentType}", not the JSON this route promises`);
+    this.name = "InvalidResponseError";
+    this.method = method;
+    this.path = path;
+    this.contentType = contentType;
+    Object.setPrototypeOf(this, InvalidResponseError.prototype);
+  }
+}
+
+// src/transport/response-decoder.ts
+class ResponseDecoder {
+  static async decode(response, request, expectJson) {
+    if (response.status === 204)
+      return;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      return response.json();
+    }
+    if (expectJson) {
+      throw new InvalidResponseError(request.method, request.path, contentType);
+    }
+    return response.text();
+  }
+}
+
+// src/transport/transport.ts
+class Transport {
+  url;
+  key;
+  headers;
+  timeoutMilliseconds;
+  fetchFunction;
+  constructor(options) {
+    this.url = Transport.normalizeUrl(options.url);
+    this.key = options.key;
+    this.headers = options.headers ?? {};
+    this.timeoutMilliseconds = options.timeoutMilliseconds;
+    this.fetchFunction = options.fetch ?? fetch;
+  }
+  async json(request) {
+    const response = await this.execute(request);
+    return await ResponseDecoder.decode(response, request, true);
+  }
+  async empty(request) {
+    const response = await this.execute(request);
+    await ResponseDecoder.decode(response, request, false);
+  }
+  async stream(request) {
+    const response = await this.execute(request);
+    return response.body;
+  }
+  async upload(request, form) {
+    const response = await this.execute(request, form);
+    return await ResponseDecoder.decode(response, request, true);
+  }
+  withKey(key) {
+    return new Transport({ ...this.snapshot(), key });
+  }
+  withUrl(url) {
+    return new Transport({ ...this.snapshot(), url });
+  }
+  snapshot() {
+    return {
+      url: this.url,
+      key: this.key,
+      headers: this.headers,
+      timeoutMilliseconds: this.timeoutMilliseconds,
+      fetch: this.fetchFunction
+    };
+  }
+  async execute(request, form) {
+    const abortSignals = new AbortSignals(request.signal, request.timeoutMilliseconds ?? this.timeoutMilliseconds);
+    const url = `${this.url}${request.path}${QueryString.build(request.query)}`;
+    let response;
+    try {
+      response = await this.fetchFunction(url, {
+        method: request.method,
+        headers: this.buildHeaders(request, Boolean(form)),
+        body: form ?? (request.body === undefined ? undefined : JSON.stringify(request.body)),
+        signal: abortSignals.signal
+      });
+    } catch (caught) {
+      throw this.transportFailure(request, abortSignals, caught);
+    } finally {
+      abortSignals.dispose();
+    }
+    if (!response.ok) {
+      throw ErrorFactory.fromResponseBody(response.status, request.method, request.path, await response.text());
+    }
+    return response;
+  }
+  transportFailure(request, abortSignals, caught) {
+    const firedBy = abortSignals.firedBy();
+    if (firedBy === "timeout") {
+      return new TimeoutError(request.method, request.path, request.timeoutMilliseconds ?? this.timeoutMilliseconds ?? 0);
+    }
+    if (firedBy === "caller") {
+      return new RequestAbortedError(request.method, request.path);
+    }
+    return new NetworkError(request.method, request.path, caught);
+  }
+  buildHeaders(request, isUpload) {
+    const headers = { ...this.headers, ...request.headers };
+    if (this.key)
+      headers["Authorization"] = `Bearer ${this.key}`;
+    if (!isUpload && request.body !== undefined && !("Content-Type" in headers)) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
+  static normalizeUrl(url) {
+    return url.replace(/\/+$/, "");
+  }
+}
+
+// src/silo.ts
+class Silo {
+  projects;
+  media;
+  options;
+  transport;
+  constructor(options) {
+    this.options = options;
+    this.transport = new Transport({
+      url: options.url,
+      key: options.key,
+      headers: options.headers,
+      timeoutMilliseconds: options.timeoutMilliseconds,
+      fetch: options.fetch
+    });
+    this.projects = new Projects(this.transport);
+    this.media = new Media(this.transport);
+  }
+  project(name) {
+    return new ProjectHandle(this.transport, name);
+  }
+  scope(project, environment) {
+    return this.project(project).environment(environment);
+  }
+  search(query, options) {
+    return new Search(this.transport, SearchReach.instance()).run(query, options);
+  }
+  health(options) {
+    return this.transport.json({
+      method: "GET",
+      path: ApiPath.health(),
+      signal: options?.signal,
+      timeoutMilliseconds: options?.timeoutMilliseconds
+    });
+  }
+  withKey(key) {
+    return new Silo({ ...this.options, key });
+  }
+  withUrl(url) {
+    return new Silo({ ...this.options, url });
+  }
+}
+// src/transport/route-inventory.ts
+class RouteInventory {
+  static Covered = [
+    "GET /api/health",
+    "GET /api/projects",
+    "POST /api/projects",
+    "PATCH /api/projects/:project",
+    "DELETE /api/projects/:project",
+    "GET /api/projects/:project/envs",
+    "POST /api/projects/:project/envs",
+    "PATCH /api/projects/:project/envs/:env",
+    "DELETE /api/projects/:project/envs/:env",
+    "POST /api/projects/:project/variables",
+    "PATCH /api/projects/:project/variables/:name",
+    "DELETE /api/projects/:project/variables/:name",
+    "GET /api/projects/:project/envs/:env/variables",
+    "PUT /api/projects/:project/envs/:env/variables/:name",
+    "DELETE /api/projects/:project/envs/:env/variables/:name",
+    "GET /api/projects/:project/envs/:env/collections",
+    "POST /api/projects/:project/envs/:env/collections",
+    "PATCH /api/projects/:project/envs/:env/collections/:name",
+    "GET /api/projects/:project/envs/:env/schemas",
+    "GET /api/projects/:project/envs/:env/collections/:name/schema",
+    "PUT /api/projects/:project/envs/:env/collections/:name/schema",
+    "DELETE /api/projects/:project/envs/:env/collections/:name/schema",
+    "GET /api/projects/:project/envs/:env/collections/:name",
+    "POST /api/projects/:project/envs/:env/collections/:name",
+    "GET /api/projects/:project/envs/:env/collections/:name/:id",
+    "PUT /api/projects/:project/envs/:env/collections/:name/:id",
+    "DELETE /api/projects/:project/envs/:env/collections/:name/:id",
+    "GET /api/projects/:project/envs/:env/collections/:name/search",
+    "GET /api/projects/:project/envs/:env/search",
+    "GET /api/search",
+    "GET /api/media",
+    "POST /api/media",
+    "GET /api/media/extensions",
+    "GET /api/media/:id",
+    "PATCH /api/media/:id",
+    "DELETE /api/media/:id",
+    "GET /api/media/:id/usages",
+    "POST /api/media/delete",
+    "GET /api/media/folders",
+    "POST /api/media/folders",
+    "PATCH /api/media/folders",
+    "DELETE /api/media/folders"
+  ];
+  static OutOfScope = {
+    "GET /api/session": "key introspection, an operator surface",
+    "GET /api/keys": "keys and claims are an operator surface",
+    "POST /api/keys": "keys and claims are an operator surface",
+    "DELETE /api/keys/:id": "keys and claims are an operator surface",
+    "GET /api/audit": "an operator surface",
+    "GET /api/observability": "an operator surface",
+    "GET /api/settings": "an operator surface",
+    "PUT /api/settings/:table": "an operator surface",
+    "GET /api/export": "transfer is an operator surface",
+    "POST /api/import": "transfer is an operator surface",
+    "POST /api/copy": "transfer is an operator surface",
+    "POST /api/projects/:project/envs/:env/copy": "scope-to-scope copy is transfer",
+    "POST /api/search/reindex": "rebuilding the index is an operator action",
+    "POST /api/media/purge": "emptying the library is an operator action",
+    "POST /api/media/reconcile": "an operator action",
+    "GET /api/media/storage": "media configuration is an operator surface",
+    "PUT /api/media/storage": "media configuration is an operator surface",
+    "GET /api/media/settings": "media configuration is an operator surface",
+    "PUT /api/media/settings": "media configuration is an operator surface",
+    "GET /api/plugins": "plugins are an operator surface",
+    "GET /api/plugins/:name": "plugins are an operator surface",
+    "GET /api/plugins/:name/ui": "a plugin's admin panel, rendered by the admin UI",
+    "DELETE /api/plugins/:name": "plugins are an operator surface",
+    "POST /api/plugins/install": "plugins are an operator surface",
+    "ALL /api/ext/*": "routes a plugin contributes; their shapes are the plugin's, not silo's",
+    "PUT /api/plugins/:name/grant": "plugins are an operator surface",
+    "DELETE /api/plugins/:name/grant": "plugins are an operator surface",
+    "POST /api/plugins/:name/enable": "plugins are an operator surface",
+    "POST /api/plugins/:name/disable": "plugins are an operator surface",
+    "POST /api/plugins/:name/restart": "plugins are an operator surface",
+    "PATCH /api/plugins/:name/config": "plugins are an operator surface",
+    "DELETE /api/plugins/:name/config": "plugins are an operator surface",
+    "POST /api/plugins/rescan": "plugins are an operator surface",
+    "GET /media/:idOrKey": "a browser URL, not a call: use asset.url"
+  };
+  static accountsFor(route) {
+    return RouteInventory.Covered.includes(route) || route in RouteInventory.OutOfScope;
+  }
+}
+// src/query/filter.ts
+class Filter {
+  static field(name) {
+    return new FilterField(FieldPath.field(name));
+  }
+  static each(name) {
+    return new FilterField(FieldPath.each(name));
+  }
+  static meta(name) {
+    return new FilterField(FieldPath.meta(name));
+  }
+  static and(left, right) {
+    return left.and(right);
+  }
+  static or(left, right) {
+    return left.or(right);
+  }
+  static not(expression) {
+    return expression.not();
+  }
+  static raw(node) {
+    return new FilterExpression(node);
+  }
+}
+// src/query/sort-term.ts
+class SortTerm {
+  path;
+  direction;
+  constructor(path, direction = "asc") {
+    this.path = path;
+    this.direction = direction;
+  }
+  ascending() {
+    return new SortTerm(this.path, "asc");
+  }
+  descending() {
+    return new SortTerm(this.path, "desc");
+  }
+  toString() {
+    return this.direction === "desc" ? `-${this.path}` : this.path;
+  }
+}
+
+// src/query/sort.ts
+class Sort {
+  static by(name) {
+    return new SortTerm(FieldPath.field(name));
+  }
+  static meta(name) {
+    return new SortTerm(FieldPath.meta(name));
+  }
+  static recentlyUpdated() {
+    return Sort.meta("updated_at").descending();
+  }
+  static recentlyCreated() {
+    return Sort.meta("created_at").descending();
+  }
+  static of(...terms) {
+    return terms.map((term) => term.toString()).join(",");
+  }
+}
+// src/query/filter-operator.ts
+var FilterOperators = Object.freeze([
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "contains",
+  "exists",
+  "and",
+  "or",
+  "not"
+]);
+export {
+  Variable,
+  ValidationFailedError,
+  UnauthorizedError,
+  TypedFilter,
+  TimeoutError,
+  SortTerm,
+  Sort,
+  SiloError,
+  Silo,
+  SearchReach,
+  SearchPage,
+  Search,
+  RowStream,
+  RouteInventory,
+  ResolvedEntry,
+  ReservedFieldNames,
+  RequestAbortedError,
+  RenameReport,
+  Projects,
+  ProjectVariables,
+  ProjectHandle,
+  PageWindow,
+  Page,
+  NotFoundError,
+  NetworkError,
+  MediaUsagePage,
+  MediaStream,
+  MediaReference,
+  MediaPageStream,
+  MediaPage,
+  MediaInUseError,
+  MediaFolders,
+  MediaDeleteStalledError,
+  MediaDeleteReport,
+  MediaAsset,
+  Media,
+  InvalidResponseError,
+  InternalError,
+  ForbiddenError,
+  FilterOperators,
+  FilterField,
+  FilterExpression,
+  Filter,
+  FieldPath,
+  Environments,
+  EnvironmentVariables,
+  EnvironmentHandle,
+  EntryStream,
+  EntryReader,
+  EntryPageStream,
+  EntryPage,
+  EntryBase,
+  Entry,
+  ConflictError,
+  Collections,
+  CollectionSchema,
+  CollectionHandle
+};