process-graph 1.2.0 → 1.4.0

package/dist/source/github.js

@@ -1,5 +1,42 @@
-import { A as syncPageSchema, C as scopeChildrenInputSchema, D as sourceDescriptionSchema, E as scopeRootsInputSchema, O as syncFilterSchema, S as relationSchema, T as scopeListingSchema, _ as gapSchema, a as ownerScopeId, b as participantSchema, c as githubGraphqlEndpoint, d as paginate, f as graphSourceContract, g as gapReasons, h as filterStates, i as issueId, j as transitionSchema, k as syncInputSchema, l as assembleSync, m as boundActivitySchema, n as accountId, o as parseScope, p as badRequestReasons, r as githubSource, s as repositoryId, t as createGitHubIssuesSource, u as createGraphSourceRouter, v as orderDirections, w as scopeEntrySchema, x as relationKinds, y as orderFields } from "../source-DRDpEA8Q.js";
+import { _ as syncInputSchema, a as gapSchema, c as participantSchema, d as scopeChildrenInputSchema, f as scopeEntrySchema, g as syncFilterSchema, h as sourceDescriptionSchema, i as gapReasons, l as relationKinds, m as scopeRootsInputSchema, n as boundActivitySchema, o as orderDirections, p as scopeListingSchema, r as filterStates, s as orderFields, t as badRequestReasons, u as relationSchema, v as syncPageSchema, y as transitionSchema } from "../schema-DVAttrJg.js";
+import { a as ownerScopeId, c as githubGraphqlEndpoint, d as graphSourceContract, i as issueId, l as createGraphSourceRouter, n as accountId, o as parseScope, r as githubSource, s as repositoryId, t as createGitHubIssuesSource, u as paginate } from "../source-lTKshktI.js";
 import { t as GraphSourceError } from "../errors-BZe5WzCn.js";
+//#region ../../core/graph/source-contract/dist/assemble.js
+const relationKey = (relation) => JSON.stringify([
+	relation.kind,
+	relation.from,
+	relation.to
+]);
+/** Keeps one entry per key, in first-seen order, holding the latest value seen for it. */
+const latestById = (items, keyOf) => {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const item of items) byKey.set(keyOf(item), item);
+	return [...byKey.values()];
+};
+/**
+* Merges the pages of a sync into one model. A record can appear on several pages, for example an issue in another repository reached through a dependency before its own repository is read; identity is the identifier, so it becomes one element, and where pages disagree the later page wins, being the more recent read.
+* @param pages - The pages of one sync, in the order they arrived.
+* @returns The model, overlay, relations and gaps of the whole sync.
+*/
+const assembleSync = (pages) => {
+	const overlay = Object.fromEntries(pages.flatMap((page) => Object.entries(page.overlay)));
+	return {
+		model: {
+			participants: latestById(pages.flatMap((page) => page.participants), (participant) => participant.id),
+			events: [],
+			actions: [],
+			artefacts: [],
+			elements: latestById(pages.flatMap((page) => page.activities), (activity) => activity.id),
+			transitions: latestById(pages.flatMap((page) => page.transitions), (transition) => transition.id),
+			fragments: [],
+			projections: []
+		},
+		overlay,
+		relations: latestById(pages.flatMap((page) => page.relations), relationKey),
+		gaps: pages.flatMap((page) => page.gaps)
+	};
+};
+//#endregion
 //#region ../../core/graph/source-contract/dist/fake.js
 const gapIndex = -1;
 const cursorPattern = /^(?<scope>[^@;]+)@(?<index>-1|0|[1-9]\d*)(?:;(?<filter>.+))?$/u;

package/dist/{source-DRDpEA8Q.js → source-lTKshktI.js}

@@ -1,132 +1,9 @@
-import { r as overlaySchema, t as modelSchema } from "./schema-CVnS6HiX.js";
+import { _ as syncInputSchema, d as scopeChildrenInputSchema, g as syncFilterSchema, h as sourceDescriptionSchema, m as scopeRootsInputSchema, p as scopeListingSchema, t as badRequestReasons, v as syncPageSchema } from "./schema-DVAttrJg.js";
 import { t as GraphSourceError } from "./errors-BZe5WzCn.js";
 import { z } from "zod";
 import { eventIterator, oc } from "@orpc/contract";
 import { withEventMeta } from "@orpc/client";
 import { implement } from "@orpc/server";
