process-graph 1.3.0 → 2.0.0

package/dist/{store-DKzvLGgl.js → store-CgweIG8J.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as validateOverlay, c as fragmentOperators, d as overlayStatuses, f as participantKinds, l as messageModes, p as pseudoRoles, r as overlaySchema, s as elementKinds, t as modelSchema, u as notations } from "./schema-BPT8fmfa.js";
+import { c as elementKinds, d as notations, f as overlayStatuses, i as overlaySchema, l as fragmentOperators, m as pseudoRoles, n as modelSchema, o as validateOverlay, p as participantKinds, t as boundActivitySchema, u as messageModes } from "./schema-CL95Lyni.js";
 import { t as validate } from "./validate-DF3mQZww.js";
 import { r as loopTransitions, s as emptyFactRecord } from "./control-DiygoEhm.js";
 import { z } from "zod";
@@ -11,21 +11,12 @@ import { index, integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlit
 * The model's own record schemas, taken from `modelSchema` rather than restated, so what the store accepts is exactly a model or a slice of one and can never drift from it.
 */
 const modelShape = modelSchema.unwrap().shape;
-/** The model's `activity` element: the first variant of its element union. A type test pins the order, so reordering the union is a compile error. */
-const [activityElementSchema] = modelShape.elements.unwrap().element.options;
 /** The name a store files a model under. Any non-empty string; the store gives it no structure. */
 const modelIdSchema = z.string().min(1);
 /**
 * A position in the store's history. Every change to any model takes the next revision from one store-wide sequence, so revisions only grow, a model's revision is the revision of its last change, and a model deleted and saved again never reuses an earlier one.
 */
 const revisionSchema = z.int().positive();
-/**
-* An activity bound to the external record it stands for. `source` is required here, where the model leaves it optional: a bound item's identity is its source record, and the source-qualified identifier is its element id.
-*/
-const boundActivitySchema = activityElementSchema.unwrap().extend({ source: z.string().min(1) }).refine((activity) => activity.id === activity.source, {
-	message: "a bound activity's id must equal its source",
-	path: ["id"]
-}).readonly();
 /** The relation kinds a store keeps beside a model, the same kinds a source reports. */
 const relationKinds = [
 	"child-of",
@@ -41,7 +32,7 @@ const relationSchema = z.strictObject({
 	to: z.string().min(1)
 }).readonly();
 /**
-* Items read from a source, to be merged into a stored model by identifier. Each participant, activity and transition replaces the one with the same id or is appended after the existing ones; the overlay's entries replace the run state of the elements they name; each relation not already stored is appended. Everything else in the model is left as it is.
+* Items read from a source, to be merged into a stored model by identifier. Activities are graph-schema's `boundActivitySchema`, the same schema a source's sync page uses, so a page's items pass unchanged. Each participant, activity and transition replaces the one with the same id or is appended after the existing ones; the overlay's entries replace the run state of the elements they name; each relation not already stored is appended. Everything else in the model is left as it is.
 */
 const boundItemsSchema = z.strictObject({
 	participants: z.array(modelShape.participants.unwrap().element).readonly(),
@@ -1499,4 +1490,4 @@ const createSqliteGraphStore = (options) => {
 	};
 };
 //#endregion
-export { modelIdSchema as A, boundItemsSchema as C, factNameSchema as D, factClearingSchema as E, revisionSchema as F, storeChangeSchema as I, storedFactsSchema as L, reachSchema as M, relationKinds as N, factRecordSchema as O, relationSchema as P, storedModelSchema as R, boundActivitySchema as S, factChangeSchema as T, mergeBoundItems as _, ancestorsOf as a, defaultSubscriptionCapacity as b, mergeRelations as c, factIssues as d, factsWithin as f, emptyModel as g, checkStored as h, serialised as i, modelSummarySchema as j, issueSchema as k, relationIssues as l, withoutFacts as m, tables_exports as n, childrenOf as o, mergeFacts as p, migrate as r, descendantsOf as s, createSqliteGraphStore as t, relationsWithin as u, overlayWithin as v, changeKinds as w, GraphStoreError as x, ChangeFeed as y };
+export { modelSummarySchema as A, changeKinds as C, factRecordSchema as D, factNameSchema as E, storeChangeSchema as F, storedFactsSchema as I, storedModelSchema as L, relationKinds as M, relationSchema as N, issueSchema as O, revisionSchema as P, boundItemsSchema as S, factClearingSchema as T, mergeBoundItems as _, ancestorsOf as a, defaultSubscriptionCapacity as b, mergeRelations as c, factIssues as d, factsWithin as f, emptyModel as g, checkStored as h, serialised as i, reachSchema as j, modelIdSchema as k, relationIssues as l, withoutFacts as m, tables_exports as n, childrenOf as o, mergeFacts as p, migrate as r, descendantsOf as s, createSqliteGraphStore as t, relationsWithin as u, overlayWithin as v, factChangeSchema as w, GraphStoreError as x, ChangeFeed as y };

package/dist/store.d.ts

@@ -1,4 +1,4 @@
-import { $ as factRecordSchema, A as defaultSubscriptionCapacity, B as Reach, C as ElementRequest, D as ChangeFeedOptions, E as ChangeFeed, F as ChangeKind, G as StoredFacts, H as RelationKind, I as FactChange, J as boundItemsSchema, K as StoredModel, L as FactClearing, M as GraphStoreFailure, N as BoundActivity, O as ChangeSubscription, P as BoundItems, Q as factNameSchema, R as ModelId, S as overlayWithin, T as ModelRequest, U as Revision, V as Relation, W as StoreChange, X as factChangeSchema, Y as changeKinds, Z as factClearingSchema, _ as mergeFacts, a as blockedChainOf, at as relationSchema, b as emptyModel, c as structureOf, ct as storedFactsSchema, d as descendantsOf, dt as graphStoreContract, et as issueSchema, f as mergeRelations, g as factsWithin, h as factIssues, i as Structure, it as relationKinds, j as GraphStoreError, k as SubscribeOptions, l as ancestorsOf, lt as storedModelSchema, m as relationsWithin, n as GraphStoreRouter, nt as modelSummarySchema, o as impactOf, ot as revisionSchema, p as relationIssues, q as boundActivitySchema, r as createGraphStoreRouter, rt as reachSchema, s as readyOf, st as storeChangeSchema, t as createFakeGraphStore, tt as modelIdSchema, u as childrenOf, ut as GraphStoreClient, v as withoutFacts, w as GraphStore, x as mergeBoundItems, y as checkStored, z as ModelSummary } from "./index-CR8xUK3S.js";
+import { $ as modelIdSchema, A as defaultSubscriptionCapacity, B as Relation, C as ElementRequest, D as ChangeFeedOptions, E as ChangeFeed, F as FactChange, G as StoredModel, H as Revision, I as FactClearing, J as factChangeSchema, K as boundItemsSchema, L as ModelId, M as GraphStoreFailure, N as BoundItems, O as ChangeSubscription, P as ChangeKind, Q as issueSchema, R as ModelSummary, S as overlayWithin, T as ModelRequest, U as StoreChange, V as RelationKind, W as StoredFacts, X as factNameSchema, Y as factClearingSchema, Z as factRecordSchema, _ as mergeFacts, a as blockedChainOf, at as storeChangeSchema, b as emptyModel, c as structureOf, ct as GraphStoreClient, d as descendantsOf, et as modelSummarySchema, f as mergeRelations, g as factsWithin, h as factIssues, i as Structure, it as revisionSchema, j as GraphStoreError, k as SubscribeOptions, l as ancestorsOf, lt as graphStoreContract, m as relationsWithin, n as GraphStoreRouter, nt as relationKinds, o as impactOf, ot as storedFactsSchema, p as relationIssues, q as changeKinds, r as createGraphStoreRouter, rt as relationSchema, s as readyOf, st as storedModelSchema, t as createFakeGraphStore, tt as reachSchema, u as childrenOf, v as withoutFacts, w as GraphStore, x as mergeBoundItems, y as checkStored, z as Reach } from "./index-KhygugOP.js";
 import { SQLiteAsyncDatabase } from "drizzle-orm/sqlite-core";
 import { MigrationMeta } from "drizzle-orm/migrator";
 //#region ../../adapters/graph/store-sqlite/dist/database.d.ts
@@ -1437,4 +1437,4 @@ declare const namedFacts: import("drizzle-orm/sqlite-core").SQLiteTableWithColum
   dialect: "sqlite";
 }>;
 //#endregion
-export { type BoundActivity, type BoundItems, ChangeFeed, type ChangeFeedOptions, type ChangeKind, type ChangeSubscription, type ElementRequest, type Exclusive, type FactChange, type FactClearing, type GraphStore, type GraphStoreClient, GraphStoreError, type GraphStoreFailure, type GraphStoreRouter, type ModelId, type ModelRequest, type ModelSummary, type Reach, type Relation, type RelationKind, type Revision, type SqliteDatabase, type SqliteGraphStoreOptions, type StoreChange, type StoredFacts, type StoredModel, type Structure, type SubscribeOptions, ancestorsOf, blockedChainOf, boundActivitySchema, boundItemsSchema, changeKinds, checkStored, childrenOf, createFakeGraphStore, createGraphStoreRouter, defaultSubscriptionCapacity, descendantsOf, emptyModel, factChangeSchema, factClearingSchema, factIssues, factNameSchema, factRecordSchema, factsWithin, graphStoreContract, impactOf, issueSchema, mergeBoundItems, mergeFacts, mergeRelations, modelIdSchema, modelSummarySchema, overlayWithin, reachSchema, readyOf, relationIssues, relationKinds, relationSchema, relationsWithin, revisionSchema, storeChangeSchema, storedFactsSchema, storedModelSchema, structureOf, tables_d_exports as tables, withoutFacts };
+export { type BoundItems, ChangeFeed, type ChangeFeedOptions, type ChangeKind, type ChangeSubscription, type ElementRequest, type Exclusive, type FactChange, type FactClearing, type GraphStore, type GraphStoreClient, GraphStoreError, type GraphStoreFailure, type GraphStoreRouter, type ModelId, type ModelRequest, type ModelSummary, type Reach, type Relation, type RelationKind, type Revision, type SqliteDatabase, type SqliteGraphStoreOptions, type StoreChange, type StoredFacts, type StoredModel, type Structure, type SubscribeOptions, ancestorsOf, blockedChainOf, boundItemsSchema, changeKinds, checkStored, childrenOf, createFakeGraphStore, createGraphStoreRouter, defaultSubscriptionCapacity, descendantsOf, emptyModel, factChangeSchema, factClearingSchema, factIssues, factNameSchema, factRecordSchema, factsWithin, graphStoreContract, impactOf, issueSchema, mergeBoundItems, mergeFacts, mergeRelations, modelIdSchema, modelSummarySchema, overlayWithin, reachSchema, readyOf, relationIssues, relationKinds, relationSchema, relationsWithin, revisionSchema, storeChangeSchema, storedFactsSchema, storedModelSchema, structureOf, tables_d_exports as tables, withoutFacts };

package/dist/store.js

@@ -1,6 +1,6 @@
 import { r as loopTransitions, s as emptyFactRecord } from "./control-DiygoEhm.js";
-import { A as modelIdSchema, C as boundItemsSchema, D as factNameSchema, E as factClearingSchema, F as revisionSchema, I as storeChangeSchema, L as storedFactsSchema, M as reachSchema, N as relationKinds, O as factRecordSchema, P as relationSchema, R as storedModelSchema, S as boundActivitySchema, T as factChangeSchema, _ as mergeBoundItems, a as ancestorsOf, b as defaultSubscriptionCapacity, c as mergeRelations, d as factIssues, f as factsWithin, g as emptyModel, h as checkStored, i as serialised, j as modelSummarySchema, k as issueSchema, l as relationIssues, m as withoutFacts, n as tables_exports, o as childrenOf, p as mergeFacts, r as migrate, s as descendantsOf, t as createSqliteGraphStore, u as relationsWithin, v as overlayWithin, w as changeKinds, x as GraphStoreError, y as ChangeFeed } from "./store-DKzvLGgl.js";
-import { n as graphStoreContract, t as createGraphStoreRouter } from "./router-Dk91O_9p.js";
+import { A as modelSummarySchema, C as changeKinds, D as factRecordSchema, E as factNameSchema, F as storeChangeSchema, I as storedFactsSchema, L as storedModelSchema, M as relationKinds, N as relationSchema, O as issueSchema, P as revisionSchema, S as boundItemsSchema, T as factClearingSchema, _ as mergeBoundItems, a as ancestorsOf, b as defaultSubscriptionCapacity, c as mergeRelations, d as factIssues, f as factsWithin, g as emptyModel, h as checkStored, i as serialised, j as reachSchema, k as modelIdSchema, l as relationIssues, m as withoutFacts, n as tables_exports, o as childrenOf, p as mergeFacts, r as migrate, s as descendantsOf, t as createSqliteGraphStore, u as relationsWithin, v as overlayWithin, w as factChangeSchema, x as GraphStoreError, y as ChangeFeed } from "./store-CgweIG8J.js";
+import { n as graphStoreContract, t as createGraphStoreRouter } from "./router-DzVcQ28U.js";
 //#region ../../core/graph/store-contract/dist/structure.js
 /**
 * Whether an element is a pure control element: a `decision` or a pseudo-state. Control elements have no work of their own, so the structural queries pass through them and never report them.
@@ -269,4 +269,4 @@ const createFakeGraphStore = () => {
 	};
 };
 //#endregion
-export { ChangeFeed, GraphStoreError, ancestorsOf, blockedChainOf, boundActivitySchema, boundItemsSchema, changeKinds, checkStored, childrenOf, createFakeGraphStore, createGraphStoreRouter, createSqliteGraphStore, defaultSubscriptionCapacity, descendantsOf, emptyModel, factChangeSchema, factClearingSchema, factIssues, factNameSchema, factRecordSchema, factsWithin, graphStoreContract, impactOf, issueSchema, mergeBoundItems, mergeFacts, mergeRelations, migrate, modelIdSchema, modelSummarySchema, overlayWithin, reachSchema, readyOf, relationIssues, relationKinds, relationSchema, relationsWithin, revisionSchema, serialised, storeChangeSchema, storedFactsSchema, storedModelSchema, structureOf, tables_exports as tables, withoutFacts };
+export { ChangeFeed, GraphStoreError, ancestorsOf, blockedChainOf, boundItemsSchema, changeKinds, checkStored, childrenOf, createFakeGraphStore, createGraphStoreRouter, createSqliteGraphStore, defaultSubscriptionCapacity, descendantsOf, emptyModel, factChangeSchema, factClearingSchema, factIssues, factNameSchema, factRecordSchema, factsWithin, graphStoreContract, impactOf, issueSchema, mergeBoundItems, mergeFacts, mergeRelations, migrate, modelIdSchema, modelSummarySchema, overlayWithin, reachSchema, readyOf, relationIssues, relationKinds, relationSchema, relationsWithin, revisionSchema, serialised, storeChangeSchema, storedFactsSchema, storedModelSchema, structureOf, tables_exports as tables, withoutFacts };

package/dist/sync-CkaJO3OQ.js

@@ -0,0 +1,213 @@
+import { ORPCError } from "@orpc/client";
+//#region ../../core/graph/sync/dist/scopes.js
+/** The separator between a scope's source prefix and the rest, as in `github:owner/repo`. */
+const sourceSeparator = ":";
+/** Thrown for a scope that names no source: it has no prefix before a colon. */
+var InvalidScopeError = class extends Error {
+	/** The scope as it was given. */
+	scope;
+	/**
+	* @param scope - The scope that names no source.
+	*/
+	constructor(scope) {
+		super(`"${scope}" is not a scope: write <source>:<scope>, such as github:owner/repo`);
+		this.name = "InvalidScopeError";
+		this.scope = scope;
+	}
+};
+/**
+* Groups source-qualified scopes by their source prefix, keeping each prefix where it first appears and each source's scopes in the order given. A sync reads the groups in this order, one source after another.
+* @param scopes - Source-qualified scopes, such as `github:owner` or `github:owner/repo`.
+* @returns One group per source prefix.
+* @throws InvalidScopeError for a scope with nothing before its first colon, or no colon at all.
+*/
+const scopesBySource = (scopes) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const scope of scopes) {
+		const separator = scope.indexOf(sourceSeparator);
+		if (separator <= 0) throw new InvalidScopeError(scope);
+		const prefix = scope.slice(0, separator);
+		groups.set(prefix, [...groups.get(prefix) ?? [], scope]);
+	}
+	return [...groups].map(([prefix, grouped]) => ({
+		prefix,
+		scopes: grouped
+	}));
+};
+//#endregion
+//#region ../../core/graph/sync/dist/sync.js
+/** Thrown when a scope names a source no reader serves. */
+var UnknownSourceError = class extends Error {
+	/** The source prefix no reader serves. */
+	prefix;
+	/**
+	* @param prefix - The source prefix no reader serves.
+	*/
+	constructor(prefix) {
+		super(`No source reads "${prefix}" scopes.`);
+		this.name = "UnknownSourceError";
+		this.prefix = prefix;
+	}
+};
+/**
+* Thrown by `syncScopes` when a source fails while it is being read: opening its stream or reading a page. Its message is the source's, its cause is what the source threw, and where to carry on is data in `resume` and `remaining`. A failure of the store, or of the request itself (an unknown source, a malformed scope), is thrown as it is.
+*/
+var InterruptedSyncError = class extends Error {
+	resume;
+	remaining;
+	saved;
+	/**
+	* @param interruption - Where the sync carries on.
+	* @param cause - What the source threw.
+	*/
+	constructor(interruption, cause) {
+		super(cause instanceof Error ? cause.message : String(cause), { cause });
+		this.name = "InterruptedSyncError";
+		this.resume = interruption.resume;
+		this.remaining = interruption.remaining;
+		this.saved = interruption.saved;
+	}
+};
+/** The oRPC client options carrying a signal, leaving the key out when there is none, since the options type does not accept an explicit `undefined`. */
+const callOptions = (signal) => signal === void 0 ? {} : { signal };
+/** The identifiers of the elements and participants a model in the store already has, or none when the store has no such model. */
+const storedIdentifiers = async (store, modelId, signal) => {
+	try {
+		const stored = await store.v1.models.load({ modelId }, callOptions(signal));
+		return /* @__PURE__ */ new Set([...stored.model.elements.map((element) => element.id), ...stored.model.participants.map((participant) => participant.id)]);
+	} catch (error) {
+		if (error instanceof ORPCError && error.code === "NOT_FOUND") return /* @__PURE__ */ new Set();
+		throw error;
+	}
+};
+const relationKey = (relation) => JSON.stringify([
+	relation.kind,
+	relation.from,
+	relation.to
+]);
+/** Splits what is waiting to be written into what can be written now, whose ends are all known, and what must wait for a later page. */
+const settle = (pending, endsOf, known, last) => {
+	const ready = pending.filter((item) => last || endsOf(item).every((id) => known.has(id)));
+	return {
+		ready,
+		held: pending.filter((item) => !ready.includes(item))
+	};
+};
+/**
+* Reads the scopes from their sources page by page and merges each page into the stored model as soon as it is read: participants, bound activities, transitions, relations and run state. Progress is kept as it is made, so a sync that is cancelled, rate limited or interrupted leaves everything it read in the store, and a checkpoint to carry on from.
+*
+* A store rejects a write that leaves a transition or a relation naming an element or participant the model lacks, and a source may report a dependency or a sub-issue whose other end a later page brings. A transition or relation is therefore held back until the model has both of its ends, and written with the page that completes it. One whose end never arrives is written with the last page, where the store's rejection says which reference is missing.
+* @param request - The store, sources, model, scopes, an optional filter and checkpoint, the signal and a progress listener.
+* @returns The final progress, with no checkpoint.
+* @throws InvalidScopeError for a scope that names no source; UnknownSourceError for a scope whose source no reader serves; an Error for a checkpoint naming a source none of the scopes use, and for a sync of no scopes; InterruptedSyncError, after the pages before it are written, when a source fails while it is read, an abort included; and whatever the store throws.
+*/
+const syncScopes = async (request) => {
+	const { store, sources, modelId, scopes, filter, resume, signal } = request;
+	const groups = scopesBySource(scopes).map((group) => {
+		const client = sources(group.prefix);
+		if (client === void 0) throw new UnknownSourceError(group.prefix);
+		return {
+			...group,
+			client
+		};
+	});
+	if (groups.length === 0) throw new Error("A sync needs at least one scope.");
+	const startGroup = resume === void 0 ? 0 : groups.findIndex((group) => group.prefix === resume.source);
+	if (startGroup === -1) throw new Error("The checkpoint names a source that none of the scopes use; start the sync again.");
+	const known = new Set(await storedIdentifiers(store, modelId, signal));
+	const written = {
+		participants: /* @__PURE__ */ new Set(),
+		activities: /* @__PURE__ */ new Set(),
+		transitions: /* @__PURE__ */ new Set(),
+		relations: /* @__PURE__ */ new Set()
+	};
+	const gaps = [];
+	let heldTransitions = [];
+	let heldRelations = [];
+	let pages = 0;
+	let latest;
+	const checkpointAt = (source, after) => ({
+		modelId,
+		scopes,
+		...filter === void 0 ? {} : { filter },
+		source,
+		...after === void 0 ? {} : { after }
+	});
+	const write = async (page, checkpoint) => {
+		for (const record of [...page.participants, ...page.activities]) known.add(record.id);
+		const last = checkpoint === void 0;
+		const transitions = settle([...heldTransitions, ...page.transitions], (transition) => [transition.source, transition.target], known, last);
+		const relations = settle([...heldRelations, ...page.relations], (relation) => [relation.from, relation.to], known, last);
+		heldTransitions = transitions.held;
+		heldRelations = relations.held;
+		const { revision } = await store.v1.items.upsert({
+			modelId,
+			items: {
+				participants: page.participants,
+				activities: page.activities,
+				transitions: transitions.ready,
+				relations: relations.ready,
+				overlay: page.overlay
+			}
+		}, callOptions(signal));
+		pages += 1;
+		for (const participant of page.participants) written.participants.add(participant.id);
+		for (const activity of page.activities) written.activities.add(activity.id);
+		for (const transition of transitions.ready) written.transitions.add(transition.id);
+		for (const relation of relations.ready) written.relations.add(relationKey(relation));
+		gaps.push(...page.gaps);
+		latest = {
+			pages,
+			revision,
+			participants: written.participants.size,
+			activities: written.activities.size,
+			transitions: written.transitions.size,
+			relations: written.relations.size,
+			gaps: [...gaps],
+			checkpoint
+		};
+		request.onProgress?.(latest);
+	};
+	/** Reads the sources in order, each only after the one before has finished, since a source's failure must stop the ones after it. */
+	const readFrom = async (index) => {
+		const group = groups[index];
+		if (group === void 0) return;
+		let after = index === startGroup ? resume?.after : void 0;
+		const following = groups[index + 1];
+		const interrupted = (cause) => new InterruptedSyncError({
+			resume: checkpointAt(group.prefix, after),
+			remaining: groups.slice(index + 1).flatMap((next) => next.scopes),
+			saved: pages > 0
+		}, cause);
+		const iterator = (await group.client.v1.sync.stream({
+			scope: group.scopes,
+			...after === void 0 ? {} : { after },
+			...filter === void 0 ? {} : { filter }
+		}, callOptions(signal)).catch((cause) => {
+			throw interrupted(cause);
+		}))[Symbol.asyncIterator]();
+		/** Writes each page the source yields, in order, each only after the one before is written. */
+		const drain = async () => {
+			const next = await iterator.next().catch((cause) => {
+				throw interrupted(cause);
+			});
+			if (next.done === true) return;
+			const page = next.value;
+			await write(page, page.next !== void 0 ? checkpointAt(group.prefix, page.next) : following === void 0 ? void 0 : checkpointAt(following.prefix, void 0));
+			after = page.next;
+			await drain();
+		};
+		try {
+			await drain();
+		} catch (error) {
+			await iterator.return();
+			throw error;
+		}
+		await readFrom(index + 1);
+	};
+	await readFrom(startGroup);
+	if (latest === void 0) throw new Error("unreachable: every source answers a sync with at least one page");
+	return latest;
+};
+//#endregion
+export { scopesBySource as a, InvalidScopeError as i, UnknownSourceError as n, syncScopes as r, InterruptedSyncError as t };

