@versionone/agility-sdk 0.0.0-stage → 1.0.0-alpha.2

package/dist/index.cjs

@@ -0,0 +1,1681 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ASSET_STATE_CODES: () => ASSET_STATE_CODES,
+  AgilityApiClient: () => AgilityApiClient,
+  ApiError: () => ApiError,
+  AttachmentUploadError: () => AttachmentUploadError,
+  BatchRecordError: () => BatchRecordError,
+  BatchSendError: () => BatchSendError,
+  CommandFailureError: () => CommandFailureError,
+  INLINE_LIMIT: () => INLINE_LIMIT,
+  INVERSE: () => INVERSE,
+  NUMBER_ROOTS: () => NUMBER_ROOTS,
+  RESOLVE_CHUNK: () => CHUNK3,
+  Schema: () => Schema,
+  TypeCache: () => TypeCache,
+  UNGUARDABLE_TYPES: () => UNGUARDABLE_TYPES,
+  UnguardableError: () => UnguardableError,
+  assetApi: () => assetApi_exports,
+  assetStateOf: () => assetStateOf,
+  attachment: () => attachment_exports,
+  createFetchTransport: () => createFetchTransport,
+  describeBatch: () => describe,
+  guard: () => guard,
+  isAssetNumber: () => isAssetNumber,
+  isOidToken: () => isOidToken,
+  loc2: () => loc2_exports,
+  meta: () => meta_exports,
+  momentless: () => momentless,
+  namesOf: () => namesOf,
+  parseOid: () => parseOid,
+  queryV1: () => queryV1_exports,
+  resolveNumbers: () => resolveNumbers,
+  resolveRef: () => resolveRef,
+  rest1: () => rest1_exports,
+  reverseOf: () => reverseOf,
+  reversible: () => reversible,
+  runBatch: () => runBatch,
+  select: () => select_exports,
+  sendGuarded: () => sendGuarded,
+  snapshot: () => snapshot,
+  stampsOf: () => stampsOf,
+  toOid: () => toOid,
+  touchedBy: () => touchedBy,
+  typeOfOid: () => typeOfOid,
+  unguardable: () => unguardable
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/errors.ts
+var ApiError = class extends Error {
+  status;
+  code;
+  details;
+  constructor(message, status, code, details) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/core/fetchTransport.ts
+function abortedError(signal) {
+  return new ApiError("Request aborted", 0, "ABORTED", { cause: signal.reason });
+}
+function buildUrl(baseUrl, path, query3) {
+  const normalizedBase = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+  const url = new URL(normalizedPath, normalizedBase);
+  if (query3) {
+    for (const [key, value] of Object.entries(query3)) {
+      if (value !== void 0 && value !== null) url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+function encodeBody(body, contentType) {
+  if (body === void 0) return {};
+  if (typeof body === "string") return { body, contentType: contentType ?? "text/plain" };
+  if (body instanceof Uint8Array || body instanceof ArrayBuffer) {
+    return { body, contentType: contentType ?? "application/octet-stream" };
+  }
+  if (typeof FormData !== "undefined" && body instanceof FormData) return { body };
+  if (typeof Blob !== "undefined" && body instanceof Blob) return { body, contentType: contentType ?? (body.type || "application/octet-stream") };
+  return { body: JSON.stringify(body), contentType: contentType ?? "application/json" };
+}
+async function readBody(response, responseType) {
+  if (responseType === "bytes") return new Uint8Array(await response.arrayBuffer());
+  if (responseType === "text") return response.text();
+  const contentType = response.headers.get("content-type") ?? "";
+  if (responseType === "json" || contentType.includes("json")) {
+    const text = await response.text();
+    if (!text) return void 0;
+    try {
+      return JSON.parse(text);
+    } catch {
+      if (responseType === "json") throw new ApiError("Response is not JSON", response.status, "BAD_JSON", { body: text.slice(0, 500) });
+      return text;
+    }
+  }
+  return response.text();
+}
+function messageOf(data, status) {
+  if (data && typeof data === "object") {
+    const d = data;
+    const first = Array.isArray(d.exceptions) && d.exceptions[0] && typeof d.exceptions[0] === "object" ? d.exceptions[0].message : void 0;
+    const listed = Array.isArray(d.Exceptions) ? d.Exceptions.filter((x) => typeof x === "string" && !!x).join("; ") : void 0;
+    for (const candidate of [d.error, first, listed, d.message]) {
+      if (typeof candidate === "string" && candidate) return candidate;
+    }
+  }
+  if (typeof data === "string" && data.trim()) return data.trim().slice(0, 200);
+  return `HTTP ${status}`;
+}
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function createFetchTransport(config) {
+  const fetchImpl = config.fetchImpl ?? fetch;
+  const timeoutMs = config.timeoutMs ?? 6e4;
+  const retries = Math.max(0, config.retries ?? 0);
+  const authorization = config.authorization ?? (config.accessToken ? `Bearer ${config.accessToken}` : void 0);
+  const unauthorizedStatuses = config.unauthorizedStatuses ?? [401];
+  return {
+    async request(options) {
+      const url = buildUrl(config.baseUrl, options.path, options.query);
+      const { body, contentType } = encodeBody(options.body, options.contentType);
+      const headers = { accept: "application/json", ...config.defaultHeaders, ...options.headers };
+      if (contentType) headers["content-type"] = contentType;
+      if (authorization) headers.authorization = authorization;
+      const responseType = options.responseType ?? "auto";
+      const idempotent = options.idempotent ?? options.method === "GET";
+      const attempts = idempotent ? retries + 1 : 1;
+      const callerSignal = options.signal;
+      let lastError;
+      let reauthorized = false;
+      for (let attempt = 0; attempt < attempts; attempt += 1) {
+        if (callerSignal?.aborted) throw abortedError(callerSignal);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        const onAbort = () => controller.abort();
+        callerSignal?.addEventListener("abort", onAbort, { once: true });
+        const settle = () => {
+          clearTimeout(timeoutId);
+          callerSignal?.removeEventListener("abort", onAbort);
+        };
+        let response;
+        try {
+          const init = { method: options.method, headers, body, signal: controller.signal };
+          if (config.credentials) init.credentials = config.credentials;
+          response = await fetchImpl(url, init);
+        } catch (error) {
+          settle();
+          if (callerSignal?.aborted) throw abortedError(callerSignal);
+          lastError = error instanceof Error && error.name === "AbortError" ? new ApiError(`Timed out after ${timeoutMs} ms`, 0, "TIMEOUT", { cause: error }) : new ApiError(error instanceof Error ? error.message : String(error), 0, "NETWORK_ERROR", { cause: error });
+          if (attempt + 1 < attempts) await delay(150 * (attempt + 1));
+          continue;
+        }
+        try {
+          if (response.ok) {
+            options.onResponse?.({ status: response.status, headers: response.headers });
+            return await readBody(response, responseType);
+          }
+          const data = await readBody(response, responseType === "bytes" ? "text" : responseType === "json" ? "auto" : responseType);
+          lastError = new ApiError(messageOf(data, response.status), response.status, void 0, data);
+        } catch (error) {
+          if (callerSignal?.aborted) throw abortedError(callerSignal);
+          throw error;
+        } finally {
+          settle();
+        }
+        if (config.onUnauthorized && !reauthorized && unauthorizedStatuses.includes(response.status)) {
+          reauthorized = true;
+          const decision = await config.onUnauthorized({ error: lastError, request: options, retryable: idempotent });
+          if (callerSignal?.aborted) throw abortedError(callerSignal);
+          if (decision === "retry" && idempotent) {
+            attempt -= 1;
+            continue;
+          }
+          break;
+        }
+        if (response.status >= 500 && attempt + 1 < attempts) {
+          await delay(150 * (attempt + 1));
+          continue;
+        }
+        break;
+      }
+      throw lastError instanceof ApiError ? lastError : new ApiError("Unknown transport error", 0, "UNKNOWN_ERROR", { cause: lastError });
+    }
+  };
+}
+
+// src/types/oid.ts
+var OID_TOKEN = /^([A-Za-z][A-Za-z0-9_]*):(\d+)(?::(\d+))?$/;
+function isOidToken(value) {
+  return typeof value === "string" && OID_TOKEN.test(value);
+}
+function parseOid(token) {
+  const m = OID_TOKEN.exec(token);
+  if (!m) throw new Error(`"${token}" is not an OID token (Story:1234)`);
+  return { type: m[1], id: Number(m[2]), moment: m[3] === void 0 ? null : Number(m[3]) };
+}
+function momentless(token) {
+  const m = OID_TOKEN.exec(token);
+  return m ? `${m[1]}:${m[2]}` : token;
+}
+function typeOfOid(token) {
+  return parseOid(token).type;
+}
+function toOid(type, id, moment) {
+  return moment == null ? `${type}:${id}` : `${type}:${id}:${moment}`;
+}
+
+// src/wire/assetApi.ts
+var assetApi_exports = {};
+__export(assetApi_exports, {
+  CommandFailureError: () => CommandFailureError,
+  emptyOutcome: () => emptyOutcome,
+  failuresOf: () => failuresOf,
+  fromWireRow: () => fromWireRow,
+  mergeOutcome: () => mergeOutcome,
+  momentless: () => momentless,
+  outcomeOf: () => outcomeOf,
+  preview: () => preview,
+  queries: () => queries,
+  query: () => query,
+  queryPage: () => queryPage,
+  send: () => send,
+  sendYaml: () => sendYaml,
+  toWire: () => toWire,
+  toWireValue: () => toWireValue
+});
+
+// src/wire/select.ts
+var select_exports = {};
+__export(select_exports, {
+  attributeOf: () => attributeOf,
+  fromTypeOf: () => fromTypeOf,
+  resolvePath: () => resolvePath,
+  segmentsOf: () => segmentsOf,
+  typesNeeded: () => typesNeeded
+});
+function segmentsOf(path) {
+  const parts = [];
+  let depth = 0, quote = null, current = "";
+  for (const ch of path) {
+    if (quote) {
+      current += ch;
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "[") depth += 1;
+    if (ch === "]") depth -= 1;
+    if (ch === "." && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  parts.push(current);
+  return parts.map((raw) => {
+    if (raw.startsWith("@")) return { name: raw, downcast: null, aggregate: raw.slice(1) };
+    const bare = raw.replace(/\[[\s\S]*\]$/, "");
+    const colon = bare.indexOf(":");
+    return colon < 0 ? { name: bare, downcast: null, aggregate: null } : { name: bare.slice(0, colon), downcast: bare.slice(colon + 1) || null, aggregate: null };
+  });
+}
+function attributeOf(lookup, type, name) {
+  const t = lookup.assetType(type);
+  if (t === void 0) return void 0;
+  if (t === null) return null;
+  return t.Attributes[`${type}.${name}`] ?? Object.values(t.Attributes).find((a) => a.Name === name) ?? null;
+}
+function resolvePath(lookup, type, path) {
+  const segments = segmentsOf(path);
+  let current = type, multi = false, last = null;
+  for (const [i, seg] of segments.entries()) {
+    if (seg.aggregate) {
+      return i === segments.length - 1 ? { kind: "resolved", definition: null, valueType: null, multi: false, aggregate: seg.aggregate } : { kind: "unknown", at: path };
+    }
+    const def = attributeOf(lookup, current, seg.name);
+    if (def === void 0) return { kind: "needs", type: current };
+    if (def === null) return { kind: "unknown", at: `${current}.${seg.name}` };
+    if (def.AttributeType !== "Relation") {
+      return i === segments.length - 1 ? { kind: "resolved", definition: def, valueType: current, multi, aggregate: null } : { kind: "unknown", at: path };
+    }
+    multi ||= def.IsMultivalue;
+    const next = seg.downcast ?? def.RelatedAsset;
+    if (!next) return { kind: "unknown", at: `${current}.${seg.name}` };
+    current = next;
+    last = def;
+  }
+  return { kind: "resolved", definition: last, valueType: current, multi, aggregate: null };
+}
+function fromTypeOf(from, batch = []) {
+  const fromOid = isOidToken(from) ? typeOfOid(from) : null;
+  if (fromOid) return fromOid;
+  if (from.startsWith("@")) {
+    for (const command of batch) {
+      const body = command?.[from];
+      const assetType = body && typeof body === "object" ? body.AssetType : void 0;
+      if (typeof assetType === "string") return assetType;
+    }
+    return null;
+  }
+  return from;
+}
+function typesNeeded(lookup, query3, type) {
+  const needed = /* @__PURE__ */ new Set();
+  if (lookup.assetType(type) === void 0) {
+    needed.add(type);
+    return needed;
+  }
+  for (const entry of query3.select ?? []) {
+    const path = typeof entry === "string" ? entry : entry.from;
+    const r = resolvePath(lookup, type, path);
+    if (r.kind === "needs") needed.add(r.type);
+    else if (r.kind === "resolved" && typeof entry !== "string" && r.valueType) for (const t of typesNeeded(lookup, entry, r.valueType)) needed.add(t);
+  }
+  return needed;
+}
+
+// src/wire/assetApi.ts
+var isRef = (v) => !!v && typeof v === "object" && !Array.isArray(v) && "_oid" in v && typeof v._oid === "string";
+function toWireValue(value) {
+  if (isRef(value)) return momentless(value._oid);
+  if (Array.isArray(value)) return value.map(toWireValue);
+  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, toWireValue(v)]));
+  return value;
+}
+var toWire = (commands) => commands.map((c) => toWireValue(c));
+function fromWireRow(row, context) {
+  const out = {};
+  const grouped = Array.isArray(row._children);
+  for (const [k, v] of Object.entries(row)) {
+    if (grouped && k === "_children") out[k] = v.map((child) => child && typeof child === "object" ? fromWireRow(child, context) : child);
+    else if (grouped && k === "_oid" && v === "NULL") out[k] = null;
+    else if (k === "_oid" && typeof v === "string") out[k] = momentless(v);
+    else out[k] = context ? translate(v, resolvePath(context.lookup, context.type, k), context.lookup) : fromWireValue(v);
+  }
+  return out;
+}
+var isNullRef = (value) => isRef(value) && value._oid === "NULL";
+function fromWireValue(value) {
+  if (isNullRef(value)) return null;
+  if (isRef(value)) return { ...value, _oid: momentless(value._oid) };
+  if (Array.isArray(value)) return value.map(fromWireValue);
+  return value;
+}
+function translate(value, resolution, lookup) {
+  if (resolution.kind !== "resolved") return fromWireValue(value);
+  if (resolution.aggregate) return toNumber(value);
+  const definition = resolution.definition;
+  if (definition.AttributeType === "Relation") {
+    const context = resolution.valueType ? { lookup, type: resolution.valueType } : void 0;
+    const one2 = (x) => isNullRef(x) ? null : isRef(x) ? fromWireRow(x, context) : fromWireValue(x);
+    if (resolution.multi) return (Array.isArray(value) ? value : value == null ? [] : [value]).filter((x) => !isNullRef(x)).map(one2);
+    if (Array.isArray(value)) return value.length ? one2(value[0]) : null;
+    return value == null ? null : one2(value);
+  }
+  const one = (x) => scalar(x, definition.AttributeType);
+  return resolution.multi && Array.isArray(value) ? value.map(one) : one(value);
+}
+function scalar(value, type) {
+  if (value == null) return null;
+  switch (type) {
+    case "Numeric":
+    case "LongInt":
+    case "Rank":
+      return toNumber(value);
+    case "Boolean":
+      return value === true || value === "True" || value === "true" ? true : value === false || value === "False" || value === "false" ? false : value;
+    default:
+      return value;
+  }
+}
+function toNumber(value) {
+  if (value == null) return null;
+  if (typeof value === "number") return value;
+  const n = typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+  return Number.isNaN(n) ? value : n;
+}
+function failuresOf(response) {
+  return (response.commandFailures?.commands ?? []).map(({ error, ...echoed }) => ({
+    index: typeof error === "object" && error && typeof error.sourceCommandIndex === "number" ? error.sourceCommandIndex : null,
+    message: typeof error === "string" ? error : error?.message || "command failed",
+    echoed
+  }));
+}
+function outcomeOf(response) {
+  return {
+    created: (response.assetsCreated?.oidTokens ?? []).map(momentless),
+    modified: (response.assetsModified?.oidTokens ?? []).map(momentless),
+    operated: (response.assetsOperatedOn?.oidTokens ?? []).map(momentless),
+    failures: failuresOf(response),
+    queryResults: response.queryResult?.results ?? [],
+    durationSeconds: typeof response.durationSeconds === "number" ? response.durationSeconds : null
+  };
+}
+var emptyOutcome = () => ({ created: [], modified: [], operated: [], failures: [], queryResults: [], durationSeconds: null });
+function mergeOutcome(into, done, offset) {
+  into.created.push(...done.created);
+  into.modified.push(...done.modified);
+  into.operated.push(...done.operated);
+  into.failures.push(...done.failures.map((f) => ({ ...f, index: f.index === null ? null : f.index + offset })));
+  into.queryResults.push(...done.queryResults);
+  if (done.durationSeconds !== null) into.durationSeconds = (into.durationSeconds ?? 0) + done.durationSeconds;
+  return into;
+}
+var CommandFailureError = class extends ApiError {
+  failures;
+  response;
+  constructor(response, failures = failuresOf(response)) {
+    super(failures.map((f) => f.message).join("; ") || "command failed", 200, "CommandFailure", failures);
+    this.name = "CommandFailureError";
+    this.failures = failures;
+    this.response = response;
+  }
+};
+var bodyOf = (c) => {
+  const keys = Object.keys(c);
+  return keys.length === 1 && keys[0].startsWith("@") ? c[keys[0]] : c;
+};
+var isQuery = (body) => !!body && typeof body === "object" && typeof body.from === "string" && !("update" in body) && !("execute" in body) && !("AssetType" in body);
+function queriesIn(commands) {
+  return commands.flatMap((c, index) => {
+    const body = bodyOf(c);
+    return isQuery(body) ? [{ body, index }] : [];
+  });
+}
+function realign(sent, results, failed) {
+  const expected = sent.filter((q) => !failed.has(q.index)).length;
+  if (results.length !== expected) return null;
+  let next = 0;
+  return sent.map((q) => failed.has(q.index) ? null : results[next++]);
+}
+async function send(transport, commands, options = {}) {
+  const response = await transport.request({
+    method: "POST",
+    path: "/api/asset",
+    query: options.previewOnly ? { previewOnly: "true" } : void 0,
+    body: toWire(commands),
+    responseType: "json",
+    idempotent: options.idempotent === true
+  });
+  if (options.previewOnly) return response;
+  const queries3 = queriesIn(commands);
+  const failures = failuresOf(response);
+  const failed = new Set(failures.flatMap((f) => f.index === null ? [] : [f.index]));
+  const results = response.queryResult?.results ?? [];
+  let aligned = realign(queries3, results, failed);
+  if (!aligned) {
+    if (!failures.some((f) => f.index === null)) throw new Error(`api/asset returned ${results.length} query results for ${queries3.filter((q) => !failed.has(q.index)).length} queries that did not fail; cannot tell which result belongs to which query`);
+    aligned = queries3.map(() => null);
+  }
+  const contextOf = (i) => {
+    const type = options.lookup ? fromTypeOf(queries3[i].body.from, commands) : null;
+    return type ? { lookup: options.lookup, type } : void 0;
+  };
+  const translated = { ...response, queryResult: { ...response.queryResult, results: aligned.map((rows, i) => rows && rows.map((r) => fromWireRow(r, contextOf(i)))) } };
+  if (options.throwOnFailure && translated.commandFailures?.count) throw new CommandFailureError(translated);
+  return translated;
+}
+async function preview(transport, commands) {
+  return transport.request({ method: "POST", path: "/api/asset", query: { previewOnly: "true" }, body: toWire(commands), responseType: "json" });
+}
+async function sendYaml(transport, yaml, options = {}) {
+  return transport.request({ method: "POST", path: "/api/asset", query: options.previewOnly ? { previewOnly: "true" } : void 0, body: yaml, contentType: "text/yaml", responseType: "json" });
+}
+async function query(transport, q, options = {}) {
+  const [rows] = await queries(transport, [q], options);
+  return rows ?? [];
+}
+async function queryPage(transport, q, options = {}) {
+  if (!q.page) throw new Error(`query of ${q.from} without a page: every api/asset read must be bounded`);
+  const response = await send(transport, [{ ...q, needTotal: true }], { ...options, throwOnFailure: true });
+  const rows = response.queryResult.results[0] ?? [];
+  const reported = response.queryResult.resultMetaData?.[0]?.total;
+  const total = typeof reported === "number" ? reported : null;
+  return { rows, total, more: total === null ? rows.length === q.page.size : q.page.start + rows.length < total };
+}
+async function queries(transport, qs, options = {}) {
+  for (const q of qs) if (!q.page) throw new Error(`query of ${q.from} without a page: every api/asset read must be bounded`);
+  const response = await send(transport, qs, { ...options, throwOnFailure: true });
+  return qs.map((_, i) => response.queryResult.results[i] ?? []);
+}
+
+// src/wire/attachment.ts
+var attachment_exports = {};
+__export(attachment_exports, {
+  attachmentUrl: () => attachmentUrl,
+  embeddedImageUrl: () => embeddedImageUrl,
+  fromBase64: () => fromBase64,
+  getBytes: () => getBytes,
+  getFile: () => getFile,
+  normalizeEmbeddedImageUrls: () => normalizeEmbeddedImageUrls,
+  numericId: () => numericId,
+  putBytes: () => putBytes,
+  toBase64: () => toBase64,
+  toUint8Array: () => toUint8Array,
+  uploadEmbeddedImage: () => uploadEmbeddedImage
+});
+async function toUint8Array(data) {
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  return new Uint8Array(await data.arrayBuffer());
+}
+function toBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(binary);
+}
+function fromBase64(text) {
+  const binary = atob(text);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) out[i] = binary.charCodeAt(i);
+  return out;
+}
+function numericId(spec) {
+  const m = /^(?:[A-Za-z]+:)?(\d+)(?::\d+)?$/.exec(String(spec).trim());
+  if (!m) throw new TypeError(`"${spec}" is not an asset id (5678, or an OID token such as Attachment:5678)`);
+  return m[1];
+}
+var join = (baseUrl, path) => `${baseUrl.replace(/\/+$/, "")}/${path}`;
+var attachmentUrl = (baseUrl, id) => join(baseUrl, `attachment.img/${numericId(id)}`);
+var embeddedImageUrl = (baseUrl, id) => join(baseUrl, `embedded.img/${numericId(id)}`);
+function normalizeEmbeddedImageUrls(html, baseUrl) {
+  return html.replace(/(\bsrc\s*=\s*)(["'])([^"']*?embedded\.img\/(\d+)[^"']*)\2/gi, (_m, attr, quote, _url, id) => `${attr}${quote}${embeddedImageUrl(baseUrl, id)}${quote}`);
+}
+function named(error, what) {
+  if (!(error instanceof ApiError)) return error;
+  if (error.status === 404) return new ApiError(`${what}: not found`, 404, "NOT_FOUND", error.details);
+  if (error.status === 413) return new ApiError(`${what}: larger than the server's maximum request length`, 413, "TOO_LARGE", error.details);
+  return error;
+}
+async function getBytes(transport, id) {
+  const n = numericId(id);
+  try {
+    return await transport.request({ method: "GET", path: `/attachment.img/${n}`, responseType: "bytes" });
+  } catch (error) {
+    throw named(error, `attachment ${n}`);
+  }
+}
+async function getFile(transport, id) {
+  const n = numericId(id);
+  let contentType = null, filename = null;
+  const onResponse = ({ headers }) => {
+    contentType = headers.get("content-type");
+    const disposition = headers.get("content-disposition") ?? "";
+    const encoded = /filename\*=UTF-8''([^;]+)/i.exec(disposition)?.[1];
+    filename = encoded ? decodeURIComponent(encoded) : /filename="?([^";]+)"?/i.exec(disposition)?.[1] ?? null;
+  };
+  try {
+    const bytes = await transport.request({ method: "GET", path: `/attachment.img/${n}`, responseType: "bytes", onResponse });
+    return { bytes, contentType, filename };
+  } catch (error) {
+    throw named(error, `attachment ${n}`);
+  }
+}
+async function putBytes(transport, id, data, contentType = "application/octet-stream") {
+  const n = numericId(id);
+  const body = data instanceof Blob ? data : await toUint8Array(data);
+  try {
+    await transport.request({ method: "POST", path: `/attachment.img/${n}`, body, contentType: data instanceof Blob && data.type ? data.type : contentType, responseType: "text" });
+  } catch (error) {
+    throw named(error, `attachment ${n}`);
+  }
+}
+async function uploadEmbeddedImage(transport, asset, data, options = {}) {
+  const blob = data instanceof Blob ? data : new Blob([await toUint8Array(data)], { type: options.contentType ?? "application/octet-stream" });
+  const form = new FormData();
+  form.append("image", blob, options.filename ?? "image");
+  form.append("oidToken", asset);
+  let html;
+  try {
+    html = await transport.request({ method: "POST", path: "/EmbeddedImage.mvc/Upload", body: form, responseType: "text" });
+  } catch (error) {
+    throw named(error, `embedded image for ${asset}`);
+  }
+  const inner = /<textarea[^>]*>([\s\S]*?)<\/textarea>/i.exec(html)?.[1];
+  let payload;
+  try {
+    payload = inner ? JSON.parse(inner.replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&")) : void 0;
+  } catch {
+  }
+  if (!payload || typeof payload.Url !== "string") throw new ApiError("EmbeddedImage.mvc/Upload did not answer with an image URL", 200, "BAD_RESPONSE", html.slice(0, 500));
+  const id = /embedded\.img\/(\d+)/.exec(payload.Url)?.[1] ?? (typeof payload.Key === "string" ? numericId(payload.Key) : void 0);
+  if (!id) throw new ApiError("EmbeddedImage.mvc/Upload answered a URL without an image id", 200, "BAD_RESPONSE", payload);
+  return { oid: typeof payload.Key === "string" ? payload.Key : `EmbeddedImage:${id}`, id, url: payload.Url };
+}
+
+// src/services/attachments.ts
+var INLINE_LIMIT = 1e6;
+var SELECT = ["Name", "Filename", "ContentType", "Description", "CreateDate", "CreatedBy.Name"];
+var infoOf = (r) => {
+  const oid = momentless(r._oid);
+  return { oid, id: numericId(oid), name: r.Name ?? null, filename: r.Filename ?? null, contentType: r.ContentType ?? null, description: r.Description ?? null, createDate: r.CreateDate ?? null, createdBy: r["CreatedBy.Name"] ?? null };
+};
+async function page(transport, asset, options = {}) {
+  const { rows, total, more } = await queryPage(transport, { from: "Attachment", select: SELECT, filter: ["Asset=$asset"], with: { $asset: momentless(asset) }, sort: ["-CreateDate"], page: options.page ?? { size: 50, start: 0 } });
+  return { attachments: rows.map((r) => infoOf(r)), total, more };
+}
+async function list(transport, asset, options = {}) {
+  const rows = await query(transport, { from: "Attachment", select: SELECT, filter: ["Asset=$asset"], with: { $asset: momentless(asset) }, sort: ["-CreateDate"], page: options.page ?? { size: 50, start: 0 } });
+  return rows.map((r) => infoOf(r));
+}
+async function info(transport, id) {
+  const [row] = await query(transport, { from: "Attachment", select: SELECT, filter: ["ID=$id"], with: { $id: `Attachment:${numericId(id)}` }, page: { size: 1, start: 0 } });
+  return row ? infoOf(row) : null;
+}
+async function get(transport, id) {
+  const meta = await info(transport, id);
+  if (!meta) throw new ApiError(`attachment ${numericId(id)}: not found`, 404, "NOT_FOUND");
+  const file = await getFile(transport, meta.id);
+  return { ...meta, bytes: file.bytes, contentType: file.contentType ?? meta.contentType, recordedContentType: meta.contentType };
+}
+var AttachmentUploadError = class extends Error {
+  constructor(attachment, cause) {
+    super(`${attachment.oid} was created on its asset with no content, and uploading the file failed: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.attachment = attachment;
+    this.name = "AttachmentUploadError";
+  }
+  attachment;
+};
+async function add(transport, asset, data, options) {
+  const bytes = await toUint8Array(data);
+  const contentType = options.contentType ?? (typeof Blob !== "undefined" && data instanceof Blob && data.type ? data.type : "application/octet-stream");
+  const inline = bytes.length <= (options.inlineLimit ?? INLINE_LIMIT);
+  const create = { AssetType: "Attachment", Asset: momentless(asset), Name: options.name ?? options.filename, Filename: options.filename, ContentType: contentType, Content: inline ? toBase64(bytes) : "" };
+  if (options.description) create.Description = options.description;
+  const oid = outcomeOf(await send(transport, [create], { throwOnFailure: true })).created[0];
+  const created = { oid, id: numericId(oid), name: String(create.Name), filename: options.filename, contentType, description: options.description ?? null, createDate: null, createdBy: null };
+  if (!inline) {
+    try {
+      await putBytes(transport, created.id, bytes, contentType);
+    } catch (error) {
+      throw new AttachmentUploadError(created, error);
+    }
+  }
+  return created;
+}
+async function put(transport, id, data, contentType) {
+  await putBytes(transport, id, data, contentType);
+}
+async function remove(transport, id) {
+  await send(transport, [{ from: `Attachment:${numericId(id)}`, execute: "Delete" }], { throwOnFailure: true });
+}
+
+// src/services/guard.ts
+var CHUNK = 100;
+var UNGUARDABLE_TYPES = ["Idea", "IdeaChangeSet", "IdeaStatus", "IdeaComment", "IdeaCategory", "IdeaForum", "IdeaUser"];
+var UnguardableError = class extends Error {
+  reasons;
+  constructor(reasons) {
+    super(`cannot guard this batch: ${reasons.map((r) => `command ${r.index}: ${r.reason}`).join("; ")}`);
+    this.name = "UnguardableError";
+    this.reasons = reasons;
+  }
+};
+function aliased(command) {
+  const keys = Object.keys(command);
+  return keys.length === 1 && keys[0].startsWith("@") ? { alias: keys[0], body: command[keys[0]] } : null;
+}
+var bodyOf2 = (c) => aliased(c)?.body ?? c;
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var isCreateValue = (v) => isObject(v) && "AssetType" in v || Array.isArray(v) && v.some(isCreateValue) || isObject(v) && [].concat(v.add ?? []).some(isCreateValue);
+function unguardable(commands) {
+  const out = [];
+  commands.forEach((c, index) => {
+    const a = aliased(c);
+    const body = bodyOf2(c);
+    const writes = "update" in body || "execute" in body;
+    if (a && writes) out.push({ index, reason: `${a.alias} is an aliased ${"update" in body ? "update" : "execute"}: preview does not expand it, so it cannot be read or guarded per asset` });
+    else if (!a && writes && typeof body.from === "string" && body.from.startsWith("@")) out.push({ index, reason: `a bare update or execute from an alias (${body.from}) is rejected by the server; alias the command itself` });
+    if (isObject(body.update) && Object.values(body.update).some(isCreateValue)) out.push({ index, reason: "an update that creates assets inline: the projection normalises the creates away" });
+  });
+  return out;
+}
+function perAsset(projected) {
+  const body = bodyOf2(projected);
+  return typeof body.oid === "string" && ("update" in body || "execute" in body) ? { oid: momentless(body.oid), update: body.update, execute: body.execute } : null;
+}
+var touchedBy = (projected) => [...new Set(projected.flatMap((p) => {
+  const x = perAsset(p);
+  return x ? [x.oid] : [];
+}))];
+var STAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,7})?$/;
+async function stampsOf(transport, oids) {
+  const byType2 = /* @__PURE__ */ new Map();
+  for (const oid of new Set(oids.map(momentless))) {
+    const t = typeOfOid(oid);
+    byType2.set(t, [...byType2.get(t) ?? [], oid]);
+  }
+  const out = {};
+  for (const [type, list3] of byType2) {
+    if (UNGUARDABLE_TYPES.includes(type)) continue;
+    for (let i = 0; i < list3.length; i += CHUNK) {
+      const part = list3.slice(i, i + CHUNK);
+      const rows = await query(transport, { from: type, select: ["ChangeDate"], filter: ["ID=$oids"], with: { $oids: part }, page: { size: part.length, start: 0 } });
+      for (const r of rows) if (r.ChangeDate != null) out[momentless(r._oid)] = String(r.ChangeDate);
+    }
+  }
+  return out;
+}
+function guard(projected, stamps) {
+  const commands = [], unstamped = [];
+  for (const p of projected) {
+    const x = perAsset(p);
+    if (!x) {
+      commands.push(p);
+      continue;
+    }
+    const stamp = stamps[x.oid];
+    if (stamp === void 0) {
+      unstamped.push(x.oid);
+      continue;
+    }
+    if (!STAMP.test(stamp)) throw new Error(`${x.oid}: ChangeDate ${JSON.stringify(stamp)} is not a timestamp; refusing to put it in a filter`);
+    const scope = { from: typeOfOid(x.oid), filter: ["ID=$oid", `ChangeDate='${stamp}'`], with: { $oid: x.oid } };
+    commands.push(x.update ? { ...scope, update: x.update } : { ...scope, execute: x.execute });
+  }
+  return { commands, unstamped };
+}
+function passesOf(projected) {
+  const seen = /* @__PURE__ */ new Map();
+  const passes = [[]];
+  for (const p of projected) {
+    const x = perAsset(p);
+    const k = x ? seen.get(x.oid) ?? 0 : 0;
+    if (x) seen.set(x.oid, k + 1);
+    (passes[k] ??= []).push(p);
+  }
+  return passes;
+}
+var GuardedPassError = class extends Error {
+  constructor(cause, outcome, sent, pass) {
+    super(`guarded send failed in pass ${pass + 1}${pass ? " (earlier passes applied)" : ""}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.cause = cause;
+    this.outcome = outcome;
+    this.sent = sent;
+    this.pass = pass;
+    this.name = "GuardedPassError";
+  }
+  cause;
+  outcome;
+  sent;
+  pass;
+};
+async function sendPasses(transport, projected, stamps, options = {}) {
+  const passes = passesOf(projected);
+  const outcome = emptyOutcome();
+  const sent = [], unstamped = [];
+  let applied = /* @__PURE__ */ new Set();
+  for (const [k, pass] of passes.entries()) {
+    let current;
+    if (k === 0) current = guard(pass, stamps);
+    else {
+      const eligible = pass.filter((p) => applied.has(perAsset(p).oid));
+      current = guard(eligible, await stampsOf(transport, eligible.map((p) => perAsset(p).oid)));
+    }
+    const commands = current.commands;
+    unstamped.push(...current.unstamped);
+    if (!commands.length) break;
+    const offset = sent.length;
+    let done;
+    try {
+      const creates = commands.some((c) => "AssetType" in bodyOf2(c));
+      done = outcomeOf(await send(transport, commands, { ...options, idempotent: !creates }));
+    } catch (error) {
+      if (k === 0) throw error;
+      throw new GuardedPassError(error, outcome, sent, k);
+    }
+    sent.push(...commands);
+    mergeOutcome(outcome, done, offset);
+    applied = new Set([...done.modified, ...done.operated].map(momentless));
+  }
+  return { outcome, sent, unstamped: [...new Set(unstamped)] };
+}
+async function sendGuarded(transport, commands, options = {}) {
+  const refused = unguardable(commands);
+  if (refused.length) throw new UnguardableError(refused);
+  const projected = await preview(transport, commands);
+  const touched = touchedBy(projected);
+  const ideas = touched.filter((oid) => UNGUARDABLE_TYPES.includes(typeOfOid(oid)));
+  if (ideas.length) throw new UnguardableError(ideas.map((oid) => ({ index: -1, reason: `${oid}: ${typeOfOid(oid)} has no ChangeDate` })));
+  const stamps = await stampsOf(transport, touched);
+  const { outcome, sent, unstamped } = await sendPasses(transport, projected, stamps, options);
+  const done = /* @__PURE__ */ new Set([...outcome.modified, ...outcome.operated]);
+  return { outcome, projected, sent, touched, stamps, skipped: [.../* @__PURE__ */ new Set([...unstamped, ...touched.filter((oid) => !done.has(oid))])] };
+}
+
+// src/services/batch.ts
+var CHUNK2 = 100;
+var bodyOf3 = (c) => aliased(c)?.body ?? c;
+function describe(commands, projected) {
+  const out = { creates: [], queries: [], updates: [], executes: [], deferred: [] };
+  commands.forEach((c, index) => {
+    const a = aliased(c), body = bodyOf3(c);
+    if (a && typeof body.from === "string" && ("update" in body || "execute" in body)) out.deferred.push({ index, alias: a.alias, from: body.from, kind: "update" in body ? "update" : "execute" });
+    else if (typeof body.AssetType === "string") out.creates.push({ index, alias: a?.alias ?? null, type: body.AssetType, name: typeof body.Name === "string" ? body.Name : null });
+    else if (typeof body.from === "string" && !("update" in body) && !("execute" in body)) out.queries.push({ index, from: body.from });
+  });
+  for (const p of projected) {
+    const body = bodyOf3(p);
+    if (typeof body.oid !== "string") continue;
+    const oid = momentless(body.oid);
+    if (body.update && typeof body.update === "object") out.updates.push({ oid, attributes: body.update });
+    else if (body.execute !== void 0) {
+      const e = body.execute;
+      out.executes.push({ oid, op: typeof e === "string" ? e : e.op, args: typeof e === "string" ? {} : e.args ?? {} });
+    }
+  }
+  return out;
+}
+var byType = (oids) => {
+  const out = /* @__PURE__ */ new Map();
+  for (const oid of new Set([...oids].map(momentless))) out.set(typeOfOid(oid), [...out.get(typeOfOid(oid)) ?? [], oid]);
+  return out;
+};
+var chunks = (list3) => Array.from({ length: Math.ceil(list3.length / CHUNK2) }, (_, i) => list3.slice(i * CHUNK2, (i + 1) * CHUNK2));
+var plain = (v) => Array.isArray(v) ? v.map(plain) : v && typeof v === "object" && "_oid" in v ? momentless(String(v._oid)) : v ?? null;
+async function namesOf(transport, schema, oids, onFailure) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [type, list3] of byType(oids)) {
+    let select;
+    try {
+      await schema.load(type);
+      select = ["Name", "Number"].filter((a) => schema.attribute(type, a));
+    } catch (error) {
+      onFailure?.({ type, oids: list3, error });
+      continue;
+    }
+    if (!select.length) continue;
+    for (const part of chunks(list3)) {
+      try {
+        const rows = await query(transport, { from: type, select, filter: ["ID=$oids"], with: { $oids: part }, page: { size: part.length, start: 0 } });
+        for (const r of rows) out.set(momentless(r._oid), { number: r.Number ?? null, name: r.Name ?? null });
+      } catch (error) {
+        onFailure?.({ type, oids: part, error });
+      }
+    }
+  }
+  return out;
+}
+async function snapshot(transport, described) {
+  const wanted = /* @__PURE__ */ new Map();
+  const want = (oid, attrs) => {
+    const s = wanted.get(oid) ?? /* @__PURE__ */ new Set();
+    attrs.forEach((a) => s.add(a));
+    wanted.set(oid, s);
+  };
+  for (const u of described.updates) want(u.oid, [...Object.keys(u.attributes), "ChangeDate"]);
+  for (const e of described.executes) want(e.oid, ["AssetState", "ChangeDate"]);
+  const before = {};
+  for (const [type, oids] of byType(wanted.keys())) {
+    const select = [...new Set(oids.flatMap((o) => [...wanted.get(o)]))];
+    for (const part of chunks(oids)) {
+      const rows = await query(transport, { from: type, select, filter: ["ID=$oids"], with: { $oids: part }, page: { size: part.length, start: 0 } });
+      for (const r of rows) {
+        const oid = momentless(r._oid), row = r;
+        before[oid] = Object.fromEntries([...wanted.get(oid)].map((a) => [a, plain(row[a])]));
+      }
+    }
+  }
+  return before;
+}
+var INVERSE = { Inactivate: "Reactivate", QuickClose: "Reactivate", Reactivate: "Inactivate", Delete: "Undelete", Undelete: "Delete" };
+var CASCADING = /* @__PURE__ */ new Set(["Inactivate", "QuickClose"]);
+var CASCADE_DEPTH = 8;
+async function openDescendantsOf(transport, schema, roots) {
+  const out = {};
+  const rootOf = new Map(roots.map((r) => [momentless(r), momentless(r)]));
+  const seen = new Set(rootOf.keys());
+  let frontier = [...rootOf.keys()];
+  for (let depth = 0; depth < CASCADE_DEPTH && frontier.length; depth += 1) {
+    const children = /* @__PURE__ */ new Map();
+    for (const [type, list3] of byType(frontier)) {
+      await schema.load(type);
+      if (!schema.attribute(type, "Children")) continue;
+      for (const part of chunks(list3)) {
+        const rows = await query(transport, { from: type, select: ["Children"], filter: ["ID=$oids"], with: { $oids: part }, page: { size: part.length, start: 0 } });
+        for (const r of rows) {
+          const parent = momentless(r._oid);
+          for (const c of [].concat(plain(r.Children) ?? [])) {
+            const child = momentless(String(c));
+            if (seen.has(child)) continue;
+            seen.add(child);
+            children.set(child, rootOf.get(parent));
+          }
+        }
+      }
+    }
+    const states = children.size ? await statesOf(transport, [...children.keys()]) : {};
+    frontier = [];
+    for (const [child, root] of children) {
+      if (states[child] === void 0 || isClosed(states[child])) continue;
+      rootOf.set(child, root);
+      (out[root] ??= []).push(child);
+      frontier.push(child);
+    }
+  }
+  return out;
+}
+function reverseOf(described, before, done, context = {}) {
+  const commands = [], notes = [];
+  const cannot = (oid, op) => context.canOperate?.(typeOfOid(oid), op) === false;
+  const modified = new Set(done.modified.map(momentless)), operated = new Set(done.operated.map(momentless));
+  for (const u of described.updates) {
+    if (!modified.has(u.oid)) continue;
+    const was = before[u.oid];
+    if (!was) {
+      notes.push(`${u.oid}: no snapshot, cannot restore`);
+      continue;
+    }
+    const update = {};
+    for (const [attr, change] of Object.entries(u.attributes)) {
+      const prior = was[attr];
+      const c = change && typeof change === "object" && !Array.isArray(change) ? change : {};
+      const add2 = [].concat(c.add ?? []), remove2 = [].concat(c.remove ?? []);
+      if (Array.isArray(prior)) {
+        const added = add2.filter((v) => !prior.includes(v)), removed = remove2.filter((v) => prior.includes(v));
+        if (added.length || removed.length) update[attr] = { add: removed, remove: added };
+      } else if (prior === void 0) notes.push(`${u.oid}.${attr}: not in snapshot, cannot restore`);
+      else update[attr] = prior;
+    }
+    if (Object.keys(update).length) commands.push({ from: u.oid, update });
+  }
+  for (const e of described.executes) {
+    if (!operated.has(e.oid)) continue;
+    const inverse = INVERSE[e.op];
+    if (!inverse) {
+      notes.push(`${e.oid}: ${e.op} has no known inverse (was ${String(before[e.oid]?.AssetState ?? "?")})`);
+      continue;
+    }
+    if (cannot(e.oid, inverse)) {
+      notes.push(`${e.oid}: ${typeOfOid(e.oid)} has no ${inverse} operation, so its ${e.op} is not reversed`);
+      continue;
+    }
+    commands.push({ from: e.oid, execute: inverse });
+    if (!CASCADING.has(e.op)) continue;
+    const open = context.openDescendants?.[e.oid] ?? [];
+    const closed = context.cascaded ? context.cascaded[e.oid] ?? [] : void 0;
+    if (closed === void 0) {
+      if (open.length) notes.push(`${e.oid}: ${e.op} may also have closed ${open.length} open descendant${open.length === 1 ? "" : "s"} (${open.join(", ")}); they could not be read back, so they are not reopened`);
+      continue;
+    }
+    for (const d of closed) {
+      if (cannot(d, "Reactivate")) notes.push(`${d}: closed with ${e.oid}, but ${typeOfOid(d)} has no Reactivate operation`);
+      else commands.push({ from: d, execute: "Reactivate" });
+    }
+    if (closed.length) notes.push(`${e.oid}: ${e.op} also closed ${closed.join(", ")}; reopened after it`);
+  }
+  for (const oid of [...done.created].reverse().map(momentless)) {
+    if (cannot(oid, "Delete")) notes.push(`${oid}: ${typeOfOid(oid)} has no Delete operation, so it is not deleted${typeOfOid(oid) === "Conversation" ? " (the server removes a Conversation once its last Expression is deleted)" : ""}`);
+    else commands.push({ from: oid, execute: "Delete" });
+  }
+  for (const d of described.deferred ?? []) notes.push(`command ${d.index} (${d.alias}): an aliased ${d.kind} of ${d.from}, sent as written with no snapshot; not reversed`);
+  if (commands.length) notes.unshift("restores the state recorded at snapshotAt; anything that changed between then and sentAt is not reflected, and a scalar restored to null is cleared, not unset");
+  return { commands, notes };
+}
+var BatchRecordError = class extends Error {
+  receipt;
+  constructor(cause, receipt) {
+    super(`the batch was sent and its outcome recorded, but reading the assets back afterwards failed, so receipt.after is incomplete: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.name = "BatchRecordError";
+    this.receipt = receipt;
+  }
+};
+var BatchSendError = class extends Error {
+  receipt;
+  constructor(cause, receipt) {
+    super(`the batch send failed; whether the server applied it is unknown: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.name = "BatchSendError";
+    this.receipt = receipt;
+  }
+};
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+async function runBatch(transport, schema, commands, options = {}) {
+  const useGuard = options.guard ?? true;
+  if (!commands.length) throw new Error("the batch is empty");
+  const refused = unguardable(commands);
+  const fatal = refused.filter((r) => r.reason.includes("rejected by the server"));
+  if (fatal.length || useGuard && refused.length) throw new UnguardableError(useGuard ? refused : fatal);
+  const notes = [];
+  const noteFailure = ({ type, oids, error }) => notes.push(`could not look up Name for ${oids.length} ${type} asset${oids.length === 1 ? "" : "s"}: ${error instanceof Error ? error.message : String(error)}`);
+  const previewedAt = now();
+  const projected = await preview(transport, commands);
+  const described = describe(commands, projected);
+  const touched = touchedBy(projected);
+  const names = await namesOf(transport, schema, touched, noteFailure);
+  const receipt = { receipt: 1, request: commands, previewedAt, preview: projected, described, names: Object.fromEntries(names), before: {}, sent: false, guarded: false, created: [], touched: [], after: {}, skipped: [], failed: [], openDescendants: {}, cascaded: {}, reverse: { commands: [], notes: [] }, notes };
+  const nothing = !described.creates.length && !described.updates.length && !described.executes.length && !described.queries.length && !described.deferred.length;
+  if (nothing) return receipt;
+  for (const d of described.deferred) notes.push(`command ${d.index} (${d.alias}): an aliased ${d.kind}, which preview does not expand; sent as written, not snapshotted, not reversible`);
+  receipt.snapshotAt = now();
+  receipt.before = await snapshot(transport, described);
+  const closing = described.executes.filter((e) => CASCADING.has(e.op)).map((e) => e.oid);
+  if (closing.length) receipt.openDescendants = await openDescendantsOf(transport, schema, closing);
+  if (options.dryRun) return receipt;
+  if (options.confirm && !await options.confirm(receipt)) return receipt;
+  let unstamped = [];
+  receipt.guarded = useGuard;
+  receipt.sentAt = now();
+  let done;
+  try {
+    if (useGuard) {
+      const stamps = Object.fromEntries(Object.entries(receipt.before).flatMap(([oid, v]) => typeof v.ChangeDate === "string" ? [[oid, v.ChangeDate]] : []));
+      receipt.sentCommands = guard(passesOf(projected)[0], stamps).commands;
+      const result = await sendPasses(transport, projected, stamps);
+      ({ outcome: done, unstamped } = result);
+      receipt.sentCommands = result.sent;
+    } else {
+      receipt.sentCommands = commands;
+      done = outcomeOf(await send(transport, commands));
+    }
+  } catch (error) {
+    if (error instanceof GuardedPassError) {
+      receipt.sent = true;
+      receipt.outcome = error.outcome;
+      receipt.sentCommands = error.sent;
+    }
+    throw new BatchSendError(error, receipt);
+  }
+  receipt.sent = true;
+  receipt.outcome = done;
+  const hit = [.../* @__PURE__ */ new Set([...done.modified, ...done.operated])];
+  const unnamed = { number: null, name: null };
+  receipt.created = done.created.map((oid, i) => ({ alias: described.creates[i]?.alias ?? null, type: described.creates[i]?.type ?? typeOfOid(oid), oid, ...unnamed }));
+  receipt.touched = hit.map((oid) => ({ oid, ...names.get(oid) ?? unnamed }));
+  const sentAs = receipt.sentCommands ?? [];
+  const oidOfSent = (i) => {
+    const body = i === null ? void 0 : sentAs[i] ? bodyOf3(sentAs[i]) : void 0;
+    const id = body?.with?.$oid ?? body?.from;
+    return typeof id === "string" && id.includes(":") ? momentless(id) : null;
+  };
+  receipt.failed = [...new Set(done.failures.map((f) => oidOfSent(f.index)).filter((oid) => !!oid && touched.includes(oid) && !hit.includes(oid)))];
+  receipt.skipped = useGuard ? [.../* @__PURE__ */ new Set([...unstamped, ...touched.filter((oid) => !hit.includes(oid) && !receipt.failed.includes(oid))])] : [];
+  for (const type of new Set([...done.created, ...hit].map((oid) => typeOfOid(momentless(oid))))) await schema.load(type).catch(() => null);
+  const canOperate = (type, op) => schema.canOperate(type, op);
+  const operatedNow = new Set(done.operated.map(momentless));
+  const closed = Object.keys(receipt.openDescendants).filter((oid) => operatedNow.has(oid) && receipt.openDescendants[oid].length);
+  receipt.reverse = reverseOf(described, receipt.before, done, { openDescendants: receipt.openDescendants, cascaded: closed.length ? void 0 : {}, canOperate });
+  try {
+    if (closed.length) {
+      const states = await statesOf(transport, closed.flatMap((oid) => receipt.openDescendants[oid]));
+      receipt.cascaded = Object.fromEntries(closed.map((oid) => [oid, receipt.openDescendants[oid].filter((d) => isClosed(states[d]))]));
+      receipt.reverse = reverseOf(described, receipt.before, done, { openDescendants: receipt.openDescendants, cascaded: receipt.cascaded, canOperate });
+    }
+    const more = await namesOf(transport, schema, [...done.created, ...hit.filter((oid) => !names.has(oid))], noteFailure);
+    receipt.created = receipt.created.map((c) => ({ ...c, ...more.get(c.oid) ?? unnamed }));
+    receipt.touched = receipt.touched.map((t) => names.has(t.oid) ? t : { ...t, ...more.get(t.oid) ?? unnamed });
+    const all = [.../* @__PURE__ */ new Set([...done.created, ...hit, ...Object.values(receipt.cascaded).flat()])];
+    receipt.after = all.length ? await stampsOf(transport, all) : {};
+  } catch (error) {
+    throw new BatchRecordError(error, receipt);
+  }
+  return receipt;
+}
+async function statesOf(transport, oids) {
+  const out = {};
+  for (const [type, list3] of byType(oids)) {
+    for (const part of chunks(list3)) {
+      const rows = await query(transport, { from: type, select: ["AssetState"], filter: ["ID=$oids"], with: { $oids: part }, page: { size: part.length, start: 0 } });
+      for (const r of rows) if (r.AssetState != null) out[momentless(r._oid)] = String(r.AssetState);
+    }
+  }
+  return out;
+}
+var isClosed = (state) => state === "Closed" || state === "128";
+async function reversible(transport, receipt, options = {}) {
+  const targets = receipt.reverse.commands.map((c) => momentless(String(bodyOf3(c).from)));
+  const now2 = await stampsOf(transport, targets.filter((oid) => receipt.after[oid] !== void 0));
+  const drifted = targets.flatMap((oid) => receipt.after[oid] !== void 0 && now2[oid] !== receipt.after[oid] ? [{ oid, was: receipt.after[oid], now: now2[oid] ?? null }] : []);
+  const skip = new Set(options.force ? [] : drifted.map((d) => d.oid));
+  const kept = receipt.reverse.commands.filter((c) => !skip.has(momentless(String(bodyOf3(c).from))));
+  const deletes = kept.flatMap((c) => bodyOf3(c).execute === "Delete" ? [momentless(String(bodyOf3(c).from))] : []);
+  const states = deletes.length ? await statesOf(transport, deletes) : {};
+  const reactivated = deletes.filter((oid) => isClosed(states[oid]));
+  const commands = kept.flatMap((c) => {
+    const body = bodyOf3(c), oid = momentless(String(body.from));
+    return body.execute === "Delete" && reactivated.includes(oid) ? [{ from: oid, execute: "Reactivate" }, c] : [c];
+  });
+  return { commands, drifted, reactivated };
+}
+
+// src/types/asset.ts
+var ASSET_STATE_CODES = { Future: 0, Active: 64, Closed: 128, Dead: 192, Template: 200, OldBrokenDownStory: 208, Deprecated: 254, Deleted: 255 };
+var STATE_OF_CODE = Object.fromEntries(Object.entries(ASSET_STATE_CODES).map(([name, code]) => [code, name]));
+function assetStateOf(value) {
+  if (value == null) return null;
+  const code = typeof value === "number" ? value : typeof value === "string" && /^\d+$/.test(value) ? Number(value) : NaN;
+  return Number.isNaN(code) ? String(value) : STATE_OF_CODE[code] ?? String(value);
+}
+
+// src/services/resolve.ts
+var NUMBER_ROOTS = {
+  Environment: ["Number", "Name", "AssetState"],
+  ExternalActionInvocation: ["Number"],
+  Goal: ["Number", "Name", "AssetState"],
+  Grant: ["Number", "AssetState"],
+  Issue: ["Number", "Name", "AssetState"],
+  Milestone: ["Number", "Name", "AssetState"],
+  Okr: ["Number", "Name", "AssetState"],
+  OkrSession: ["Number", "Name", "AssetState"],
+  RegressionPlan: ["Number", "Name", "AssetState"],
+  RegressionSuite: ["Number", "Name", "AssetState"],
+  RegressionTest: ["Number", "Name", "AssetState"],
+  Request: ["Number", "Name", "AssetState"],
+  Roadmap: ["Number", "Name", "AssetState"],
+  StrategicTheme: ["Number", "Name", "AssetState"],
+  Topic: ["Number", "Name", "AssetState"],
+  Workitem: ["Number", "Name", "AssetState"]
+};
+var isAssetNumber = (text) => /^[A-Za-z]+-\d+$/.test(text.trim());
+var CHUNK3 = 100;
+var absentRoots = /* @__PURE__ */ new WeakMap();
+var absentFor = (transport, types) => {
+  if (types) return { has: (root) => types.types.get(root) === null, add: (root) => {
+    types.types.set(root, null);
+  } };
+  const set = absentRoots.get(transport) ?? /* @__PURE__ */ new Set();
+  absentRoots.set(transport, set);
+  return set;
+};
+var UNKNOWN_TYPE = /^Unknown AssetType: (\S+)/;
+async function askRoots(transport, numbers, types) {
+  const absent = absentFor(transport, types);
+  for (let attempt = 0; ; attempt += 1) {
+    const roots = Object.keys(NUMBER_ROOTS).filter((r) => !absent.has(r));
+    try {
+      const results = await queries(transport, roots.map((from) => ({
+        from,
+        select: [...NUMBER_ROOTS[from]],
+        filter: ["Number=$numbers"],
+        with: { $numbers: numbers },
+        page: { size: numbers.length, start: 0 }
+      })));
+      return results.flat();
+    } catch (error) {
+      const unknown = error instanceof CommandFailureError ? error.failures.map((f) => UNKNOWN_TYPE.exec(f.message)?.[1]) : [];
+      if (attempt > 0 || !unknown.length || unknown.some((t) => !t || !roots.includes(t))) throw error;
+      for (const t of unknown) absent.add(t);
+    }
+  }
+}
+async function resolveNumbers(transport, numbers, options = {}) {
+  const firsts = /* @__PURE__ */ new Map();
+  for (const n of numbers) if (!firsts.has(n.trim().toUpperCase())) firsts.set(n.trim().toUpperCase(), n.trim());
+  const asked = [...firsts.values()];
+  const invalid = asked.filter((n) => !isAssetNumber(n));
+  if (invalid.length) throw new TypeError(`not asset numbers (expected a prefix and digits, S-1234): ${invalid.join(", ")}`);
+  const byNumber = /* @__PURE__ */ new Map();
+  for (let i = 0; i < asked.length; i += CHUNK3) {
+    for (const r of await askRoots(transport, asked.slice(i, i + CHUNK3), options.types)) {
+      if (!r.Number || byNumber.has(r.Number.toUpperCase())) continue;
+      const oid = momentless(r._oid);
+      byNumber.set(r.Number.toUpperCase(), { number: r.Number, oid, type: typeOfOid(oid), name: r.Name ?? null, assetState: assetStateOf(r.AssetState) });
+    }
+  }
+  return {
+    found: asked.flatMap((n) => byNumber.get(n.toUpperCase()) ?? []),
+    missing: asked.filter((n) => !byNumber.has(n.toUpperCase()))
+  };
+}
+async function resolveRef(transport, spec, options = {}) {
+  const text = spec.trim();
+  if (isOidToken(text)) {
+    const oid = momentless(text);
+    return { number: null, oid, type: typeOfOid(oid), name: null, assetState: null };
+  }
+  if (isAssetNumber(text)) return (await resolveNumbers(transport, [text], options)).found[0] ?? null;
+  throw new TypeError(`"${spec}" is neither an asset number (S-1234) nor an OID token (Story:1234)`);
+}
+
+// src/wire/meta.ts
+var meta_exports = {};
+__export(meta_exports, {
+  getAssetType: () => getAssetType,
+  getAttributeDefinition: () => getAttributeDefinition,
+  getMetamodel: () => getMetamodel,
+  isMetamodelDocument: () => isMetamodelDocument,
+  toAssetType: () => toAssetType,
+  toAttributeDefinition: () => toAttributeDefinition,
+  toMetamodel: () => toMetamodel
+});
+function toAttributeDefinition(doc) {
+  return {
+    _type: "AttributeDefinition",
+    Name: doc.Name,
+    Token: doc.Token,
+    DisplayName: doc.DisplayName,
+    AttributeType: doc.AttributeType,
+    IsReadOnly: doc.IsReadOnly,
+    IsRequired: doc.IsRequired,
+    IsMultivalue: doc.IsMultivalue,
+    IsCanned: doc.IsCanned,
+    IsCustom: doc.IsCustom,
+    ...doc.Base ? { Base: doc.Base.tokenref } : {},
+    ...doc.ReciprocalRelation ? { ReciprocalRelation: doc.ReciprocalRelation.tokenref } : {},
+    ...doc.OrderByAttribute ? { OrderByAttribute: doc.OrderByAttribute.tokenref } : {},
+    ...doc.DisplayByAttribute ? { DisplayByAttribute: doc.DisplayByAttribute.tokenref } : {},
+    ...doc.RelatedAsset ? { RelatedAsset: doc.RelatedAsset.nameref } : {}
+  };
+}
+function toAssetType(doc) {
+  return {
+    _type: "AssetType",
+    Name: doc.Token,
+    Token: doc.Token,
+    DisplayName: doc.DisplayName,
+    Abstract: doc.Abstract,
+    ...doc.Base ? { Base: doc.Base.nameref } : {},
+    ...doc.DefaultOrderBy ? { DefaultOrderBy: doc.DefaultOrderBy.tokenref } : {},
+    ...doc.DefaultDisplayBy ? { DefaultDisplayBy: doc.DefaultDisplayBy.tokenref } : {},
+    ...doc.ShortName ? { ShortName: doc.ShortName.tokenref } : {},
+    Attributes: Object.fromEntries(Object.entries(doc.Attributes ?? {}).map(([key, value]) => [key, toAttributeDefinition(value)])),
+    ...doc.Operations ? { Operations: Object.keys(doc.Operations).map((token) => token.slice(token.indexOf(".") + 1)) } : {}
+  };
+}
+function toMetamodel(doc) {
+  return { Version: doc.Version, AssetTypes: Object.fromEntries(Object.entries(doc.AssetTypes).map(([key, value]) => [key, toAssetType(value)])) };
+}
+function isMetamodelDocument(value) {
+  return !!value && typeof value === "object" && typeof value.Version === "string" && !!value.AssetTypes && typeof value.AssetTypes === "object";
+}
+async function getMetamodel(transport) {
+  return toMetamodel(await transport.request({ method: "GET", path: "/meta.v1", responseType: "json" }));
+}
+async function getAssetType(transport, token) {
+  return toAssetType(await transport.request({ method: "GET", path: `/meta.v1/${encodeURIComponent(token)}`, responseType: "json" }));
+}
+async function getAttributeDefinition(transport, tokenref) {
+  const [type, attribute] = tokenref.split(".");
+  if (!type || !attribute) throw new Error(`"${tokenref}" is not an attribute token ("Story.Name")`);
+  return toAttributeDefinition(await transport.request({ method: "GET", path: `/meta.v1/${encodeURIComponent(type)}/${encodeURIComponent(attribute)}`, responseType: "json" }));
+}
+
+// src/services/schema.ts
+var TypeCache = class _TypeCache {
+  /** Loaded types; null records that the instance has no such type, so it is not asked for again. */
+  types = /* @__PURE__ */ new Map();
+  loading = /* @__PURE__ */ new Map();
+  /** A cache seeded from a metamodel document. */
+  static fromMetamodel(metamodel) {
+    const cache = new _TypeCache();
+    for (const [token, type] of Object.entries(metamodel.AssetTypes)) cache.types.set(token, type);
+    return cache;
+  }
+};
+var Schema = class _Schema {
+  constructor(transport, seed, cache = new TypeCache()) {
+    this.transport = transport;
+    this.cache = cache;
+    this.types = cache.types;
+    this.loading = cache.loading;
+    if (seed) {
+      for (const [token, type] of Object.entries(seed.AssetTypes)) if (!this.types.has(token)) this.types.set(token, type);
+    }
+  }
+  transport;
+  types;
+  loading;
+  /** Where this schema keeps what it loads; pass it to another schema to share it. */
+  cache;
+  /** The same cache, loading anything missing through another transport (another user's credentials). */
+  withTransport(transport) {
+    return new _Schema(transport, void 0, this.cache);
+  }
+  /** A complete schema from a metamodel document; nothing is ever fetched. */
+  static fromMetamodel(metamodel) {
+    return new _Schema(void 0, metamodel);
+  }
+  /** The type, null when the instance has none, undefined when not loaded yet. */
+  assetType(token) {
+    return this.types.has(token) ? this.types.get(token) : void 0;
+  }
+  /** An attribute by bare name; undefined when the type is not loaded, null when it has no such attribute. */
+  attribute(type, name) {
+    return attributeOf(this, type, name);
+  }
+  /**
+   * Can the type do this operation (Delete, Reactivate, …)? Undefined when
+   * the type is not loaded or its definition carries no operations, so a
+   * caller can tell "no" from "don't know".
+   */
+  canOperate(type, op) {
+    const t = this.assetType(type);
+    return t?.Operations ? t.Operations.includes(op) : void 0;
+  }
+  /** The tokens loaded so far. */
+  get loaded() {
+    return [...this.types.entries()].filter(([, t]) => t !== null).map(([token]) => token);
+  }
+  /**
+   * Load one type from meta.v1 (once; concurrent callers share the request).
+   * A type the instance does not have resolves to null and is remembered;
+   * any other failure (auth, network) is thrown, not swallowed.
+   */
+  async load(token) {
+    if (this.types.has(token)) return this.types.get(token);
+    const inFlight = this.loading.get(token);
+    if (inFlight) return inFlight;
+    if (!this.transport) {
+      this.types.set(token, null);
+      return null;
+    }
+    const request = getAssetType(this.transport, token).catch((error) => {
+      if (error instanceof ApiError && error.status === 404) return null;
+      throw error;
+    }).then((type) => {
+      this.types.set(token, type);
+      return type;
+    }).finally(() => this.loading.delete(token));
+    this.loading.set(token, request);
+    return request;
+  }
+  /**
+   * Load whatever the queries in a batch need to have their rows translated:
+   * the `from` types, then the types behind every relation hop and sub-select,
+   * until nothing more is needed. Non-query commands are ignored.
+   */
+  async ensureFor(commands) {
+    for (const command of commands) {
+      const query3 = queryOf(command);
+      if (!query3) continue;
+      const type = fromTypeOf(query3.from, commands);
+      if (!type) continue;
+      for (let round = 0; round < 32; round += 1) {
+        const needed = [...typesNeeded(this, query3, type)].filter((t) => !this.types.has(t));
+        if (!needed.length) break;
+        await Promise.all(needed.map((t) => this.load(t)));
+      }
+    }
+  }
+};
+function queryOf(command) {
+  if (!command || typeof command !== "object") return null;
+  const keys = Object.keys(command);
+  const body = keys.length === 1 && keys[0].startsWith("@") ? command[keys[0]] : command;
+  if (!body || typeof body !== "object" || typeof body.from !== "string") return null;
+  if ("update" in body || "execute" in body || "AssetType" in body) return null;
+  return body;
+}
+
+// src/wire/loc2.ts
+var loc2_exports = {};
+__export(loc2_exports, {
+  DEFAULT_MAX_GET_LENGTH: () => DEFAULT_MAX_GET_LENGTH,
+  localize: () => localize,
+  localizeOne: () => localizeOne,
+  toLson: () => toLson
+});
+var DEFAULT_MAX_GET_LENGTH = 2e3;
+var toLson = (tags) => JSON.stringify(tags);
+async function localize(transport, tags, options = {}) {
+  const unique = [...new Set(tags)];
+  if (!unique.length) return {};
+  const encoded = encodeURIComponent(toLson(unique));
+  const headers = options.culture ? { "Accept-Language": options.culture } : void 0;
+  const result = encoded.length <= (options.maxGetLength ?? DEFAULT_MAX_GET_LENGTH) ? await transport.request({ method: "GET", path: `/loc-2.v1?${encoded}`, headers, responseType: "json" }) : await transport.request({ method: "POST", path: "/loc-2.v1", headers, body: encoded, contentType: "application/x-www-form-urlencoded", responseType: "json", idempotent: true });
+  if (!result || typeof result !== "object" || Array.isArray(result)) throw new Error(`loc-2.v1 answered an array of tags with ${JSON.stringify(result)?.slice(0, 100)}, not an object`);
+  return result;
+}
+async function localizeOne(transport, tag, options = {}) {
+  const map = await localize(transport, [tag], options);
+  return map[tag] ?? tag;
+}
+
+// src/wire/queryV1.ts
+var queryV1_exports = {};
+__export(queryV1_exports, {
+  queries: () => queries2,
+  query: () => query2
+});
+function rejected(error) {
+  const details = error.details;
+  const messages = (details?.exceptions ?? []).map((e) => e?.message).filter((m) => typeof m === "string" && !!m);
+  return messages.length ? new ApiError(messages.join("; "), error.status, "QUERY_REJECTED", error.details) : error;
+}
+async function queries2(transport, qs, options = {}) {
+  for (const q of qs) if (!q.page) throw new Error(`query of ${q.from} without a page: every query.v1 read must be bounded`);
+  if (!qs.length) return [];
+  let response;
+  try {
+    response = await transport.request({ method: "POST", path: "/query.v1", body: qs, responseType: "json", idempotent: true });
+  } catch (error) {
+    throw error instanceof ApiError && error.status === 400 ? rejected(error) : error;
+  }
+  if (!Array.isArray(response) || response.length !== qs.length || !response.every(Array.isArray)) {
+    throw new ApiError(`query.v1 answered with ${Array.isArray(response) ? `${response.length} results` : "no result list"} for ${qs.length} queries`, 200, "BAD_RESPONSE", response);
+  }
+  return qs.map((q, i) => {
+    const type = options.lookup ? fromTypeOf(q.from, qs) : null;
+    const context = type ? { lookup: options.lookup, type } : void 0;
+    return response[i].map((row) => fromWireRow(row, context));
+  });
+}
+async function query2(transport, q, options = {}) {
+  const [rows] = await queries2(transport, [q], options);
+  return rows ?? [];
+}
+
+// src/wire/rest1.ts
+var rest1_exports = {};
+__export(rest1_exports, {
+  fromAssetDocument: () => fromAssetDocument,
+  get: () => get2,
+  history: () => history,
+  list: () => list2,
+  momentless: () => momentless,
+  toQuery: () => toQuery
+});
+var toRef = (doc) => ({ _oid: momentless(doc.idref) });
+function fromAssetDocument(doc, { history: history2 = false } = {}) {
+  const out = { _oid: history2 ? doc.id : momentless(doc.id) };
+  const attrs = doc.Attributes ?? {};
+  for (const [key, a] of Object.entries(attrs)) {
+    if (a._type === "Relation") {
+      out[key] = Array.isArray(a.value) ? a.value.map(toRef) : a.value ? toRef(a.value) : null;
+    } else if (key === "AssetState" && typeof a.value === "number") {
+      out[key] = assetStateOf(a.value);
+    } else {
+      out[key] = a.value;
+    }
+  }
+  for (const [key, a] of Object.entries(attrs)) {
+    const dot = key.indexOf(".");
+    if (dot < 0 || a._type !== "Attribute") continue;
+    const rel = key.slice(0, dot), attr = key.slice(dot + 1);
+    if (attr.includes(".")) continue;
+    const target = out[rel];
+    const values = a.value;
+    if (Array.isArray(target) && Array.isArray(values)) target.forEach((ref, i) => {
+      if (ref && typeof ref === "object") ref[attr] = values[i];
+    });
+    else if (target && typeof target === "object" && !Array.isArray(target) && !Array.isArray(a.value)) target[attr] = a.value;
+  }
+  return out;
+}
+function toQuery(params) {
+  return {
+    sel: params.sel?.join(","),
+    where: params.where?.length ? params.where.join(";") : void 0,
+    with: params.with ? Object.entries(params.with).map(([k, v]) => `${k}=${[].concat(v).join(",")}`).join("|") : void 0,
+    find: params.find,
+    findin: params.findin?.join(","),
+    sort: params.sort?.join(","),
+    page: `${params.page.size},${params.page.start}`,
+    deleted: params.deleted === void 0 ? void 0 : String(params.deleted),
+    needTotal: params.needTotal === void 0 ? void 0 : String(params.needTotal),
+    asof: params.asof
+  };
+}
+async function read(transport, path, params, history2) {
+  if (!params.page) throw new Error(`rest-1 read of ${path} without a page: every read must be bounded`);
+  const doc = await transport.request({ method: "GET", path, query: toQuery(params), responseType: "json" });
+  return { rows: (doc.Assets ?? []).map((a) => fromAssetDocument(a, { history: history2 })), total: typeof doc.total === "number" && doc.total >= 0 ? doc.total : null, pageSize: doc.pageSize, pageStart: doc.pageStart };
+}
+var list2 = (transport, type, params) => read(transport, `/rest-1.v1/Data/${encodeURIComponent(type)}`, params, false);
+async function get2(transport, oid, sel) {
+  const [type, id] = momentless(oid).split(":");
+  const doc = await transport.request({ method: "GET", path: `/rest-1.v1/Data/${encodeURIComponent(type)}/${encodeURIComponent(id)}`, query: { sel: sel?.join(",") }, responseType: "json" });
+  return fromAssetDocument(doc);
+}
+var history = (transport, target, params) => {
+  const [type, id] = target.split(":");
+  const path = id ? `/rest-1.v1/Hist/${encodeURIComponent(type)}/${encodeURIComponent(id)}` : `/rest-1.v1/Hist/${encodeURIComponent(type)}`;
+  return read(transport, path, params, true);
+};
+
+// src/client.ts
+var AgilityApiClient = class _AgilityApiClient {
+  transport;
+  schema;
+  constructor(config, options = {}) {
+    const opts = "request" in options ? { transport: options } : options;
+    this.transport = opts.transport ?? createFetchTransport({
+      baseUrl: config.baseUrl,
+      authorization: config.authorization,
+      accessToken: config.accessToken,
+      timeoutMs: config.timeoutMs,
+      retries: config.retries,
+      defaultHeaders: config.defaultHeaders,
+      credentials: config.credentials,
+      onUnauthorized: config.onUnauthorized,
+      unauthorizedStatuses: config.unauthorizedStatuses
+    });
+    this.config = config;
+    this.schema = opts.schema ?? new Schema(this.transport, opts.metamodel, opts.types);
+  }
+  config;
+  /**
+   * The same client, with every request it sends tied to `signal`: abort it
+   * (on navigation, say) and in-flight requests end with an ApiError coded
+   * ABORTED. The schema and its cache are shared; a type load that other
+   * callers are waiting on is not cancelled.
+   */
+  withSignal(signal) {
+    const base = this.transport;
+    const transport = { request: (options) => base.request({ ...options, signal: options.signal ?? signal }) };
+    return new _AgilityApiClient(this.config, { transport, schema: this.schema });
+  }
+  /** meta.v1: the instance's schema, raw. (The translated, cached view is `schema`.) */
+  meta = {
+    metamodel: () => getMetamodel(this.transport),
+    assetType: (token) => getAssetType(this.transport, token),
+    attributeDefinition: (tokenref) => getAttributeDefinition(this.transport, tokenref)
+  };
+  /**
+   * loc-2.v1: labels for tags, in one request (meta's DisplayName values are
+   * tags). An unmatched tag comes back as itself; the server never says
+   * "missing", so neither does this.
+   */
+  localize(tags, options) {
+    return localize(this.transport, tags, options);
+  }
+  /**
+   * Services: what a person types, turned into assets. Numbers resolve in
+   * one api/asset request across every number root; an OID token is taken
+   * as is.
+   */
+  resolve = {
+    numbers: (numbers) => resolveNumbers(this.transport, numbers, { types: this.schema.cache }),
+    ref: (spec) => resolveRef(this.transport, spec, { types: this.schema.cache })
+  };
+  /**
+   * A batch with a record: preview, snapshot what it overwrites, (confirm,)
+   * send guarded, and a receipt with created/touched/skipped assets and a
+   * reverse batch. `reversible` drops from a receipt's reverse the assets
+   * changed since, unless forced.
+   */
+  batch = {
+    run: (commands, options) => runBatch(this.transport, this.schema, commands, options),
+    reversible: (receipt, options) => reversible(this.transport, receipt, options)
+  };
+  /**
+   * The files attached to assets: metadata on Attachment assets, bytes
+   * through attachment.img. `add` sends a small file inline (one request)
+   * and a large one in two steps; `url` is where a browser opens one.
+   */
+  attachments = {
+    list: (asset, options) => list(this.transport, asset, options),
+    page: (asset, options) => page(this.transport, asset, options),
+    info: (id) => info(this.transport, id),
+    get: (id) => get(this.transport, id),
+    add: (asset, data, options) => add(this.transport, asset, data, options),
+    put: (id, data, contentType) => put(this.transport, id, data, contentType),
+    remove: (id) => remove(this.transport, id),
+    url: (id) => attachmentUrl(this.config.baseUrl, id)
+  };
+  /**
+   * Images embedded in an asset's rich text (Description and other long
+   * text). `upload` returns the URL to put in an <img src>; `normalize`
+   * rewrites every embedded.img reference in some HTML to this instance's
+   * absolute URL, as Agility's own editor stores it. They cannot be deleted.
+   */
+  embeddedImages = {
+    upload: (asset, data, options) => uploadEmbeddedImage(this.transport, asset, data, options),
+    url: (id) => embeddedImageUrl(this.config.baseUrl, id),
+    normalize: (html) => normalizeEmbeddedImageUrls(html, this.config.baseUrl)
+  };
+  /** rest-1.v1: bounded reads, one asset, history. */
+  data = {
+    list: (type, params) => list2(this.transport, type, params),
+    get: (oid, sel) => get2(this.transport, oid, sel),
+    history: (target, params) => history(this.transport, target, params)
+  };
+  /**
+   * query.v1: reads only, the same query bodies as assets.query, rows
+   * translated the same way. The endpoint cannot write, so it is the safe
+   * place to explore a query; its requests may be retried like a GET.
+   */
+  queryV1 = {
+    query: async (q) => {
+      await this.schema.ensureFor([q]);
+      return query2(this.transport, q, { lookup: this.schema });
+    },
+    queries: async (qs) => {
+      await this.schema.ensureFor(qs);
+      return queries2(this.transport, qs, { lookup: this.schema });
+    }
+  };
+  /** api/asset: batches and queries, rows translated through the schema. */
+  assets = {
+    send: async (commands, options) => {
+      await this.schema.ensureFor(commands);
+      return send(this.transport, commands, { ...options, lookup: this.schema });
+    },
+    preview: (commands) => preview(this.transport, commands),
+    /**
+     * Send as a compare-and-set: each asset is changed only if nobody has
+     * changed it since the preview read it; the rest come back `skipped`.
+     * Throws UnguardableError, before any request, for shapes it cannot
+     * cover.
+     */
+    sendGuarded: async (commands, options) => {
+      await this.schema.ensureFor(commands);
+      return sendGuarded(this.transport, commands, { ...options, lookup: this.schema });
+    },
+    query: async (q) => {
+      await this.schema.ensureFor([q]);
+      return query(this.transport, q, { lookup: this.schema });
+    },
+    queries: async (qs) => {
+      await this.schema.ensureFor(qs);
+      return queries(this.transport, qs, { lookup: this.schema });
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ASSET_STATE_CODES,
+  AgilityApiClient,
+  ApiError,
+  AttachmentUploadError,
+  BatchRecordError,
+  BatchSendError,
+  CommandFailureError,
+  INLINE_LIMIT,
+  INVERSE,
+  NUMBER_ROOTS,
+  RESOLVE_CHUNK,
+  Schema,
+  TypeCache,
+  UNGUARDABLE_TYPES,
+  UnguardableError,
+  assetApi,
+  assetStateOf,
+  attachment,
+  createFetchTransport,
+  describeBatch,
+  guard,
+  isAssetNumber,
+  isOidToken,
+  loc2,
+  meta,
+  momentless,
+  namesOf,
+  parseOid,
+  queryV1,
+  resolveNumbers,
+  resolveRef,
+  rest1,
+  reverseOf,
+  reversible,
+  runBatch,
+  select,
+  sendGuarded,
+  snapshot,
+  stampsOf,
+  toOid,
+  touchedBy,
+  typeOfOid,
+  unguardable
+});
+//# sourceMappingURL=index.cjs.map