-//#region ../../core/graph/source-contract/dist/schema.js
-/**
-* The model's own record schemas, taken from `modelSchema` rather than restated, so a page of a sync is exactly a slice of a model and can never drift from it.
-*/
-const modelShape = modelSchema.unwrap().shape;
-/** A participant as the model declares it: an organisation, a repository, a person. */
-const participantSchema = modelShape.participants.unwrap().element;
-/** A transition as the model declares it. A source emits one per dependency, from the prerequisite to the work that waits on it. */
-const transitionSchema = modelShape.transitions.unwrap().element;
-/** The model's `activity` element: the first variant of its element union, pinned by a type test so a reordering of the union is a compile error. */
-const [activityElementSchema] = modelShape.elements.unwrap().element.options;
-/**
-* An activity bound to the external record it stands for. `source` is required here, where the model leaves it optional, and it equals `id`: the source-qualified identifier (`github:org/repo#12`) is the element's identity, so the same record synced twice, or reached from two places, is the same element.
-*/
-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 source reports beside the model's transitions. */
-const relationKinds = [
-	"child-of",
-	"assigned-to",
-	"part-of"
-];
-/**
-* A structural link between two identifiers that the model has no field for: `child-of` from a sub-task activity to its parent activity, `assigned-to` from an activity to a person participant, `part-of` from one participant to the participant that contains it (a repository to its organisation). Relations carry no ordering, so a consumer decides whether a parent waits on its children.
-*/
-const relationSchema = z.strictObject({
-	kind: z.enum(relationKinds),
-	from: z.string().min(1),
-	to: z.string().min(1)
-}).readonly();
-/** Why part of a requested scope is missing from a sync. */
-const gapReasons = ["not-found", "forbidden"];
-/**
-* A part of the requested scope that the source could not read, reported as data so the rest of the sync still arrives. `target` is the source-qualified identifier of what is missing: a scope, a record, or one of a record's connections.
-*/
-const gapSchema = z.strictObject({
-	target: z.string().min(1),
-	reason: z.enum(gapReasons),
-	message: z.string()
-}).readonly();
-/**
-* One page of a sync: bound activities, the participants they name, the transitions between them, their relations, their run state, and any gaps. A page is a partial view; `assembleSync` merges a whole sync into one model.
-*
-* `next` is the cursor to resume after this page. It is absent on the last page.
-*/
-const syncPageSchema = z.strictObject({
-	participants: z.array(participantSchema).readonly(),
-	activities: z.array(boundActivitySchema).readonly(),
-	transitions: z.array(transitionSchema).readonly(),
-	relations: z.array(relationSchema).readonly(),
-	overlay: overlaySchema,
-	gaps: z.array(gapSchema).readonly(),
-	next: z.string().min(1).exactOptional()
-}).readonly();
-/** The run states a sync filter can select by: whether the work is still open or done. */
-const filterStates = ["open", "done"];
-/** What a sync filter can order the listed records by: when they were created, when they last changed, or how much discussion they have. */
-const orderFields = [
-	"created",
-	"updated",
-	"comments"
-];
-/** Which way a sync filter orders the listed records. */
-const orderDirections$1 = ["ascending", "descending"];
-/**
-* Narrows and orders the records each scope lists, applied on the source's side where the source supports it. Every field is optional, and an absent field does not narrow.
-*
-* - `states` keeps records whose run state is one of those given.
-* - `labels` keeps records carrying at least one of the labels given.
-* - `order` is the order the records are listed in; absent, the source's own stable order.
-*
-* A filter narrows what a scope lists, not what the listed records reach: a blocker of a listed record is read whatever its own state or labels, because it is a dependency of work the filter kept.
-*/
-const syncFilterSchema = z.strictObject({
-	states: z.array(z.enum(filterStates)).min(1).readonly().exactOptional(),
-	labels: z.array(z.string().min(1)).min(1).readonly().exactOptional(),
-	order: z.strictObject({
-		field: z.enum(orderFields),
-		direction: z.enum(orderDirections$1)
-	}).readonly().exactOptional()
-}).readonly();
-/**
-* What to sync and where to resume. `scope` names what to read as source-qualified scope identifiers (for GitHub, `github:org` for every repository an owner has, or `github:org/repo`), read in the order given. `after` is a cursor from an earlier page's `next`: the sync continues with the page that followed it. A cursor is valid only with the scope list and the filter it was issued for.
-*
-* `filter` narrows and orders what each scope lists (see `syncFilterSchema`).
-*/
-const syncInputSchema = z.strictObject({
-	scope: z.array(z.string().min(1)).min(1).readonly(),
-	after: z.string().min(1).exactOptional(),
-	filter: syncFilterSchema.exactOptional()
-}).readonly();
-/**
-* A scope a person can choose to sync, as a picker lists it. `scope` is the scope identifier to pass to `sync` (for GitHub, `github:org` for an organisation, `github:org/repo` for a repository), `label` its display name, `description` the source's own description when it has one, `url` where it lives in the source's own interface, and `archived` whether the source has archived it.
-*/
-const scopeEntrySchema = z.strictObject({
-	scope: z.string().min(1),
-	label: z.string(),
-	description: z.string().exactOptional(),
-	url: z.url().exactOptional(),
-	archived: z.boolean()
-}).readonly();
-/**
-* One page of a scope listing. `entries` are in the source's stable listing order, `gaps` name a parent the source could not read (it does not exist, or the credentials cannot see it), and `next` is the cursor to resume after this page, absent on the last.
-*/
-const scopeListingSchema = z.strictObject({
-	entries: z.array(scopeEntrySchema).readonly(),
-	gaps: z.array(gapSchema).readonly(),
-	next: z.string().min(1).exactOptional()
-}).readonly();
-/** Where a listing of the top-level scopes resumes: a cursor from an earlier page's `next`. */
-const scopeRootsInputSchema = z.strictObject({ after: z.string().min(1).exactOptional() }).readonly();
-/** The scope whose child scopes to list (for GitHub, the repositories of `github:owner`), and where to resume. A cursor is valid only for the parent it was issued for. */
-const scopeChildrenInputSchema = z.strictObject({
-	scope: z.string().min(1),
-	after: z.string().min(1).exactOptional()
-}).readonly();
-/** What a source says about itself. `source` is the prefix of every identifier it emits, before the colon. */
-const sourceDescriptionSchema = z.strictObject({ source: z.string().regex(/^[a-z][a-z0-9-]*$/u) }).readonly();
-/** Why a request was rejected as malformed. */
-const badRequestReasons = ["invalid-cursor", "invalid-scope"];
-//#endregion
 //#region ../../core/graph/source-contract/dist/contract.js
 /**
 * The typed errors every procedure can end with, each carrying its detail as data. The codes are oRPC's common codes, so an HTTP transport answers with the matching status (401, 429, 400) without any per-transport mapping.
@@ -286,42 +163,6 @@ const createGraphSourceRouter = (pager) => os.router({ v1: {
 	}
 } });
 //#endregion
-//#region ../../core/graph/source-contract/dist/assemble.js
-const relationKey = (relation) => JSON.stringify([
-	relation.kind,
-	relation.from,
-	relation.to
-]);
-/** Keeps one entry per key, in first-seen order, holding the latest value seen for it. */
-const latestById = (items, keyOf) => {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const item of items) byKey.set(keyOf(item), item);
-	return [...byKey.values()];
-};
-/**
-* Merges the pages of a sync into one model. A record can appear on several pages, for example an issue in another repository reached through a dependency before its own repository is read; identity is the identifier, so it becomes one element, and where pages disagree the later page wins, being the more recent read.
-* @param pages - The pages of one sync, in the order they arrived.
-* @returns The model, overlay, relations and gaps of the whole sync.
-*/
-const assembleSync = (pages) => {
-	const overlay = Object.fromEntries(pages.flatMap((page) => Object.entries(page.overlay)));
-	return {
-		model: {
-			participants: latestById(pages.flatMap((page) => page.participants), (participant) => participant.id),
-			events: [],
-			actions: [],
-			artefacts: [],
-			elements: latestById(pages.flatMap((page) => page.activities), (activity) => activity.id),
-			transitions: latestById(pages.flatMap((page) => page.transitions), (transition) => transition.id),
-			fragments: [],
-			projections: []
-		},
-		overlay,
-		relations: latestById(pages.flatMap((page) => page.relations), relationKey),
-		gaps: pages.flatMap((page) => page.gaps)
-	};
-};
-//#endregion
 //#region ../../adapters/graph/source-github-issues/dist/cursor.js
 /**
 * Where the next page of a sync starts. A position is plain data, so a cursor resumes in any process.
@@ -545,16 +386,36 @@ const readJson = async (response) => {
 	}
 };
 /**
+* Asks the token port for the token a request needs. A port that cannot supply one has failed to provide credentials, which ends the sync exactly as GitHub rejecting them would, so whatever it throws is reported as `unauthorised`: a `GraphSourceError` the port threw as it is, and anything else wrapped in one whose message names the token port and the owner and whose cause is the port's own error. An abort is passed through, since it is the caller's, not the port's.
+* @param transport - The token port.
+* @param owner - The login the request is about, or `undefined` for the token's own holder.
+* @param signal - The caller's abort signal.
+* @returns The token.
+* @throws GraphSourceError with `unauthorised` when the port fails.
+*/
+const tokenFor = async (transport, owner, signal) => {
+	try {
+		return await transport.token(owner, signal);
+	} catch (error) {
+		if (error instanceof GraphSourceError || signal?.aborted === true) throw error;
+		const reason = error instanceof Error ? error.message : String(error);
+		throw new GraphSourceError({
+			kind: "unauthorised",
+			message: `the GitHub token port gave no token${owner === void 0 ? "" : ` for ${owner}`}: ${reason}`
+		}, { cause: error });
+	}
+};
+/**
 * Sends one GraphQL request and classifies the answer.
 * @param transport - The token, fetch and clock ports.
 * @param request - The document, its variables, the owner whose token to use and the schema for `data`.
 * @param signal - The caller's abort signal, passed to `fetch`.
 * @returns The parsed data and any `NOT_FOUND` or `FORBIDDEN` problems beside it.
-* @throws GraphSourceError with `unauthorised` for HTTP 401, and `rate-limited` (with the reset instant when GitHub gives one) for any form of rate limiting.
+* @throws GraphSourceError with `unauthorised` for HTTP 401 or a token port that fails, and `rate-limited` (with the reset instant when GitHub gives one) for any form of rate limiting.
 * @throws Error for any other failure: an HTTP error, another GraphQL error type, or data that does not match the schema.
 */
 const graphql = async (transport, request, signal) => {
-	const token = await transport.token(request.owner, signal);
+	const token = await tokenFor(transport, request.owner, signal);
 	const response = await transport.fetch(githubGraphqlEndpoint, {
 		method: "POST",
 		headers: {
@@ -1313,4 +1174,4 @@ const createGitHubIssuesSource = (options) => {
 	};
 };
 //#endregion
-export { syncPageSchema as A, scopeChildrenInputSchema as C, sourceDescriptionSchema as D, scopeRootsInputSchema as E, syncFilterSchema as O, relationSchema as S, scopeListingSchema as T, gapSchema as _, ownerScopeId as a, participantSchema as b, githubGraphqlEndpoint as c, paginate as d, graphSourceContract as f, gapReasons as g, filterStates as h, issueId as i, transitionSchema as j, syncInputSchema as k, assembleSync as l, boundActivitySchema as m, accountId as n, parseScope as o, badRequestReasons as p, githubSource as r, repositoryId as s, createGitHubIssuesSource as t, createGraphSourceRouter as u, orderDirections$1 as v, scopeEntrySchema as w, relationKinds as x, orderFields as y };
+export { ownerScopeId as a, githubGraphqlEndpoint as c, graphSourceContract as d, issueId as i, createGraphSourceRouter as l, accountId as n, parseScope as o, githubSource as r, repositoryId as s, createGitHubIssuesSource as t, paginate as u };

package/dist/store/node.d.ts

@@ -1,4 +1,4 @@
-import { w as GraphStore } from "../index-DxWOY8f9.js";
+import { w as GraphStore } from "../index-CR8xUK3S.js";
 import { DatabaseSyncOptions } from "node:sqlite";
 import { NodeSQLiteDatabase } from "drizzle-orm/node-sqlite";
 //#region ../../adapters/graph/sqlite-node/dist/open.d.ts
@@ -21,4 +21,29 @@ interface NodeGraphStore {
  */
 export declare const openNodeGraphStore: (path: string, options?: DatabaseSyncOptions) => NodeGraphStore;
 //#endregion
-export type { NodeGraphStore };
+//#region ../../adapters/graph/sqlite-node/dist/data-file.d.ts
+/** The data directory's mode: only its owner may list or enter it, since the store holds synced work (titles, relationships) that other users on the host must not read. */
+export declare const privateDirectoryMode = 448;
+/** The data file's mode: only its owner may read or write it. SQLite creates the `-wal` and `-shm` files beside it with the same mode on Unix. */
+export declare const privateFileMode = 384;
+/** Where a store's data file lives, and how much of its path the caller owns. */
+interface DataFileOptions {
+  /**
+   * Whether the directory is the caller's own, such as an application's default data directory or one a host keeps under its own home, which is created private and kept private. A directory someone else chose, such as a path a user names on a command line, is created when missing but never has its mode changed.
+   */
+  readonly ownsDirectory: boolean;
+  /** The platform; on Windows, file modes mean nothing and nothing is set. */
+  readonly platform: NodeJS.Platform;
+}
+/**
+ * Makes a data file ready for `openNodeGraphStore` to open, so a store holding synced work is never readable by other users on the host. Call it before opening the store; it does not open the database itself.
+ *
+ * The directory is created when missing (with any missing parents), with `privateDirectoryMode` when it is the caller's own. The database file is created with `privateFileMode` when missing, before SQLite opens it, so the file and the `-wal` and `-shm` files SQLite derives from it are never readable by others, whatever the umask. A file that already exists is left alone unless the directory is the caller's own; there, an existing directory or store file (database, `-wal` or `-shm`) that group or others can read is narrowed to the private mode. On Windows, where file modes mean nothing, only the directory is created.
+ * @param path - The database file; not `":memory:"`, which has no file.
+ * @param options - Whether the caller owns the directory, and the platform.
+ * @returns One warning line naming what was narrowed, for the caller to show, or nothing when nothing was.
+ * @throws Error from the file system when the directory or file cannot be created or its mode read or changed.
+ */
+export declare const prepareDataFile: (path: string, options: DataFileOptions) => readonly string[];
+//#endregion
+export type { DataFileOptions, NodeGraphStore };

package/dist/store/node.js

@@ -1,2 +1,2 @@
-import { t as openNodeGraphStore } from "../open-BF-UHqeW.js";
-export { openNodeGraphStore };
+import { i as openNodeGraphStore, n as privateDirectoryMode, r as privateFileMode, t as prepareDataFile } from "../data-file-BVMxkTug.js";
+export { openNodeGraphStore, prepareDataFile, privateDirectoryMode, privateFileMode };

package/dist/store/wasm/worker.js

@@ -1,5 +1,5 @@
-import { I as storeChangeSchema, t as createSqliteGraphStore, y as ChangeFeed } from "../../store-BJILV4JS.js";
-import { t as createGraphStoreRouter } from "../../router-DvGGLnNt.js";
+import { I as storeChangeSchema, t as createSqliteGraphStore, y as ChangeFeed } from "../../store-DKzvLGgl.js";
+import { t as createGraphStoreRouter } from "../../router-Dk91O_9p.js";
 import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
 import { RPCHandler } from "@orpc/server/message-port";
 import { drizzle } from "drizzle-orm/sqlite-proxy";

package/dist/store/wasm.d.ts

@@ -1,4 +1,4 @@
-import { ut as GraphStoreClient } from "../index-DxWOY8f9.js";
+import { ut as GraphStoreClient } from "../index-CR8xUK3S.js";
 //#region ../../adapters/graph/sqlite-wasm/dist/client.d.ts
 /**
  * A client for the graph store a worker serves with `serveGraphStoreInWorker`. Every procedure of the contract is available, with its abort signal and typed errors, as if the store were in the page.

package/dist/{store-BJILV4JS.js → store-DKzvLGgl.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-CVnS6HiX.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 { t as validate } from "./validate-DF3mQZww.js";
 import { r as loopTransitions, s as emptyFactRecord } from "./control-DiygoEhm.js";
 import { z } from "zod";

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-DxWOY8f9.js";
+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 { SQLiteAsyncDatabase } from "drizzle-orm/sqlite-core";
 import { MigrationMeta } from "drizzle-orm/migrator";
 //#region ../../adapters/graph/store-sqlite/dist/database.d.ts

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-BJILV4JS.js";
-import { n as graphStoreContract, t as createGraphStoreRouter } from "./router-DvGGLnNt.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";
 //#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.

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-DoMIav3D.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 { g as syncFilterSchema } from "./schema-DVAttrJg.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 };