package/dist/sync.d.ts

@@ -0,0 +1,26 @@
+import { a as SyncRequest, c as syncScopes, i as SyncProgress, l as SyncCheckpoint, n as SourceLookup, o as SyncStore, r as SyncInterruption, s as UnknownSourceError, t as InterruptedSyncError, u as syncCheckpointSchema } from "./index-7nV7hCmv.js";
+//#region ../../core/graph/sync/dist/scopes.d.ts
+/** The scopes of one source, in the order they were given. */
+interface SourceScopes {
+  /** The source's identifier prefix, such as `github`. */
+  readonly prefix: string;
+  readonly scopes: readonly string[];
+}
+/** Thrown for a scope that names no source: it has no prefix before a colon. */
+export declare class InvalidScopeError extends Error {
+  /** The scope as it was given. */
+  readonly scope: string;
+  /**
+   * @param scope - The scope that names no source.
+   */
+  constructor(scope: string);
+}
+/**
+ * Groups source-qualified scopes by their source prefix, keeping each prefix where it first appears and each source's scopes in the order given. A sync reads the groups in this order, one source after another.
+ * @param scopes - Source-qualified scopes, such as `github:owner` or `github:owner/repo`.
+ * @returns One group per source prefix.
+ * @throws InvalidScopeError for a scope with nothing before its first colon, or no colon at all.
+ */
+export declare const scopesBySource: (scopes: readonly string[]) => readonly SourceScopes[];
+//#endregion
+export { InterruptedSyncError, type SourceLookup, type SourceScopes, type SyncCheckpoint, type SyncInterruption, type SyncProgress, type SyncRequest, type SyncStore, UnknownSourceError, syncCheckpointSchema, syncScopes };

