@undefineds.co/xpod 0.4.10 → 0.4.12

package/node_modules/@undefineds.co/pod-collections/dist/index.cjs

@@ -0,0 +1,1042 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  writeOnlyFields: () => writeOnlyFields,
+  valueToTerm: () => valueToTerm,
+  tableColumnsWithoutDescriptorField: () => tableColumnsWithoutDescriptorField,
+  subjectIriForRow: () => subjectIriForRow,
+  stripVirtualProps: () => stripVirtualProps,
+  sessionFetchOf: () => sessionFetchOf,
+  rowKeyOf: () => rowKeyOf,
+  resourceIdForRow: () => resourceIdForRow,
+  resolveTableDocument: () => resolveTableDocument,
+  projectionHash: () => projectionHash,
+  projectionFieldOrder: () => projectionFieldOrder,
+  podCollectionInternals: () => podCollectionInternals,
+  mapSubjectRows: () => mapSubjectRows,
+  fieldBindings: () => fieldBindings,
+  descriptorFieldsWithoutColumn: () => descriptorFieldsWithoutColumn,
+  definePodCollection: () => definePodCollection,
+  conditionalDocumentRead: () => conditionalDocumentRead,
+  computeDocumentDiff: () => computeDocumentDiff,
+  coerceFieldValue: () => coerceFieldValue,
+  PodCollectionError: () => PodCollectionError,
+  DEFAULT_CONFIRM_RETRIES: () => DEFAULT_CONFIRM_RETRIES,
+  DEFAULT_COALESCE_MS: () => DEFAULT_COALESCE_MS
+});
+module.exports = __toCommonJS(exports_src);
+var import_db = require("@tanstack/db");
+
+// src/types.ts
+class PodCollectionError extends Error {
+  code;
+  cause;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "PodCollectionError";
+    this.code = code;
+    this.cause = options?.cause;
+  }
+}
+
+// src/layout.ts
+var TEMPLATE_VARIABLE = /\{([^{}]+)\}/gu;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function normalizePodUrl(podUrl) {
+  return podUrl.endsWith("/") ? podUrl : `${podUrl}/`;
+}
+function resolvePodUrl(podUrl, value) {
+  if (/^[a-z][a-z0-9+.-]*:/iu.test(value))
+    return value;
+  return new URL(value.replace(/^\/+/u, ""), normalizePodUrl(podUrl)).toString();
+}
+function templateVariables(pattern) {
+  return [...pattern.matchAll(TEMPLATE_VARIABLE)].map((match) => match[1]);
+}
+function rowKeyVariable(pattern) {
+  const last = templateVariables(pattern).at(-1);
+  if (!last) {
+    throw new PodCollectionError("layout_pattern_without_key", `resourceIdPattern "${pattern}" has no {…} key slot`);
+  }
+  return last;
+}
+function splitOnKeySlot(pattern) {
+  const slot = `{${rowKeyVariable(pattern)}}`;
+  const index = pattern.lastIndexOf(slot);
+  return { head: pattern.slice(0, index), tail: pattern.slice(index + slot.length), slot };
+}
+function isDocumentBase(base) {
+  const lastSegment = base.replace(/\/+$/u, "").split("/").pop() ?? "";
+  return lastSegment.includes(".");
+}
+function baseDirectory(base) {
+  if (base.endsWith("/"))
+    return base;
+  const slash = base.lastIndexOf("/");
+  return slash < 0 ? "/" : base.slice(0, slash + 1);
+}
+function resolveTableDocument(descriptor, input) {
+  const podUrl = normalizePodUrl(input.podUrl);
+  if (input.document)
+    return resolvePodUrl(podUrl, input.document);
+  const base = descriptor.storage.base;
+  const pattern = descriptor.storage.resourceIdPattern;
+  if (!base || !pattern) {
+    throw new PodCollectionError("layout_missing_storage", `descriptor ${descriptor.uri} has no storage.base / resourceIdPattern`);
+  }
+  if (isDocumentBase(base))
+    return resolvePodUrl(podUrl, base);
+  const { head, tail } = splitOnKeySlot(pattern);
+  if (!pattern.includes("#") && templateVariables(head).length === 0) {
+    const key = input.scope?.instanceId ?? input.scope?.provider;
+    if (!key) {
+      throw new PodCollectionError("layout_document_required", `descriptor ${descriptor.uri} stores one document per row key (${pattern}); pass document or scope`);
+    }
+    return resolvePodUrl(podUrl, `${base}${head}${key}${tail}`);
+  }
+  throw new PodCollectionError("layout_document_required", `descriptor ${descriptor.uri} stores rows across documents (${base}${pattern}); pass document explicitly`);
+}
+function documentResourceId(documentUrl, podUrl) {
+  const root = normalizePodUrl(podUrl);
+  if (documentUrl.startsWith(root))
+    return documentUrl.slice(root.length);
+  return documentUrl.replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]*/iu, "").replace(/^\/+/u, "");
+}
+function documentKeyOf(descriptor, documentUrl, podUrl) {
+  const relative = documentResourceId(documentUrl, podUrl);
+  const baseDir = baseDirectory(descriptor.storage.base).replace(/^\/+/u, "");
+  const key = relative.startsWith(baseDir) ? relative.slice(baseDir.length) : relative;
+  if (!key) {
+    throw new PodCollectionError("layout_document_outside_base", `document ${documentUrl} is not under ${descriptor.storage.base}`);
+  }
+  return key;
+}
+function resourceIdForRow(descriptor, documentUrl, podUrl, key) {
+  const pattern = descriptor.storage.resourceIdPattern;
+  const documentKey = documentKeyOf(descriptor, documentUrl, podUrl);
+  const { head, tail, slot } = splitOnKeySlot(pattern);
+  if (templateVariables(pattern).length > 1) {
+    throw new PodCollectionError("layout_document_required", `resourceIdPattern "${pattern}" has template variables this layer cannot fill`);
+  }
+  if (pattern.startsWith("#"))
+    return `${documentKey}${pattern.replace(slot, key)}`;
+  return `${head}${key}${tail}`;
+}
+function subjectIriForRow(descriptor, documentUrl, key) {
+  return descriptor.storage.resourceIdPattern.includes("#") ? `${documentUrl}#${key}` : documentUrl;
+}
+function documentOfIri(iri) {
+  const hash = iri.indexOf("#");
+  return hash < 0 ? iri : iri.slice(0, hash);
+}
+function rowSubjectIriOf(row) {
+  for (const candidate of [row["@id"], row.uri, row.subject]) {
+    if (typeof candidate === "string" && candidate.length > 0)
+      return candidate;
+  }
+  return;
+}
+function rowResourceIdOf(row) {
+  return typeof row.id === "string" && row.id.length > 0 ? row.id : undefined;
+}
+function rowKeyOf(descriptor, row) {
+  const resourceId = rowResourceIdOf(row);
+  if (!resourceId)
+    return;
+  return compileRowKeyPattern(descriptor.storage.resourceIdPattern).exec(resourceId)?.[1];
+}
+function compileRowKeyPattern(pattern) {
+  const matches = [...pattern.matchAll(TEMPLATE_VARIABLE)];
+  const last = matches.at(-1);
+  if (!last) {
+    throw new PodCollectionError("layout_pattern_without_key", `resourceIdPattern "${pattern}" has no {…} key slot`);
+  }
+  let source = "^[\\s\\S]*?";
+  let cursor = 0;
+  for (const match of matches) {
+    const index = match.index ?? 0;
+    source += escapeRegExp(pattern.slice(cursor, index));
+    source += match === last ? "([\\s\\S]+)" : "[\\s\\S]*?";
+    cursor = index + match[0].length;
+  }
+  source += `${escapeRegExp(pattern.slice(cursor))}$`;
+  return new RegExp(source, "u");
+}
+function rowBelongsToDocument(descriptor, documentUrl, podUrl, row) {
+  const document = documentOfIri(documentUrl);
+  const subject = rowSubjectIriOf(row);
+  if (subject)
+    return documentOfIri(subject) === document;
+  const resourceId = rowResourceIdOf(row);
+  if (!resourceId)
+    return false;
+  const documentKey = documentKeyOf(descriptor, documentUrl, podUrl);
+  return documentOfIri(resourceId).endsWith(documentKey);
+}
+
+// src/mapping.ts
+var XSD = "http://www.w3.org/2001/XMLSchema#";
+function tableColumnPredicates(table) {
+  const mapping = table.getMapping();
+  const predicates = new Map;
+  for (const [column, entry] of Object.entries(mapping.columns)) {
+    if (entry.predicate === "@id")
+      continue;
+    predicates.set(column, entry.predicate);
+  }
+  return predicates;
+}
+function fieldBindings(descriptor, table) {
+  const byPredicate = new Map;
+  for (const [column, predicate] of tableColumnPredicates(table)) {
+    byPredicate.set(predicate, column);
+  }
+  const bindings = new Map;
+  for (const [field, fieldDescriptor] of Object.entries(descriptor.fields)) {
+    bindings.set(field, { field, descriptor: fieldDescriptor, column: byPredicate.get(fieldDescriptor.predicate) });
+  }
+  return bindings;
+}
+function identityFieldOf(descriptor) {
+  return rowKeyVariable(descriptor.storage.resourceIdPattern);
+}
+function descriptorFieldsWithoutColumn(descriptor, table) {
+  const identity = identityFieldOf(descriptor);
+  return [...fieldBindings(descriptor, table).values()].filter((binding) => binding.column === undefined && binding.field !== identity).map((binding) => binding.field).sort();
+}
+function tableColumnsWithoutDescriptorField(descriptor, table) {
+  const declaredPredicates = new Set(Object.values(descriptor.fields).map((field) => field.predicate));
+  return [...tableColumnPredicates(table)].filter(([, predicate]) => !declaredPredicates.has(predicate)).map(([column]) => column).sort();
+}
+function assertDescriptorTableAlignment(descriptor, table) {
+  const tableClass = table.getType();
+  if (descriptor.class !== tableClass) {
+    throw new PodCollectionError("mapping_class_mismatch", `descriptor ${descriptor.uri} declares class ${descriptor.class} but table ${table.config.name} reads ${tableClass}`);
+  }
+}
+function writeOnlyFields(descriptor) {
+  return new Set(Object.entries(descriptor.fields).filter(([, field]) => field.secret === true).map(([name]) => name));
+}
+function projectionFieldOrder(descriptor) {
+  const writeOnly = writeOnlyFields(descriptor);
+  return Object.entries(descriptor.fields).filter(([field]) => !writeOnly.has(field)).sort(([, left], [, right]) => left.predicate < right.predicate ? -1 : left.predicate > right.predicate ? 1 : 0).map(([field]) => field);
+}
+function isRdfTerm(value) {
+  return typeof value === "object" && value !== null && typeof value.termType === "string" && typeof value.value === "string";
+}
+function termDatatypeOf(value) {
+  const datatype = value.datatype;
+  if (!datatype)
+    return;
+  return typeof datatype === "string" ? datatype : datatype.value;
+}
+function coerceScalar(field, input) {
+  if (input === null || input === undefined || input === "")
+    return;
+  const term = isRdfTerm(input) ? input : undefined;
+  const raw = term ? term.value : input;
+  const datatype = term ? termDatatypeOf(term) : undefined;
+  switch (field.type) {
+    case "uri":
+      return term && term.termType !== "NamedNode" ? String(raw) : String(raw);
+    case "string":
+    case "text":
+      return typeof raw === "boolean" || typeof raw === "number" ? String(raw) : String(raw);
+    case "number": {
+      if (typeof raw === "number")
+        return raw;
+      const parsed = Number(raw);
+      return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    case "boolean":
+      if (typeof raw === "boolean")
+        return raw;
+      if (raw === "true")
+        return true;
+      if (raw === "false")
+        return false;
+      return Boolean(raw);
+    case "timestamp": {
+      const date = raw instanceof Date ? raw : new Date(String(raw));
+      return Number.isNaN(date.getTime()) ? undefined : date;
+    }
+    case "json": {
+      if (!term)
+        return input;
+      if (datatype && !/#json(Array)?$/u.test(datatype) && raw === "")
+        return;
+      try {
+        return JSON.parse(String(raw));
+      } catch {
+        return raw;
+      }
+    }
+    default:
+      return raw;
+  }
+}
+function coerceFieldValue(field, input) {
+  if (field.array) {
+    if (input === undefined || input === null)
+      return;
+    const list = Array.isArray(input) ? input : [input];
+    const values = list.map((item) => coerceScalar(field, item)).filter((item) => item !== undefined);
+    return values.length > 0 ? values : undefined;
+  }
+  return coerceScalar(field, input);
+}
+function valueToTerm(field, value) {
+  if (value === undefined || value === null)
+    return;
+  if (field.type === "uri")
+    return { termType: "NamedNode", value: String(value) };
+  if (field.type === "number") {
+    const numeric = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(numeric))
+      return;
+    return {
+      termType: "Literal",
+      value: String(numeric),
+      datatype: Number.isInteger(numeric) ? `${XSD}integer` : `${XSD}decimal`
+    };
+  }
+  if (field.type === "boolean") {
+    return { termType: "Literal", value: value ? "true" : "false", datatype: `${XSD}boolean` };
+  }
+  if (field.type === "timestamp") {
+    const date = value instanceof Date ? value : new Date(String(value));
+    if (Number.isNaN(date.getTime()))
+      return;
+    return { termType: "Literal", value: date.toISOString(), datatype: `${XSD}dateTime` };
+  }
+  if (field.type === "json") {
+    return { termType: "Literal", value: typeof value === "string" ? value : JSON.stringify(value) };
+  }
+  const text = String(value);
+  if (/^https?:\/\//u.test(text))
+    return { termType: "NamedNode", value: text };
+  return { termType: "Literal", value: text };
+}
+function mapSubjectRows(descriptor, table, subjects) {
+  const bindings = fieldBindings(descriptor, table);
+  const identityField = identityFieldOf(descriptor);
+  const writeOnly = writeOnlyFields(descriptor);
+  const rows = [];
+  for (const subject of subjects) {
+    const key = rowKeyOf(descriptor, subject);
+    if (key === undefined)
+      continue;
+    const row = { id: key };
+    if (identityField !== "id")
+      row[identityField] = key;
+    const subjectIri = subject["@id"] ?? subject.uri ?? subject.subject;
+    if (typeof subjectIri === "string")
+      row["@id"] = subjectIri;
+    for (const binding of bindings.values()) {
+      if (writeOnly.has(binding.field))
+        continue;
+      if (binding.column === undefined)
+        continue;
+      const value = coerceFieldValue(binding.descriptor, subject[binding.column]);
+      if (value !== undefined)
+        row[binding.field] = value;
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+function descriptorRowToColumnValues(descriptor, table, row, options) {
+  const bindings = fieldBindings(descriptor, table);
+  const values = { id: options.resourceId };
+  for (const [field, value] of Object.entries(row)) {
+    if (field === "id" || field === "@id")
+      continue;
+    const binding = bindings.get(field);
+    if (!binding || binding.column === undefined)
+      continue;
+    if (options.includeField && !options.includeField(field))
+      continue;
+    values[binding.column] = value;
+  }
+  return values;
+}
+function isUriArrayField(field) {
+  return field.array === true && field.type === "uri";
+}
+
+// src/read.ts
+async function selectSubjectRows(table, database) {
+  const initialized = typeof table.isInitialized === "function" ? table.isInitialized() : true;
+  if (!initialized)
+    await database.init?.(table);
+  const rows = await database.select().from(table).execute();
+  return rows;
+}
+async function conditionalDocumentRead(source, _request = {}) {
+  const subjects = await selectSubjectRows(source.table, source.database);
+  return {
+    etag: undefined,
+    subjects: subjects.filter((subject) => rowBelongsToDocument(source.descriptor, source.document, source.podUrl, subject))
+  };
+}
+function sessionFetchOf(database) {
+  const dialect = database.getDialect?.();
+  const candidate = dialect?.config?.session?.fetch;
+  return typeof candidate === "function" ? candidate : undefined;
+}
+
+// src/diff.ts
+var EMPTY_FIELDS = new Set;
+function stripVirtualProps(row) {
+  const source = row;
+  const stripped = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (key.startsWith("$"))
+      continue;
+    stripped[key] = value;
+  }
+  return stripped;
+}
+function canonicalValue(value) {
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Array.isArray(value))
+    return value.map((item) => canonicalValue(item));
+  if (value && typeof value === "object") {
+    if (value instanceof Set)
+      return [...value].map((item) => canonicalValue(item));
+    const entries = Object.entries(value).filter(([, item]) => item !== undefined).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+    return Object.fromEntries(entries.map(([key, item]) => [key, canonicalValue(item)]));
+  }
+  return value;
+}
+function projectionHash(row, fieldOrder) {
+  const source = stripVirtualProps(row);
+  const ordered = {};
+  if (source.id !== undefined)
+    ordered.id = canonicalValue(source.id);
+  for (const field of fieldOrder) {
+    if (source[field] !== undefined)
+      ordered[field] = canonicalValue(source[field]);
+  }
+  return JSON.stringify(ordered);
+}
+function canonicalEquals(left, right) {
+  if (left === undefined || right === undefined)
+    return left === right;
+  return JSON.stringify(canonicalValue(left)) === JSON.stringify(canonicalValue(right));
+}
+function projectionCovers(row, intent, writeOnly = EMPTY_FIELDS) {
+  if (row === undefined)
+    return false;
+  const source = stripVirtualProps(row);
+  const target = stripVirtualProps(intent);
+  for (const [key, value] of Object.entries(target)) {
+    if (key === "@id" || value === undefined)
+      continue;
+    if (writeOnly.has(key))
+      continue;
+    if (!canonicalEquals(source[key], value))
+      return false;
+  }
+  return true;
+}
+function computeDocumentDiff(input) {
+  const present = new Set(input.presentKeys);
+  const inserts = [];
+  const updates = [];
+  const deletes = [];
+  const baselineHash = (key) => {
+    const known = input.knownHash(key);
+    if (known !== undefined)
+      return known;
+    const held = input.presentRow?.(key);
+    return held === undefined ? undefined : input.hashOf(held);
+  };
+  for (const [key, row] of input.next) {
+    if (input.pendingKeys.has(key)) {
+      if (present.has(key) && baselineHash(key) !== input.hashOf(row)) {
+        updates.push({ key, row });
+      }
+      continue;
+    }
+    if (!present.has(key)) {
+      inserts.push({ key, row });
+      continue;
+    }
+    if (baselineHash(key) !== input.hashOf(row))
+      updates.push({ key, row });
+  }
+  for (const key of present) {
+    if (input.next.has(key))
+      continue;
+    if (input.pendingKeys.has(key))
+      continue;
+    const row = input.presentRow?.(key);
+    if (row === undefined)
+      continue;
+    deletes.push({ key, row });
+  }
+  return { inserts, updates, deletes };
+}
+
+// src/mutations.ts
+function createDeferred() {
+  let resolve;
+  const promise = new Promise((settle) => {
+    resolve = () => settle();
+  });
+  return { promise, resolve };
+}
+function createPendingWrites(onConflict) {
+  const keys = new Set;
+  const entries = new Map;
+  const conflicts = [];
+  const clear = (key) => {
+    keys.delete(key);
+    entries.delete(key);
+  };
+  const settle = (entry, error) => {
+    if (entry.settled)
+      return;
+    entry.error = error;
+    entry.settled = true;
+    entry.resolveSettled();
+  };
+  const register = (input) => {
+    clear(input.key);
+    const deferred = createDeferred();
+    const entry = {
+      ...input,
+      settled: false,
+      error: undefined,
+      settledPromise: deferred.promise,
+      resolveSettled: deferred.resolve
+    };
+    entries.set(input.key, entry);
+    keys.add(input.key);
+    return entry;
+  };
+  return {
+    keys,
+    entries,
+    conflicts,
+    register,
+    clear,
+    settle,
+    isConfirmed: (key) => entries.get(key)?.settled === true && entries.get(key)?.error === undefined,
+    recordConflict: (conflict) => {
+      conflicts.push(conflict);
+      onConflict?.(conflict);
+    }
+  };
+}
+function markConflict(pending, entry, server) {
+  pending.recordConflict({
+    key: entry.key,
+    server,
+    local: entry.localRow ?? entry.intent ?? server,
+    at: Date.now()
+  });
+  pending.settle(entry, new PodCollectionError("write_conflict", `row ${entry.key} was changed by someone else; server wins`));
+}
+function reconcilePendingWrites(pending, next, hashOf, writeOnly = EMPTY_WRITE_ONLY) {
+  for (const entry of pending.entries.values()) {
+    if (entry.settled)
+      continue;
+    const server = next.get(entry.key);
+    if (entry.intent === undefined) {
+      if (server === undefined) {
+        pending.settle(entry);
+        continue;
+      }
+      if (entry.beforeHash !== undefined && hashOf(server) !== entry.beforeHash) {
+        markConflict(pending, entry, server);
+      }
+      continue;
+    }
+    if (projectionCovers(server, entry.intent, writeOnly)) {
+      pending.settle(entry);
+      continue;
+    }
+    if (server !== undefined && hashOf(server) !== entry.beforeHash) {
+      markConflict(pending, entry, server);
+      continue;
+    }
+    if (server === undefined && entry.beforeHash !== undefined) {
+      pending.settle(entry, new PodCollectionError("write_conflict", `row ${entry.key} disappeared before the write was confirmed; server wins`));
+    }
+  }
+}
+var EMPTY_WRITE_ONLY = new Set;
+function absoluteUri(value, base) {
+  if (typeof value !== "string" || value.length === 0)
+    return;
+  if (/^[a-z][a-z0-9+.-]*:/iu.test(value))
+    return value;
+  return new URL(value, base).toString();
+}
+async function writeField(context, fieldName, options) {
+  const field = context.descriptor.fields[fieldName];
+  if (!field || !isUriArrayField(field)) {
+    throw new PodCollectionError("write_field_not_uri_array", `field ${fieldName} is not array+uri; it must go through the ORM`);
+  }
+  const documentUrl = documentOfIri(context.document);
+  const previous = (Array.isArray(options.previous) ? options.previous : [options.previous]).map((value) => absoluteUri(value, documentUrl)).filter((value) => value !== undefined);
+  const next = (Array.isArray(options.next) ? options.next : [options.next]).map((value) => absoluteUri(value, documentUrl)).filter((value) => value !== undefined);
+  const triples = (iris) => iris.map((iri) => `<${options.subjectIri}> <${field.predicate}> <${iri}> .`).join(`
+`);
+  const operations = [
+    previous.length > 0 ? `DELETE DATA { ${triples(previous)} }` : undefined,
+    next.length > 0 ? `INSERT DATA { ${triples(next)} }` : undefined
+  ].filter((operation) => operation !== undefined);
+  if (operations.length === 0)
+    return;
+  const fetchFn = context.authenticatedFetch ?? sessionFetchOf(context.database);
+  if (!fetchFn) {
+    throw new PodCollectionError("write_field_no_fetch", "array+uri fields need an authenticated fetch (SolidAuthSession.fetch); none available");
+  }
+  const response = await fetchFn(documentUrl, {
+    method: "PATCH",
+    headers: { "content-type": "application/sparql-update" },
+    body: operations.join(`;
+`)
+  });
+  if (!response.ok) {
+    throw new PodCollectionError("write_field_rejected", `SPARQL PATCH for ${fieldName} failed with HTTP ${response.status}`);
+  }
+}
+function createMutationHandlers(context) {
+  const { descriptor, table, pending } = context;
+  const fieldOrder = projectionFieldOrder(descriptor);
+  const hashOf = (row) => projectionHash(row, fieldOrder);
+  const uriArrayFieldNames = new Set(Object.entries(descriptor.fields).filter(([, field]) => isUriArrayField(field)).map(([name]) => name));
+  const columnBindings = fieldBindings(descriptor, table);
+  const columnOf = (field) => columnBindings.get(field)?.column;
+  const runWrite = async (key, write) => {
+    try {
+      await write();
+    } catch (error) {
+      pending.clear(key);
+      throw error instanceof Error ? error : new PodCollectionError("write_failed", String(error), { cause: error });
+    }
+    try {
+      await context.confirm(key);
+    } finally {
+      pending.clear(key);
+    }
+  };
+  return {
+    onInsert: async ({ transaction }) => {
+      for (const mutation of transaction.mutations) {
+        const row = mutation.modified;
+        const key = String(mutation.key);
+        const resourceId = resourceIdForRow(descriptor, context.document, context.podUrl, key);
+        const subjectIri = subjectIriForRow(descriptor, context.document, key);
+        pending.register({
+          key,
+          intent: row,
+          localRow: row,
+          beforeHash: undefined
+        });
+        await runWrite(key, async () => {
+          const values = descriptorRowToColumnValues(descriptor, table, row, {
+            resourceId,
+            includeField: (field) => !uriArrayFieldNames.has(field)
+          });
+          await context.database.insert(table).values(values).execute();
+          await writeUriArrayFields(context, row, subjectIri, undefined, row);
+        });
+      }
+    },
+    onUpdate: async ({ transaction }) => {
+      for (const mutation of transaction.mutations) {
+        const key = String(mutation.key);
+        const original = mutation.original;
+        const modified = mutation.modified;
+        const changes = mutation.changes;
+        const resourceId = resourceIdForRow(descriptor, context.document, context.podUrl, key);
+        const subjectIri = subjectIriForRow(descriptor, context.document, key);
+        const beforeHash = original && Object.keys(original).length > 0 ? hashOf(original) : undefined;
+        pending.register({
+          key,
+          intent: modified,
+          localRow: modified,
+          beforeHash
+        });
+        await runWrite(key, async () => {
+          const columnChanges = {};
+          for (const [field, value] of Object.entries(changes)) {
+            if (uriArrayFieldNames.has(field))
+              continue;
+            const column = columnOf(field);
+            if (column === undefined)
+              continue;
+            columnChanges[column] = value;
+          }
+          if (Object.keys(columnChanges).length > 0) {
+            const updated = await context.database.updateById(table, resourceId, columnChanges);
+            if (!updated) {
+              throw new PodCollectionError("write_rejected", `drizzle-solid did not update ${resourceId}`);
+            }
+          }
+          await writeUriArrayFields(context, changes, subjectIri, original, modified);
+        });
+      }
+    },
+    onDelete: async ({ transaction }) => {
+      for (const mutation of transaction.mutations) {
+        const key = String(mutation.key);
+        const original = mutation.original;
+        const resourceId = resourceIdForRow(descriptor, context.document, context.podUrl, key);
+        pending.register({
+          key,
+          intent: undefined,
+          localRow: original,
+          beforeHash: original && Object.keys(original).length > 0 ? hashOf(original) : undefined
+        });
+        await runWrite(key, async () => {
+          await context.database.deleteById(table, resourceId);
+        });
+      }
+    }
+  };
+}
+async function writeUriArrayFields(context, changed, subjectIri, previousRow, nextRow) {
+  for (const [field, fieldDescriptor] of Object.entries(context.descriptor.fields)) {
+    if (!isUriArrayField(fieldDescriptor))
+      continue;
+    if (!(field in changed))
+      continue;
+    await writeField(context, field, {
+      subjectIri,
+      previous: previousRow?.[field],
+      next: nextRow?.[field]
+    });
+  }
+}
+
+// src/feed.ts
+var NOOP_SUBSCRIPTION = {
+  available: false,
+  unsubscribe: () => {}
+};
+function subscribeDocumentFeed(feed, topicUrl, listener) {
+  if (!feed || typeof feed.watch !== "function")
+    return NOOP_SUBSCRIPTION;
+  try {
+    const unsubscribe = feed.watch(topicUrl, listener);
+    if (typeof unsubscribe !== "function")
+      return NOOP_SUBSCRIPTION;
+    let active = true;
+    return {
+      available: true,
+      unsubscribe: () => {
+        if (!active)
+          return;
+        active = false;
+        unsubscribe();
+      }
+    };
+  } catch {
+    return NOOP_SUBSCRIPTION;
+  }
+}
+
+// src/sync.ts
+var DEFAULT_COALESCE_MS = 75;
+var DEFAULT_CONFIRM_RETRIES = 2;
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function createPodSync(options) {
+  const { descriptor, table, database, document, podUrl, pending } = options;
+  const coalesceMs = options.coalesceMs ?? DEFAULT_COALESCE_MS;
+  const confirmRetries = options.confirmRetries ?? DEFAULT_CONFIRM_RETRIES;
+  const fieldOrder = projectionFieldOrder(descriptor);
+  const writeOnly = writeOnlyFields(descriptor);
+  const hashOf = (row) => projectionHash(row, fieldOrder);
+  let params;
+  let subscription;
+  let feedAvailable = false;
+  let ready = false;
+  let failureReported = false;
+  let syncState = "initializing";
+  let timer;
+  let bufferedSignals = [];
+  let running;
+  let rerunRequested = false;
+  let disposed = false;
+  let lastEtag;
+  async function ensureParams() {
+    if (params)
+      return params;
+    const collection = options.collection();
+    if (!collection) {
+      throw new PodCollectionError("sync_not_started", "collection has not started syncing yet");
+    }
+    await collection.preload();
+    if (!params) {
+      throw new PodCollectionError("sync_not_started", "collection sync did not start");
+    }
+    return params;
+  }
+  function schedulePass() {
+    if (disposed || timer !== undefined)
+      return;
+    timer = setTimeout(() => {
+      timer = undefined;
+      runPass().catch(() => {
+        syncState = "degraded";
+      });
+    }, coalesceMs);
+  }
+  function runPass() {
+    if (running) {
+      rerunRequested = true;
+      return running;
+    }
+    const task = (async () => {
+      try {
+        do {
+          rerunRequested = false;
+          await passOnce();
+        } while (rerunRequested && !disposed);
+      } finally {
+        running = undefined;
+      }
+    })();
+    running = task;
+    return task;
+  }
+  async function passOnce() {
+    const sync2 = await ensureParams();
+    if (disposed)
+      return;
+    let read;
+    try {
+      read = await conditionalDocumentRead({ descriptor, table, database, document, podUrl }, { ifNoneMatch: lastEtag });
+    } catch (error) {
+      syncState = "degraded";
+      if (!ready && !failureReported) {
+        failureReported = true;
+        sync2.markError(error);
+      }
+      return;
+    }
+    if (read.etag !== undefined)
+      lastEtag = read.etag;
+    const rows = mapSubjectRows(descriptor, table, read.subjects);
+    const next = new Map(rows.map((row) => [String(row.id), row]));
+    const presentKeys = [...sync2.collection.keys()].map((key) => String(key));
+    const knownHash = (key) => {
+      const entry = sync2.metadata?.row.get(key);
+      return entry?.hash;
+    };
+    const diff = computeDocumentDiff({
+      next,
+      presentKeys,
+      pendingKeys: pending.keys,
+      knownHash,
+      hashOf,
+      presentRow: (key) => sync2.collection.get(key)
+    });
+    if (diff.inserts.length + diff.updates.length + diff.deletes.length > 0) {
+      sync2.begin({ immediate: true });
+      for (const entry of diff.inserts) {
+        sync2.write({ type: "insert", value: stripVirtualProps(entry.row) });
+      }
+      for (const entry of diff.updates) {
+        sync2.write({ type: "update", value: stripVirtualProps(entry.row) });
+      }
+      for (const entry of diff.deletes) {
+        sync2.write({
+          type: "delete",
+          key: entry.key,
+          value: stripVirtualProps(entry.row)
+        });
+      }
+      for (const entry of [...diff.inserts, ...diff.updates]) {
+        sync2.metadata?.row.set(entry.key, { hash: hashOf(entry.row) });
+      }
+      await sync2.commit();
+    }
+    if (!ready) {
+      ready = true;
+      failureReported = false;
+      sync2.markReady();
+    }
+    reconcilePendingWrites(pending, next, hashOf, writeOnly);
+    syncState = feedAvailable ? "live" : "unavailable";
+  }
+  async function confirmPending(key) {
+    const entry = pending.entries.get(key);
+    if (!entry)
+      return;
+    for (let attempt = 0;; attempt += 1) {
+      await runPass();
+      if (entry.settled) {
+        if (entry.error)
+          throw entry.error;
+        return;
+      }
+      if (attempt >= confirmRetries) {
+        throw new PodCollectionError("write_unconfirmed", `write to ${key} was not visible in the document after ${confirmRetries + 1} reads`);
+      }
+      await sleep(coalesceMs);
+    }
+  }
+  const sync = (syncParams) => {
+    if (disposed)
+      return () => {};
+    params = syncParams;
+    subscription = subscribeDocumentFeed(options.feed, document, () => {
+      if (!ready) {
+        bufferedSignals.push({ topic: document });
+        return;
+      }
+      schedulePass();
+    });
+    feedAvailable = subscription.available;
+    runPass().then(() => {
+      if (disposed)
+        return;
+      const replay = bufferedSignals;
+      bufferedSignals = [];
+      if (replay.length > 0)
+        schedulePass();
+    }).catch(() => {
+      syncState = "degraded";
+    });
+    return () => {
+      dispose();
+    };
+  };
+  function dispose() {
+    if (disposed)
+      return;
+    disposed = true;
+    if (timer !== undefined) {
+      clearTimeout(timer);
+      timer = undefined;
+    }
+    subscription?.unsubscribe();
+    subscription = undefined;
+    bufferedSignals = [];
+  }
+  return {
+    sync,
+    refresh: () => runPass(),
+    confirmPending,
+    state: () => syncState,
+    dispose,
+    truncate: () => {
+      if (!params || disposed)
+        return;
+      params.begin({ immediate: true });
+      params.truncate();
+      Promise.resolve(params.commit()).catch(() => {});
+    }
+  };
+}
+
+// src/index.ts
+function definePodCollection(descriptor, options) {
+  assertDescriptorTableAlignment(descriptor, options.table);
+  const document = resolveTableDocument(descriptor, {
+    podUrl: options.podUrl,
+    document: options.document,
+    scope: options.scope
+  });
+  const pending = createPendingWrites(options.onConflict);
+  let collection;
+  const engine = createPodSync({
+    descriptor,
+    table: options.table,
+    database: options.database,
+    podUrl: options.podUrl,
+    document,
+    feed: options.feed,
+    coalesceMs: options.coalesceMs,
+    confirmRetries: options.confirmRetries,
+    pending,
+    collection: () => collection
+  });
+  const handlers = createMutationHandlers({
+    descriptor,
+    table: options.table,
+    database: options.database,
+    podUrl: options.podUrl,
+    document,
+    pending,
+    confirm: (key) => engine.confirmPending(key)
+  });
+  const created = import_db.createCollection({
+    id: `pod-collection:${descriptor.uri}:${document}`,
+    getKey: (row) => row.id,
+    sync: { sync: engine.sync, rowUpdateMode: "full" },
+    startSync: true,
+    onInsert: handlers.onInsert,
+    onUpdate: handlers.onUpdate,
+    onDelete: handlers.onDelete
+  });
+  collection = created;
+  return Object.assign(created, {
+    tableDocument: document,
+    pendingKeys: pending.keys,
+    conflicts: pending.conflicts,
+    refresh: () => engine.refresh(),
+    syncState: () => engine.state(),
+    dispose: () => engine.dispose(),
+    truncateForTest: () => engine.truncate()
+  });
+}
+function podCollectionInternals(collection) {
+  const internals = collection;
+  if (typeof internals.syncState !== "function" || typeof internals.dispose !== "function") {
+    throw new PodCollectionError("collection_not_from_define", "collection was not created by definePodCollection()");
+  }
+  return internals;
+}