doxum 0.1.1

package/dist/dependency-BdEMyquf.js

@@ -0,0 +1,735 @@
+import { t as __exportAll } from "./chunk-pbuEa-1d.js";
+//#region core/src/schema.ts
+const node = (value) => Object.freeze(value);
+const field = () => node({ kind: "field" });
+const optional = (value) => node({
+	...value,
+	optional: true
+});
+const object = (shape) => node({
+	kind: "object",
+	shape
+});
+const variant = (tag, variants) => node({
+	kind: "variant",
+	tag,
+	variants
+});
+const single = (value) => node({
+	kind: "single",
+	value
+});
+const table = (value) => node({
+	kind: "table",
+	value
+});
+const map = (value) => node({
+	kind: "map",
+	value
+});
+const record = () => node({ kind: "record" });
+const dict = () => node({ kind: "dict" });
+const list = (config) => ({
+	kind: "list",
+	keyOf: config.keyOf
+});
+const tree = () => node({ kind: "tree" });
+const pathProxy = (address) => new Proxy({ address }, { get: (_target, property) => {
+	if (property === "address") return address;
+	if (property === "item") return (id) => pathProxy([...address, id]);
+	if (typeof property === "symbol") return void 0;
+	return pathProxy([...address, property]);
+} });
+const select = (owner, kind, pick) => {
+	const selected = pick(pathProxy([]));
+	return Object.freeze({
+		kind,
+		schema: owner,
+		address: Object.freeze([...selected.address ?? []])
+	});
+};
+const schema = (shape) => {
+	const result = {
+		kind: "schema",
+		shape,
+		collection: (pick) => select(result, "collection", pick),
+		value: (pick) => select(result, "value", pick)
+	};
+	return Object.freeze(result);
+};
+//#endregion
+//#region core/src/profile.ts
+const active = { current: void 0 };
+const profile = {
+	clone: {
+		call: () => {
+			const value = active.current;
+			if (value) value.clone.calls += 1;
+		},
+		node: (reason) => {
+			const value = active.current;
+			if (!value) return;
+			value.clone.nodes[reason] += 1;
+		},
+		container: () => {
+			const value = active.current;
+			if (value) value.clone.containers += 1;
+		},
+		deepEqual: () => {
+			const value = active.current;
+			if (value) value.clone.deepEqual.calls += 1;
+		},
+		deepEqualContainer: () => {
+			const value = active.current;
+			if (value) value.clone.deepEqual.containers += 1;
+		},
+		initialDocument: () => {
+			const value = active.current;
+			if (value) value.clone.documents.initial += 1;
+		}
+	},
+	mutation: {
+		normalized: () => {
+			const value = active.current;
+			if (value) value.mutation.normalized += 1;
+		},
+		executed: () => {
+			const value = active.current;
+			if (value) value.mutation.executed += 1;
+		},
+		inverse: () => {
+			const value = active.current;
+			if (value) value.mutation.inverseCreated += 1;
+		}
+	},
+	batch: {
+		operation: () => {
+			const value = active.current;
+			if (value) value.batch.operations += 1;
+		},
+		entry: (amount = 1) => {
+			const value = active.current;
+			if (value) value.batch.entries += amount;
+		},
+		collectionResolved: () => {
+			const value = active.current;
+			if (value) value.batch.collectionsResolved += 1;
+		},
+		journalRecord: () => {
+			const value = active.current;
+			if (value) value.batch.journalRecords += 1;
+		},
+		rejected: () => {
+			const value = active.current;
+			if (value) value.batch.rejected += 1;
+		},
+		inverse: () => {
+			const value = active.current;
+			if (value) value.batch.inverseOperations += 1;
+		},
+		payloadTransferred: () => {
+			const value = active.current;
+			if (value) value.batch.payloadTransferred += 1;
+		},
+		payloadSnapshot: () => {
+			const value = active.current;
+			if (value) value.batch.payloadSnapshots += 1;
+		}
+	},
+	journal: {
+		subject: () => {
+			const value = active.current;
+			if (value) value.journal.subjects += 1;
+		},
+		comparison: () => {
+			const value = active.current;
+			if (value) value.journal.comparisons += 1;
+		},
+		absorbed: () => {
+			const value = active.current;
+			if (value) value.journal.absorbed += 1;
+		},
+		orderSnapshot: (items) => {
+			const value = active.current;
+			if (!value) return;
+			value.journal.orderSnapshots += 1;
+			value.journal.orderItems += items;
+		}
+	},
+	address: {
+		schemaStep: () => {
+			const value = active.current;
+			if (value) value.address.schemaSteps += 1;
+		},
+		documentStep: () => {
+			const value = active.current;
+			if (value) value.address.documentSteps += 1;
+		},
+		arrayCopied: () => {
+			const value = active.current;
+			if (value) value.address.arraysCopied += 1;
+		},
+		prefixComparison: () => {
+			const value = active.current;
+			if (value) value.address.prefixComparisons += 1;
+		},
+		segmentCompared: () => {
+			const value = active.current;
+			if (value) value.address.segmentsCompared += 1;
+		}
+	},
+	impact: { affects: () => {
+		const value = active.current;
+		if (value) value.impact.affectsChecks += 1;
+	} },
+	reader: {
+		session: () => {
+			const value = active.current;
+			if (value) value.reader.sessions += 1;
+		},
+		lookup: () => {
+			const value = active.current;
+			if (value) value.reader.nodeLookups += 1;
+		},
+		collectionIds: (amount = 1) => {
+			const value = active.current;
+			if (value) value.reader.collectionIds += amount;
+		},
+		structuralSnapshot: () => {
+			const value = active.current;
+			if (value) value.reader.structuralSnapshots += 1;
+		}
+	},
+	collectionView: {
+		mapped: () => {
+			const value = active.current;
+			if (value) value.collectionView.mappedItems += 1;
+		},
+		idsScanned: (amount = 1) => {
+			const value = active.current;
+			if (value) value.collectionView.idsScanned += amount;
+		},
+		arrayCopied: () => {
+			const value = active.current;
+			if (value) value.collectionView.arraysCopied += 1;
+		}
+	},
+	materialized: {
+		updated: () => {
+			const value = active.current;
+			if (value) value.materialized.updated += 1;
+		},
+		skipped: () => {
+			const value = active.current;
+			if (value) value.materialized.skipped += 1;
+		},
+		rebuilt: () => {
+			const value = active.current;
+			if (value) value.materialized.rebuilt += 1;
+		},
+		sourceChanged: () => {
+			const value = active.current;
+			if (value) value.materialized.sourceChanges += 1;
+		},
+		notification: () => {
+			const value = active.current;
+			if (value) value.materialized.notifications += 1;
+		}
+	}
+};
+//#endregion
+//#region core/src/address.ts
+const registries = /* @__PURE__ */ new WeakMap();
+const registryNode = () => ({ static: /* @__PURE__ */ new Map() });
+const registryFor = (schema) => {
+	const cached = registries.get(schema);
+	if (cached) return cached;
+	const registry = {
+		root: registryNode(),
+		nextPath: 0
+	};
+	registries.set(schema, registry);
+	return registry;
+};
+const hashText = (value, seed) => {
+	let hash = seed;
+	for (let index = 0; index < value.length; index += 1) hash = Math.imul(hash ^ value.charCodeAt(index), 16777619);
+	return hash >>> 0;
+};
+const appendAddressHash = (hash, segment) => hashText(segment, hashText("/", hash));
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const unwrap = (node) => {
+	let current = node;
+	while (current?.kind === "single") current = current.value;
+	return current;
+};
+const variantNode = (node, value) => {
+	const tag = isRecord$1(value) && typeof value[node.tag] === "string" ? value[node.tag] : void 0;
+	return node.variants[String(tag ?? Object.keys(node.variants)[0] ?? "")];
+};
+const schemaRoot$1 = (schema) => ({
+	kind: "object",
+	shape: schema.shape
+});
+const step = (nodeInput, value, segment) => {
+	let node = unwrap(nodeInput);
+	if (!node) return {
+		node: void 0,
+		dynamic: false
+	};
+	if (node.kind === "variant") node = unwrap(variantNode(node, value));
+	if (!node) return {
+		node: void 0,
+		dynamic: false
+	};
+	if (node.kind === "object") return {
+		node: node.shape[segment],
+		dynamic: false
+	};
+	if (node.kind === "table" || node.kind === "map") return {
+		node: node.value,
+		dynamic: true
+	};
+	if (node.kind === "record" || node.kind === "dict" || node.kind === "list" || node.kind === "tree") return {
+		node,
+		dynamic: true
+	};
+	return {
+		node: void 0,
+		dynamic: false
+	};
+};
+const pathFor = (schema, address, document) => {
+	const registry = registryFor(schema);
+	let trie = registry.root;
+	let node = schemaRoot$1(schema);
+	let value = document;
+	for (const segment of address) {
+		profile.address.schemaStep();
+		profile.address.documentStep();
+		const resolved = step(node, value, segment);
+		if (!resolved.node) return void 0;
+		trie = resolved.dynamic ? trie.dynamic ??= registryNode() : (() => {
+			const existing = trie.static.get(segment);
+			if (existing) return existing;
+			const created = registryNode();
+			trie.static.set(segment, created);
+			return created;
+		})();
+		node = resolved.node;
+		value = readSegment(value, segment);
+	}
+	if (trie.path === void 0) trie.path = registry.nextPath++;
+	return trie.path;
+};
+const resolveAddress = (schema, address, document) => {
+	if (!Array.isArray(address)) return void 0;
+	for (const segment of address) if (typeof segment !== "string") return void 0;
+	profile.address.arrayCopied();
+	const owned = Object.freeze(address.slice());
+	const path = pathFor(schema, owned, document);
+	return path === void 0 ? void 0 : {
+		path,
+		address: owned
+	};
+};
+const nodeAt = (schema, address, document) => {
+	let node = schemaRoot$1(schema);
+	let value = document;
+	for (const segment of address) {
+		node = step(node, value, segment).node;
+		value = readSegment(value, segment);
+		if (!node) return void 0;
+	}
+	return unwrap(node);
+};
+const readSegment = (value, segment) => {
+	if (!isRecord$1(value) && !Array.isArray(value)) return void 0;
+	if (isRecord$1(value) && "byId" in value && isRecord$1(value.byId)) {
+		const entity = value.byId[segment];
+		if (entity !== void 0 || Object.prototype.hasOwnProperty.call(value.byId, segment)) return entity;
+	}
+	return value[segment];
+};
+const read = (root, address) => {
+	let value = root;
+	for (const segment of address) {
+		value = readSegment(value, segment);
+		if (value === void 0) return void 0;
+	}
+	return value;
+};
+/** Resolves schema and document location in one address traversal. */
+const resolveLocated = (schema, root, address) => {
+	if (address.length === 0) return void 0;
+	let node = schemaRoot$1(schema);
+	let current = root;
+	let collection;
+	let addressHash = 2166136261;
+	for (let index = 0; index < address.length - 1; index += 1) {
+		profile.address.schemaStep();
+		profile.address.documentStep();
+		const resolved = step(node, current, address[index]);
+		if (!resolved.node) return void 0;
+		if (node?.kind === "table" || node?.kind === "map") collection = {
+			address: address.slice(0, index),
+			addressHash,
+			id: address[index],
+			...collection ? { parent: collection } : {}
+		};
+		addressHash = appendAddressHash(addressHash, address[index]);
+		node = resolved.node;
+		current = readSegment(current, address[index]);
+		if (!node) return void 0;
+	}
+	profile.address.schemaStep();
+	profile.address.documentStep();
+	const last = address[address.length - 1];
+	const resolved = step(node, current, last);
+	if (!resolved.node || !isRecord$1(current) && !Array.isArray(current)) return void 0;
+	if (node?.kind === "table" || node?.kind === "map") collection = {
+		address: address.slice(0, -1),
+		addressHash,
+		id: last,
+		...collection ? { parent: collection } : {}
+	};
+	addressHash = appendAddressHash(addressHash, last);
+	if (isRecord$1(current) && "byId" in current && isRecord$1(current.byId) && last in current.byId) return {
+		addressHash,
+		node: resolved.node,
+		parent: current.byId,
+		key: last,
+		value: current.byId[last],
+		...collection ? { collection } : {}
+	};
+	return {
+		addressHash,
+		node: resolved.node,
+		parent: current,
+		key: Array.isArray(current) && /^\d+$/.test(last) ? Number(last) : last,
+		value: readSegment(current, last),
+		...collection ? { collection } : {}
+	};
+};
+const locate = (root, address) => {
+	if (address.length === 0) return void 0;
+	let current = root;
+	for (let index = 0; index < address.length - 1; index += 1) current = readSegment(current, address[index]);
+	if (!isRecord$1(current) && !Array.isArray(current)) return void 0;
+	const last = address[address.length - 1];
+	if (isRecord$1(current) && "byId" in current && isRecord$1(current.byId) && last in current.byId) return {
+		parent: current.byId,
+		key: last,
+		value: current.byId[last]
+	};
+	return {
+		parent: current,
+		key: Array.isArray(current) && /^\d+$/.test(last) ? Number(last) : last,
+		value: readSegment(current, last)
+	};
+};
+const set = (root, address, value) => {
+	const target = locate(root, address);
+	if (!target) return false;
+	target.parent[target.key] = value;
+	return true;
+};
+const contains = (parent, child) => {
+	profile.address.prefixComparison();
+	if (parent.length > child.length) return false;
+	for (let index = 0; index < parent.length; index += 1) {
+		profile.address.segmentCompared();
+		if (parent[index] !== child[index]) return false;
+	}
+	return true;
+};
+const overlaps = (a, b) => contains(a, b) || contains(b, a);
+const debugKey = (address) => {
+	let result = "";
+	for (let index = 0; index < address.length; index += 1) {
+		if (index > 0) result += "/";
+		result += address[index].replaceAll("~", "~~").replaceAll("/", "~/");
+	}
+	return result;
+};
+//#endregion
+//#region core/src/impact-target.ts
+var impact_target_exports = /* @__PURE__ */ __exportAll({
+	address: () => address,
+	belongs: () => belongs,
+	bucket: () => bucket,
+	id: () => id,
+	same: () => same
+});
+const address = (target) => "at" in target ? target.at : target.address;
+const id = (target) => target.kind === "collection" && "id" in target ? target.id : void 0;
+const belongs = (target, schema) => !("schema" in target) || target.schema === schema;
+const same = (left, right) => {
+	if (left.kind !== right.kind) return false;
+	if ("schema" in left && "schema" in right && left.schema !== right.schema) return false;
+	const leftAddress = address(left);
+	const rightAddress = address(right);
+	if (leftAddress.length !== rightAddress.length) return false;
+	for (let index = 0; index < leftAddress.length; index += 1) if (leftAddress[index] !== rightAddress[index]) return false;
+	return left.kind !== "collection" || id(left) === id(right);
+};
+const bucket = (target) => address(target)[0];
+//#endregion
+//#region core/src/value/ownership.ts
+const stablePayloads = /* @__PURE__ */ new WeakSet();
+const markStablePayload = (value) => {
+	if (Array.isArray(value) || isPlainObject(value)) stablePayloads.add(value);
+	return value;
+};
+const isStablePayload = (value) => (Array.isArray(value) || isPlainObject(value)) && stablePayloads.has(value);
+const isPlainObject = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+const countCloneReason = (reason) => {
+	if (reason) profile.clone.node(reason);
+};
+const cloneValue = (value, reason) => {
+	profile.clone.call();
+	countCloneReason(reason);
+	if (Array.isArray(value)) {
+		profile.clone.container();
+		const result = new Array(value.length);
+		for (let index = 0; index < value.length; index += 1) result[index] = cloneValue(value[index], reason);
+		return reason === "commit" || reason === "inverse" ? markStablePayload(Object.freeze(result)) : result;
+	}
+	if (isPlainObject(value)) {
+		profile.clone.container();
+		const result = Object.create(Object.getPrototypeOf(value));
+		for (const key in value) if (Object.prototype.hasOwnProperty.call(value, key)) result[key] = cloneValue(value[key], reason);
+		return reason === "commit" || reason === "inverse" ? markStablePayload(Object.freeze(result)) : result;
+	}
+	return value;
+};
+const ownPayload = (value, reason = "canonical") => Array.isArray(value) || isPlainObject(value) ? cloneValue(value, reason) : value;
+const transferPayload = (value) => {
+	profile.batch.payloadTransferred();
+	return value;
+};
+const snapshotPayload = (value, reason = "commit") => (profile.batch.payloadSnapshot(), ownPayload(value, reason));
+const operationOwnsStructuralPayload = (operation) => operation.type === "variant.replace" || operation.type === "dict.replace" || operation.type === "entity.create" || operation.type === "list.insert" || operation.type === "list.replace" || operation.type === "tree.replace";
+const deepEqual = (left, right) => {
+	profile.clone.deepEqual();
+	if (Object.is(left, right)) return true;
+	if (Array.isArray(left) && Array.isArray(right)) {
+		profile.clone.deepEqualContainer();
+		if (left.length !== right.length) return false;
+		for (let index = 0; index < left.length; index += 1) if (!deepEqual(left[index], right[index])) return false;
+		return true;
+	}
+	if (isPlainObject(left) && isPlainObject(right)) {
+		profile.clone.deepEqualContainer();
+		const leftKeys = Object.keys(left);
+		if (leftKeys.length !== Object.keys(right).length) return false;
+		for (const key of leftKeys) if (!Object.prototype.hasOwnProperty.call(right, key) || !deepEqual(left[key], right[key])) return false;
+		return true;
+	}
+	return false;
+};
+const sameStructuralValue = (left, right) => Object.is(left, right) || (Array.isArray(left) || isPlainObject(left)) && deepEqual(left, right);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+//#endregion
+//#region core/src/access/reader.ts
+const schemaRoot = (schema) => object(schema.shape);
+const assertActive = (context) => {
+	if (!context.active()) throw new Error("Document reader is no longer active.");
+};
+const readAt = (context, address) => {
+	assertActive(context);
+	profile.reader.lookup();
+	return read(context.root(), address);
+};
+const collectValue = (context, address) => {
+	context.dependencies?.record({
+		kind: "value",
+		at: address
+	});
+};
+const collectCollection = (context, address, id) => {
+	const target = {
+		kind: "collection",
+		at: address,
+		...id === void 0 ? {} : { id }
+	};
+	context.dependencies?.record(target);
+};
+const readerFor = (node, context, address = []) => {
+	if (node.kind === "field") return { get: () => {
+		collectValue(context, address);
+		return readAt(context, address);
+	} };
+	if (node.kind === "dict" || node.kind === "record") return { get: () => {
+		collectValue(context, address);
+		profile.reader.structuralSnapshot();
+		return cloneValue(readAt(context, address), "reader");
+	} };
+	if (node.kind === "list") return {
+		values: () => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			profile.reader.structuralSnapshot();
+			return cloneValue(Array.isArray(value) ? value : [], "reader");
+		},
+		length: () => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return Array.isArray(value) ? value.length : 0;
+		},
+		at: (index) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			profile.reader.structuralSnapshot();
+			return cloneValue(Array.isArray(value) ? value[index] : void 0, "reader");
+		}
+	};
+	if (node.kind === "tree") return {
+		rootId: () => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return isRecord(value) && typeof value.rootId === "string" ? value.rootId : void 0;
+		},
+		has: (id) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return isRecord(value) && isRecord(value.nodes) && Object.prototype.hasOwnProperty.call(value.nodes, id);
+		},
+		value: (id) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			profile.reader.structuralSnapshot();
+			return cloneValue(isRecord(value) && isRecord(value.nodes) && isRecord(value.nodes[id]) ? value.nodes[id].value : void 0, "reader");
+		},
+		parent: (id) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			const entry = isRecord(value) && isRecord(value.nodes) ? value.nodes[id] : void 0;
+			return isRecord(entry) && typeof entry.parentId === "string" ? entry.parentId : void 0;
+		},
+		children: (id) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			const entry = isRecord(value) && isRecord(value.nodes) ? value.nodes[id] : void 0;
+			return isRecord(entry) && Array.isArray(entry.children) ? [...entry.children] : [];
+		}
+	};
+	if (node.kind === "table" || node.kind === "map") {
+		let items;
+		return {
+			ids: () => {
+				collectCollection(context, address);
+				const value = readAt(context, address);
+				const ids = node.kind === "table" && isRecord(value) && Array.isArray(value.ids) ? [...value.ids] : isRecord(value) ? Object.keys(value) : [];
+				profile.reader.collectionIds(ids.length);
+				return ids;
+			},
+			has: (id) => {
+				collectCollection(context, address, id);
+				const value = readAt(context, address);
+				const byId = node.kind === "table" && isRecord(value) && isRecord(value.byId) ? value.byId : value;
+				return isRecord(byId) && Object.prototype.hasOwnProperty.call(byId, id);
+			},
+			get: (id) => {
+				collectCollection(context, address, id);
+				const value = readAt(context, address);
+				const byId = node.kind === "table" && isRecord(value) && isRecord(value.byId) ? value.byId : value;
+				if (!isRecord(byId) || !Object.prototype.hasOwnProperty.call(byId, id)) return void 0;
+				const cached = items?.get(id);
+				if (cached) return cached;
+				const reader = readerFor(node.value, context, [...address, id]);
+				(items ??= /* @__PURE__ */ new Map()).set(id, reader);
+				return reader;
+			}
+		};
+	}
+	if (node.kind === "single") return readerFor(node.value, context, address);
+	if (node.kind === "variant") return new Proxy({}, { get: (_target, property) => {
+		if (typeof property === "symbol") return void 0;
+		const value = readAt(context, address);
+		const tag = isRecord(value) && typeof value[node.tag] === "string" ? String(value[node.tag]) : void 0;
+		const child = (tag ? node.variants[tag] : void 0)?.shape[property];
+		return child ? readerFor(child, context, [...address, property]) : void 0;
+	} });
+	let children;
+	return new Proxy({}, { get: (_target, property) => {
+		if (typeof property === "symbol") return void 0;
+		const child = node.shape[property];
+		if (!child) return void 0;
+		const cached = children?.get(property);
+		if (cached) return cached;
+		const reader = readerFor(child, context, [...address, property]);
+		(children ??= /* @__PURE__ */ new Map()).set(property, reader);
+		return reader;
+	} });
+};
+const documentReader = (schema, root, active, dependencies) => {
+	profile.reader.session();
+	return readerFor(schemaRoot(schema), {
+		root,
+		active,
+		dependencies
+	});
+};
+//#endregion
+//#region core/src/runtime/contract.ts
+var DocumentReentrancyError = class extends Error {
+	constructor() {
+		super("Document writes cannot be re-entered during an update or notification.");
+		this.name = "DocumentReentrancyError";
+	}
+};
+var DocumentDisposedError = class extends Error {
+	constructor() {
+		super("Doxum runtime has been disposed.");
+		this.name = "DocumentDisposedError";
+	}
+};
+//#endregion
+//#region core/src/runtime/access.ts
+const states = /* @__PURE__ */ new WeakMap();
+const bindRuntimeAccess = (runtime, state) => {
+	states.set(runtime, state);
+};
+const accessOf = (runtime) => {
+	const state = states.get(runtime);
+	if (!state) throw new Error("Unknown Doxum runtime.");
+	return state;
+};
+const schemaOf = (runtime) => accessOf(runtime).schema;
+const documentOf = (runtime) => accessOf(runtime).document;
+const readWith = (runtime, run, dependencies) => {
+	const state = accessOf(runtime);
+	if (state.disposed) throw new DocumentDisposedError();
+	let active = true;
+	const reader = documentReader(state.schema, () => state.document, () => active, dependencies);
+	try {
+		return run(reader);
+	} finally {
+		active = false;
+	}
+};
+//#endregion
+//#region core/src/access/dependency.ts
+const createDependencyTracker = () => {
+	const targets = [];
+	return {
+		record: (value) => {
+			if (!targets.some((entry) => same(entry, value))) targets.push(value);
+		},
+		clear: () => {
+			targets.length = 0;
+		},
+		size: () => targets.length,
+		some: (test) => targets.some(test),
+		snapshot: () => Object.freeze(targets.slice())
+	};
+};
+//#endregion
+export { resolveAddress as A, record as B, impact_target_exports as C, nodeAt as D, locate as E, field as F, variant as G, single as H, list as I, map as L, set as M, profile as N, overlaps as O, dict as P, object as R, id as S, debugKey as T, table as U, schema as V, tree as W, snapshotPayload as _, schemaOf as a, belongs as b, documentReader as c, deepEqual as d, isRecord as f, sameStructuralValue as g, ownPayload as h, readWith as i, resolveLocated as j, read as k, readerFor as l, operationOwnsStructuralPayload as m, bindRuntimeAccess as n, DocumentDisposedError as o, isStablePayload as p, documentOf as r, DocumentReentrancyError as s, createDependencyTracker as t, cloneValue as u, transferPayload as v, contains as w, bucket as x, address as y, optional as z };
+
+//# sourceMappingURL=dependency-BdEMyquf.js.map