package/dist/sync.js

@@ -0,0 +1,16 @@
+import { h as syncFilterSchema } from "./schema-DMXa8gAZ.js";
+import { a as scopesBySource, i as InvalidScopeError, n as UnknownSourceError, r as syncScopes, t as InterruptedSyncError } from "./sync-CkaJO3OQ.js";
+import { z } from "zod";
+//#region ../../core/graph/sync/dist/checkpoint.js
+/**
+* Where a sync stopped: the model, every scope it was asked for in order, the filter it read them with, the prefix of the source to read next, and the cursor after the last page it wrote within that source's scopes (absent to read them from the start). Everything before it is in the store, so a sync started from it reads only what is left. A source's cursor is valid only with the scopes and filter it was issued for, which is why both are kept with it.
+*/
+const syncCheckpointSchema = z.strictObject({
+	modelId: z.string().min(1),
+	scopes: z.array(z.string().min(1)).readonly(),
+	filter: syncFilterSchema.optional(),
+	source: z.string().min(1),
+	after: z.string().min(1).optional()
+}).readonly();
+//#endregion
+export { InterruptedSyncError, InvalidScopeError, UnknownSourceError, scopesBySource, syncCheckpointSchema, syncScopes };

package/dist/ui.d.ts

@@ -1,7 +1,7 @@
-import { B as Status } from "./index-D4CnOhNf.js";
-import { K as IdSpace } from "./index-Dvz_I_uQ.js";
-import { g as SequenceDiagram$1 } from "./index-D06bcdfw.js";
-import { f as LaneProps, h as TransitionItemProps, l as LegendProps, o as FilterPanelProps, r as DetailPanelProps, v as ElementCardProps } from "./index-9Au8pAmP.js";
+import { B as Status } from "./index-wQnLXJmD.js";
+import { Y as IdSpace } from "./index-DYl6lZLe.js";
+import { y as SequenceDiagram$1 } from "./index-DluJZTbT.js";
+import { f as LaneProps, h as TransitionItemProps, l as LegendProps, o as FilterPanelProps, r as DetailPanelProps, v as ElementCardProps } from "./index-C-ZNF81j.js";
 import { a as lightTheme, i as darkTheme, n as darkValues, o as vars, r as lightValues, t as ThemeValues } from "./theme-values-BybZ-cle.js";
 import { ReactElement, ReactNode } from "react";
 //#region ../../ui/graph/ui/dist/base.css.d.ts

package/dist/{version-Dagrkvwt.js → version-_UOnL566.js}

@@ -1,5 +1,5 @@
 //#region src/version.ts
 /** The version of the installed `process-graph` package, as its manifest names it. The bundler writes it in when the package is built, so reading it touches no file. */
-const version = "1.3.0";
+const version = "2.0.0";
 //#endregion
 export { version as t };