sg-widgets-core 0.1.0 → 0.3.0

package/dist/mock.mjs

@@ -1,4 +1,4 @@
-import { B as operatorsFor, E as toFilterArray, F as isFilterable, I as isLinkType, L as isNumericType, M as TIME_UNITS, _ as pluralPath, d as fieldSchemaOverride, i as eventLogFilters, k as NEGATING_OPERATORS, o as normalizeEventLogEntry, r as SgApiError, t as EVENT_LOG_FIELDS, u as displayNameOf } from "./client-DwN_-UuF.mjs";
+import { A as NEGATING_OPERATORS, D as toFilterArray, I as isFilterable, L as isLinkType, N as TIME_UNITS, R as isNumericType, V as operatorsFor, a as eventLogFilters, d as displayNameOf, f as fieldSchemaOverride, r as SgApiError, s as normalizeEventLogEntry, t as EVENT_LOG_FIELDS, v as pluralPath } from "./client-izKszX7l.mjs";
 //#region src/mock.ts
 /**
 * Status vocabularies. `valid_values` is the site's whole vocabulary and is
@@ -151,6 +151,19 @@ const PROJECT_STATUSES = [
 	"Complete",
 	"On Hold"
 ];
+/** PublishedFile's list is site configuration; this site keeps the three the probed one held (entity_types/PublishedFile). */
+const PUBLISHED_FILE_STATUSES = [
+	"wtg",
+	"ip",
+	"cmpt"
+];
+/** The four `TaskDependency.dependency_type` values, the first the default (085_task_dependency_types). */
+const DEPENDENCY_TYPES = [
+	"finish-to-start-next-day",
+	"start-to-start",
+	"finish-to-finish",
+	"start-to-finish-next-day"
+];
 const AUDIT = {
 	id: {
 		displayName: "Id",
@@ -277,6 +290,15 @@ const SPECS = {
 			displayName: "Users",
 			dataType: "multi_entity",
 			validTypes: ["HumanUser"]
+		},
+		tracking_settings: {
+			displayName: "Tracking Settings",
+			dataType: "serializable"
+		},
+		task_templates: {
+			displayName: "Task Templates",
+			dataType: "multi_entity",
+			validTypes: ["TaskTemplate"]
 		}
 	},
 	Sequence: {
@@ -313,6 +335,11 @@ const SPECS = {
 			displayName: "Shots",
 			dataType: "multi_entity",
 			validTypes: ["Shot"]
+		},
+		task_template: {
+			displayName: "Task Template",
+			dataType: "entity",
+			validTypes: ["TaskTemplate"]
 		}
 	},
 	Shot: {
@@ -392,6 +419,11 @@ const SPECS = {
 			displayName: "Tasks",
 			dataType: "multi_entity",
 			validTypes: ["Task"]
+		},
+		task_template: {
+			displayName: "Task Template",
+			dataType: "entity",
+			validTypes: ["TaskTemplate"]
 		}
 	},
 	Asset: {
@@ -451,6 +483,11 @@ const SPECS = {
 			displayName: "Tasks",
 			dataType: "multi_entity",
 			validTypes: ["Task"]
+		},
+		task_template: {
+			displayName: "Task Template",
+			dataType: "entity",
+			validTypes: ["TaskTemplate"]
 		}
 	},
 	Version: {
@@ -634,6 +671,151 @@ const SPECS = {
 			displayName: "Upstream Tasks",
 			dataType: "multi_entity",
 			validTypes: ["Task"]
+		},
+		downstream_tasks: {
+			displayName: "Downstream Tasks",
+			dataType: "multi_entity",
+			validTypes: ["Task"]
+		},
+		sg_sort_order: {
+			displayName: "Sort Order",
+			dataType: "number"
+		},
+		task_template: {
+			displayName: "Task Template",
+			dataType: "entity",
+			validTypes: ["TaskTemplate"]
+		},
+		template_task: {
+			displayName: "Template Task",
+			dataType: "entity",
+			validTypes: ["Task"]
+		}
+	},
+	TaskTemplate: {
+		...AUDIT,
+		code: {
+			displayName: "Template Name",
+			dataType: "text",
+			mandatory: true
+		},
+		description: {
+			displayName: "Description",
+			dataType: "text"
+		},
+		entity_type: {
+			displayName: "Entity Type",
+			dataType: "entity_type",
+			editable: false,
+			writable: true
+		},
+		projects: {
+			displayName: "Projects",
+			dataType: "multi_entity",
+			validTypes: ["Project"]
+		},
+		task_count: {
+			displayName: "Task Count",
+			dataType: "number",
+			editable: false
+		}
+	},
+	TaskDependency: {
+		...AUDIT,
+		task: {
+			displayName: "Task",
+			dataType: "entity",
+			validTypes: ["Task"]
+		},
+		dependent_task: {
+			displayName: "Dependent Task",
+			dataType: "entity",
+			validTypes: ["Task"]
+		},
+		dependency_type: {
+			displayName: "Dependency Type",
+			dataType: "text",
+			defaultValue: DEPENDENCY_TYPES[0]
+		},
+		offset_days: {
+			displayName: "Offset Days",
+			dataType: "number"
+		},
+		shift_ratio: {
+			displayName: "Shift Ratio",
+			dataType: "float"
+		},
+		task_id: {
+			displayName: "Task Id",
+			dataType: "number",
+			editable: false
+		},
+		dependent_task_id: {
+			displayName: "Dependent Task Id",
+			dataType: "number",
+			editable: false
+		}
+	},
+	PublishedFile: {
+		...AUDIT,
+		code: {
+			displayName: "Published File Name",
+			dataType: "text",
+			mandatory: true
+		},
+		name: {
+			displayName: "Name",
+			dataType: "text"
+		},
+		description: {
+			displayName: "Description",
+			dataType: "text"
+		},
+		version_number: {
+			displayName: "Version Number",
+			dataType: "number"
+		},
+		path: {
+			displayName: "Path",
+			dataType: "url"
+		},
+		path_cache: {
+			displayName: "Path Cache",
+			dataType: "text"
+		},
+		sg_status_list: statusSpec(PUBLISHED_FILE_STATUSES, "wtg"),
+		image: {
+			displayName: "Thumbnail",
+			dataType: "image"
+		},
+		project: {
+			displayName: "Project",
+			dataType: "entity",
+			validTypes: ["Project"]
+		},
+		entity: {
+			displayName: "Link",
+			dataType: "entity",
+			validTypes: [
+				"Asset",
+				"Shot",
+				"Sequence"
+			]
+		},
+		task: {
+			displayName: "Task",
+			dataType: "entity",
+			validTypes: ["Task"]
+		},
+		version: {
+			displayName: "Version",
+			dataType: "entity",
+			validTypes: ["Version"]
+		},
+		published_file_type: {
+			displayName: "Published File Type",
+			dataType: "entity",
+			validTypes: ["PublishedFileType"]
 		}
 	},
 	Note: {
@@ -1048,15 +1230,26 @@ const IDENTITY_FIELD = {
 	Task: "content",
 	Note: "subject",
 	Reply: "content",
-	Attachment: "display_name"
+	Attachment: "display_name",
+	TaskTemplate: "code",
+	PublishedFile: "code"
 };
 const GENERATED_IDENTITY = /* @__PURE__ */ new Set([
 	"Sequence",
 	"Shot",
 	"Asset",
 	"Version",
-	"Task"
+	"Task",
+	"TaskTemplate",
+	"PublishedFile"
 ]);
+/** The name a generated identity starts with, where it is not the display name (entity_types/TaskTemplate). */
+const GENERATED_NAME = { TaskTemplate: "TaskTemplate" };
+/** Where one side of a link is written, the other side follows (088_project_template_defaults). */
+const MIRRORED = {
+	"Project.task_templates": ["TaskTemplate", "projects"],
+	"TaskTemplate.projects": ["Project", "task_templates"]
+};
 const DISPLAY_NAMES = {
 	Project: "Project",
 	Sequence: "Sequence",
@@ -1072,13 +1265,31 @@ const DISPLAY_NAMES = {
 	Note: "Note",
 	Reply: "Reply",
 	Attachment: "Attachment",
-	EventLogEntry: "Event Log Entry"
+	EventLogEntry: "Event Log Entry",
+	TaskTemplate: "Task Template",
+	TaskDependency: "Task Dependency",
+	PublishedFile: "Published File"
 };
 /**
 * Which codes each project hides, per type. `hidden_values` is the only thing
 * `project_id` changes (009_status_lists), and it is not a subset of
 * `valid_values`: the probed site hid `blk` and `rdy`, neither of them valid.
 */
+/**
+* The fields this site may hide, `visible.editable` true: its own additions and a few
+* stock fields, `Project.code` among them. Every other field reads false, `sg_` prefix
+* or not (056_stock_vs_custom_field).
+*/
+const HIDEABLE = /* @__PURE__ */ new Set([
+	"Project.code",
+	"Shot.sg_complexity",
+	"Shot.sg_lens",
+	"Shot.sg_shot_notes_url",
+	"Asset.sg_build_days",
+	"Asset.sg_complexity",
+	"Version.sg_department",
+	"Version.sg_bar_color"
+]);
 const HIDDEN_VALUES = {
 	70: {
 		"Version.sg_status_list": [
@@ -1980,6 +2191,124 @@ function buildFixtures(seed, counts = {}) {
 		});
 		eventId += eventId % 7 === 0 ? 3 : 1;
 	}
+	let dependencyId = 1;
+	const depend = (downstream, upstream) => {
+		add("TaskDependency", dependencyId, {
+			cached_display_name: `Task ${downstream.id} dependent on Task ${upstream.id}`,
+			task: ref(downstream),
+			dependent_task: ref(upstream),
+			dependency_type: DEPENDENCY_TYPES[0],
+			offset_days: null,
+			shift_ratio: null,
+			task_id: downstream.id,
+			dependent_task_id: upstream.id,
+			created_at: isoDateTime(-180),
+			updated_at: isoDateTime(-180),
+			created_by: ref(bot),
+			updated_by: ref(bot)
+		});
+		dependencyId += 1;
+	};
+	let templateTaskId = 5600;
+	const [shotTemplate, assetTemplate] = [{
+		id: 40,
+		code: "Shot basic",
+		entityType: "Shot"
+	}, {
+		id: 41,
+		code: "Asset build",
+		entityType: "Asset"
+	}].map((t) => {
+		const template = add("TaskTemplate", t.id, {
+			code: t.code,
+			cached_display_name: t.code,
+			description: `Every ${t.entityType} step, one after the other.`,
+			entity_type: t.entityType,
+			projects: [],
+			task_count: null,
+			created_at: isoDateTime(-190),
+			updated_at: isoDateTime(-190),
+			created_by: ref(bot),
+			updated_by: ref(bot)
+		});
+		let previous = null;
+		steps.filter((st) => st.values["entity_type"] === t.entityType).forEach((st, i) => {
+			const content = String(st.values["code"]);
+			const templateTask = add("Task", templateTaskId, {
+				content,
+				cached_display_name: content,
+				sg_description: null,
+				sg_status_list: "wtg",
+				start_date: null,
+				due_date: null,
+				duration: null,
+				est_in_mins: null,
+				time_logs_sum: 0,
+				time_percent_of_est: null,
+				color: "pipeline_step",
+				milestone: false,
+				project: null,
+				entity: null,
+				step: ref(st),
+				task_assignees: [],
+				task_reviewers: [],
+				sg_sort_order: (i + 1) * 10,
+				task_template: ref(template),
+				template_task: null,
+				created_at: isoDateTime(-190),
+				updated_at: isoDateTime(-190),
+				created_by: ref(bot),
+				updated_by: ref(bot)
+			});
+			templateTaskId += 1;
+			if (previous) depend(templateTask, previous);
+			previous = templateTask;
+		});
+		return template;
+	});
+	p0.values["tracking_settings"] = { default_task_template: { Shot: {
+		type: "TaskTemplate",
+		id: shotTemplate.id,
+		name: shotTemplate.values["code"],
+		valid: "valid"
+	} } };
+	p1.values["tracking_settings"] = { default_task_template: {} };
+	p2.values["tracking_settings"] = {};
+	for (const p of projects) p.values["task_templates"] = [];
+	p0.values["task_templates"] = [ref(assetTemplate)];
+	assetTemplate.values["projects"] = [ref(p0)];
+	const shotTemplateTasks = (rows.get("Task") ?? []).filter((t) => t.values["task_template"]?.id === shotTemplate.id);
+	for (const shot of shots.filter((sh) => sh.values["sg_sequence"].id === sequences[0]?.id)) {
+		shot.values["task_template"] = ref(shotTemplate);
+		for (const taskRef of shot.values["tasks"]) {
+			const task = index.get(`Task:${taskRef.id}`);
+			const source = shotTemplateTasks.find((t) => t.values["step"].id === task.values["step"].id);
+			task.values["template_task"] = source ? ref(source) : null;
+		}
+	}
+	versions.slice(0, 12).forEach((version, i) => {
+		const code = `${String(version.values["code"])}.exr`;
+		add("PublishedFile", 3e3 + i, {
+			code,
+			cached_display_name: code,
+			name: code.replace(/_v\d+\.exr$/, ".exr"),
+			description: null,
+			version_number: 1,
+			path: null,
+			path_cache: null,
+			sg_status_list: "cmpt",
+			image: null,
+			project: version.values["project"],
+			entity: version.values["entity"],
+			task: version.values["sg_task"],
+			version: ref(version),
+			published_file_type: null,
+			created_at: version.values["created_at"],
+			updated_at: version.values["created_at"],
+			created_by: ref(bot),
+			updated_by: ref(bot)
+		});
+	});
 	const follows = /* @__PURE__ */ new Map();
 	const follow = (userRef, row) => {
 		if (!userRef || userRef.type !== "HumanUser") return;
@@ -2007,11 +2336,21 @@ var MockClient = class {
 	latencyMs;
 	clock;
 	pendingFailure;
+	/** Rows a delete retired, by `Type:id`. Reads skip them and a revive puts them back. */
+	retired = /* @__PURE__ */ new Map();
+	/** Rows a batch created with no `project`: no read reaches them, a delete does (report 001). */
+	unreadable = /* @__PURE__ */ new Map();
+	/** What a Task delete did to other rows, by `Task:id`, for its revive to undo (089_task_delete_side_effects). */
+	cascades = /* @__PURE__ */ new Map();
+	/** The highest id handed out per type, so an erased row's id is never reused. */
+	issued = /* @__PURE__ */ new Map();
+	deletes = 0;
 	constructor(options = {}) {
 		this.fixtures = buildFixtures(options.seed ?? 1, options.counts ?? {});
 		this.latencyMs = options.latencyMs ?? 0;
 		this.clock = toClock(options.now);
 		this.pendingFailure = options.failNext ?? null;
+		this.derive();
 	}
 	/**
 	* Make the next call reject with an `SgApiError`, for demoing an error state.
@@ -2058,7 +2397,8 @@ var MockClient = class {
 				dataType: s.dataType,
 				editable: s.editable ?? true,
 				mandatory: s.mandatory ?? false,
-				unique: s.unique ?? false
+				unique: s.unique ?? false,
+				hideable: HIDEABLE.has(`${entityType}.${name}`)
 			};
 			if (s.validTypes) field.validTypes = s.validTypes;
 			if (s.validValues) field.validValues = s.validValues;
@@ -2091,6 +2431,14 @@ var MockClient = class {
 			hasMore: page.length === size
 		};
 	}
+	async read(entityType, id, options = {}) {
+		await this.gate();
+		const spec = this.schemaOf(entityType);
+		const key = `${entityType}:${id}`;
+		const row = options.retired ? this.retired.get(key) : this.fixtures.index.get(key);
+		if (!row) throw notFound(`${entityType}: ${id} not found`);
+		return this.project(row, spec, options.fields);
+	}
 	async textSearch(text, entityTypes, page) {
 		await this.gate();
 		const words = text.trim().split(/\s+/).filter(Boolean);
@@ -2128,18 +2476,31 @@ var MockClient = class {
 	}
 	async update(entityType, id, patch) {
 		await this.gate();
+		return this.updateRow(entityType, id, patch, false);
+	}
+	updateRow(entityType, id, patch, inBatch) {
 		const spec = this.schemaOf(entityType);
 		const row = this.fixtures.index.get(`${entityType}:${id}`);
-		if (!row) throw new SgApiError(404, null, `Entity of type [${entityType}] with id=${id} does not exist.`);
+		if (!row) throw notFound(`Entity of type [${entityType}] with id=${id} does not exist.`);
 		for (const [name, value] of Object.entries(patch)) {
 			const field = spec[name];
 			if (!field) throw new SgApiError(400, null, `API update() ${entityType}.${name} doesn't exist.`);
 			if (field.createOnly) throw new SgApiError(400, null, `API update() ${entityType}.${name} is editable on create only.`);
-			if (field.editable === false) throw new SgApiError(400, null, `API update() ${entityType}.${name} is read only.`);
+			if (field.editable === false && !field.writable) throw new SgApiError(400, null, `API update() ${entityType}.${name} is read only.`);
 			this.checkLink("update", entityType, name, field, value);
-			row.values[name] = field.dataType === "text" && value === "" ? null : value;
+			this.checkValue(inBatch, entityType, name, field, value);
+		}
+		for (const [name, value] of Object.entries(patch)) {
+			const field = spec[name];
+			if (entityType === "Task" && (name === "upstream_tasks" || name === "downstream_tasks")) {
+				this.writeEdges(row, name, value);
+				continue;
+			}
+			row.values[name] = (field.dataType === "text" || field.dataType === "status_list") && value === "" ? null : value;
+			this.mirror(row, name);
 		}
 		if (spec["updated_at"] && Object.keys(patch).length > 0) row.values["updated_at"] = isoDateTime(0);
+		this.derive();
 		return this.project(row, spec);
 	}
 	/**
@@ -2476,16 +2837,30 @@ var MockClient = class {
 	*/
 	async create(entityType, body) {
 		await this.gate();
+		return this.createRow(entityType, body, false);
+	}
+	/**
+	* A create, alone or inside a batch. The batch skips the `project` check and stores
+	* the row where no read reaches it (report 001), and it spells an unknown field its
+	* own way (recipes/002).
+	*/
+	createRow(entityType, body, inBatch) {
 		const spec = this.schemaOf(entityType);
-		if (spec["project"] && body["project"] === void 0) throw new SgApiError(400, null, `API create() missing 'project' attribute: ${JSON.stringify(body)}`);
+		const templateTask = entityType === "Task" && !isNullish(body["task_template"]);
+		const orphan = spec["project"] !== void 0 && body["project"] === void 0 && !templateTask;
+		if (orphan && !inBatch) throw new SgApiError(400, null, `API create() missing 'project' attribute: ${JSON.stringify(body)}`);
+		if (templateTask && !isNullish(body["project"])) throw new SgApiError(400, null, "API create() Invalid Task: a task template may not have a project");
 		const identity = IDENTITY_FIELD[entityType];
 		for (const [name, value] of Object.entries(body)) {
 			const field = spec[name];
+			if (!field && inBatch) throw new SgApiError(400, null, `Invalid field value, update failed [2 - Invalid field name: field [${entityType}.${name}] does not exist or user does not have access permission.]`);
 			if (!field) throw new SgApiError(400, null, `API create() ${entityType}.${name} doesn't exist.`);
-			if (field.editable === false && !field.createOnly) throw new SgApiError(400, null, `API create() ${entityType}.${name} is read only.`);
+			if (field.editable === false && !field.createOnly && !field.writable) throw new SgApiError(400, null, `API create() ${entityType}.${name} is read only.`);
 			this.checkLink("create", entityType, name, field, value);
+			this.checkValue(true, entityType, name, field, value);
 			if (name === identity && value === "") throw new SgApiError(400, null, `Create failed for [${entityType}]: Cannot set identifier field to empty. (${entityType})`);
 		}
+		if (entityType === "TaskDependency") this.checkEdge(body);
 		const id = this.nextId(entityType);
 		const values = {};
 		for (const [name, field] of Object.entries(spec)) values[name] = field.dataType === "multi_entity" ? [] : field.defaultValue ?? null;
@@ -2499,7 +2874,8 @@ var MockClient = class {
 		values["created_at"] = isoDateTime(0);
 		if (spec["updated_at"]) values["updated_at"] = isoDateTime(0);
 		Object.assign(values, body, { id });
-		if (identity && values[identity] === null && GENERATED_IDENTITY.has(entityType)) values[identity] = `New ${DISPLAY_NAMES[entityType] ?? entityType} ${id}`;
+		if (identity && values[identity] === null && GENERATED_IDENTITY.has(entityType)) values[identity] = `New ${GENERATED_NAME[entityType] ?? DISPLAY_NAMES[entityType] ?? entityType} ${id}`;
+		if (entityType === "TaskDependency" && values["dependency_type"] === null) values["dependency_type"] = DEPENDENCY_TYPES[0];
 		values["cached_display_name"] = entityType === "Note" ? [values["subject"], values["content"]].filter(Boolean).join(" - ") : displayNameOf({
 			...values,
 			cached_display_name: null
@@ -2509,14 +2885,319 @@ var MockClient = class {
 			id,
 			values
 		};
+		if (orphan) {
+			this.unreadable.set(`${entityType}:${id}`, row);
+			return this.project(row, spec);
+		}
 		const rows = this.fixtures.rows.get(entityType);
 		if (rows) rows.push(row);
 		else this.fixtures.rows.set(entityType, [row]);
 		this.fixtures.index.set(`${entityType}:${id}`, row);
 		this.linkBack(row);
+		for (const name of Object.keys(body)) if (entityType === "Task" && (name === "upstream_tasks" || name === "downstream_tasks")) this.writeEdges(row, name, body[name]);
+		else this.mirror(row, name);
+		this.derive();
 		return this.project(row, spec);
 	}
 	/**
+	* Retire one row: reads skip it and a second delete is 404 (delete_entity_type_id).
+	* A Task takes its TaskDependency rows with it and leaves `Version.sg_task` and
+	* `PublishedFile.task` null until its revive (089_task_delete_side_effects), alone or
+	* in a batch (103_batch_delete_revive). A TaskTemplate retires its tasks
+	* (entity_types/TaskTemplate). What a Shot delete does to its Versions (probe 060)
+	* is not modelled.
+	*/
+	async delete(entityType, id) {
+		await this.gate();
+		this.deleteRow(entityType, id);
+	}
+	deleteRow(entityType, id) {
+		this.schemaOf(entityType);
+		const key = `${entityType}:${id}`;
+		const row = this.fixtures.index.get(key) ?? this.unreadable.get(key);
+		if (!row) throw notFound(`Entity of type [${entityType}] with id=${id} does not exist.`);
+		if (entityType === "TaskTemplate") for (const task of this.live("Task").filter((t) => refsOf(t.values["task_template"])[0]?.id === id)) this.deleteRow("Task", task.id);
+		if (entityType === "Task") {
+			const cascade = {
+				edges: [],
+				unlinked: []
+			};
+			for (const edge of this.edgesOf(id)) {
+				this.retire(edge);
+				cascade.edges.push(`TaskDependency:${edge.id}`);
+			}
+			for (const [type, field] of [["Version", "sg_task"], ["PublishedFile", "task"]]) for (const other of this.live(type)) {
+				const value = other.values[field];
+				if (value?.type !== "Task" || value.id !== id) continue;
+				other.values[field] = null;
+				cascade.unlinked.push({
+					row: other,
+					field,
+					value
+				});
+			}
+			this.cascades.set(key, cascade);
+		}
+		this.unreadable.delete(key);
+		this.retire(row);
+		this.derive();
+	}
+	/**
+	* Bring a retired row back with its values; `false` for a row that is already live
+	* (post_entity_type_id). A Task gets back what its delete took (089_task_delete_side_effects).
+	* A TaskDependency whose pair is linked again refuses, the pair being a unique index
+	* (095_dependency_remove_undo). A TaskTemplate's tasks stay retired: unmeasured.
+	*/
+	async revive(entityType, id) {
+		await this.gate();
+		this.schemaOf(entityType);
+		const key = `${entityType}:${id}`;
+		if (this.fixtures.index.has(key)) return false;
+		const row = this.retired.get(key);
+		if (!row) throw notFound(`Entity of type [${entityType}] with id=${id} does not exist.`);
+		if (entityType === "TaskDependency" && this.pairTaken(row)) throw new SgApiError(400, null, `Revive failed for [TaskDependency with id=${id}]: Can't unretire the entity because a field has a non-unique value for a unique index: sgcu_task_dependencies`);
+		this.unretire(row);
+		const cascade = this.cascades.get(key);
+		if (cascade) {
+			this.cascades.delete(key);
+			for (const edgeKey of cascade.edges) {
+				const edge = this.retired.get(edgeKey);
+				if (edge && !this.pairTaken(edge)) this.unretire(edge);
+			}
+			for (const { row: other, field, value } of cascade.unlinked) if (this.fixtures.index.get(`${other.type}:${other.id}`) === other && other.values[field] === null) other.values[field] = value;
+		}
+		this.derive();
+		return true;
+	}
+	retire(row) {
+		const key = `${row.type}:${row.id}`;
+		this.fixtures.index.delete(key);
+		const rows = this.fixtures.rows.get(row.type) ?? [];
+		const at = rows.indexOf(row);
+		if (at >= 0) rows.splice(at, 1);
+		this.retired.set(key, row);
+	}
+	unretire(row) {
+		const key = `${row.type}:${row.id}`;
+		this.retired.delete(key);
+		const rows = this.fixtures.rows.get(row.type) ?? [];
+		const at = rows.findIndex((r) => r.id > row.id);
+		rows.splice(at < 0 ? rows.length : at, 0, row);
+		this.fixtures.rows.set(row.type, rows);
+		this.fixtures.index.set(key, row);
+	}
+	/** Remove a row for good: no read reaches it and no revive brings it back. */
+	erase(row) {
+		this.fixtures.index.delete(`${row.type}:${row.id}`);
+		const rows = this.fixtures.rows.get(row.type) ?? [];
+		const at = rows.indexOf(row);
+		if (at >= 0) rows.splice(at, 1);
+	}
+	live(entityType) {
+		return [...this.fixtures.rows.get(entityType) ?? []];
+	}
+	/** The live TaskDependency rows with this Task at either end. */
+	edgesOf(taskId) {
+		return this.live("TaskDependency").filter((d) => refsOf(d.values["task"])[0]?.id === taskId || refsOf(d.values["dependent_task"])[0]?.id === taskId);
+	}
+	/** Whether a live row already links this row's pair. */
+	pairTaken(edge) {
+		const down = refsOf(edge.values["task"])[0]?.id;
+		const up = refsOf(edge.values["dependent_task"])[0]?.id;
+		return this.live("TaskDependency").some((d) => d !== edge && refsOf(d.values["task"])[0]?.id === down && refsOf(d.values["dependent_task"])[0]?.id === up);
+	}
+	/** Whether `from` depends on `target`, directly or through other Tasks. */
+	dependsOn(from, target) {
+		const seen = /* @__PURE__ */ new Set();
+		const queue = [from];
+		while (queue.length > 0) {
+			const at = queue.shift();
+			if (at === target) return true;
+			if (seen.has(at)) continue;
+			seen.add(at);
+			for (const d of this.live("TaskDependency")) if (refsOf(d.values["task"])[0]?.id === at) {
+				const up = refsOf(d.values["dependent_task"])[0]?.id;
+				if (up !== void 0) queue.push(up);
+			}
+		}
+		return false;
+	}
+	/**
+	* The checks a TaskDependency create makes: one of four types, one row per pair, and
+	* no loop of any length (085_task_dependency_types, 107_dependency_three_task_loop).
+	*/
+	checkEdge(body) {
+		const failed = (reason) => new SgApiError(400, null, `Create failed for [TaskDependency]: ${reason}`);
+		if ("dependency_type" in body && !DEPENDENCY_TYPES.includes(body["dependency_type"])) throw failed(`Validation failed: Dependency type Dependency type '${body["dependency_type"] === null ? "" : String(body["dependency_type"])}' is invalid, accepted values are ${DEPENDENCY_TYPES.join(", ")}.`);
+		const down = refsOf(body["task"])[0]?.id;
+		const up = refsOf(body["dependent_task"])[0]?.id;
+		if (down === void 0 || up === void 0) return;
+		if (this.live("TaskDependency").some((d) => refsOf(d.values["task"])[0]?.id === down && refsOf(d.values["dependent_task"])[0]?.id === up)) throw failed("Validation failed: There is already a connection between the entities.");
+		if (down === up || this.dependsOn(up, down)) throw failed("Can't create this dependency as it causes a loop.");
+	}
+	/**
+	* A write to `upstream_tasks` or `downstream_tasks`: a new neighbour gets a row of the
+	* default type and no offset, a dropped one's row is erased, not retired
+	* (086_batch_tasks_with_dependencies, 095_dependency_remove_undo).
+	*/
+	writeEdges(task, field, value) {
+		const [own, other] = field === "upstream_tasks" ? ["task", "dependent_task"] : ["dependent_task", "task"];
+		const wanted = refsOf(value).map((r) => r.id);
+		const current = this.live("TaskDependency").filter((d) => refsOf(d.values[own])[0]?.id === task.id);
+		for (const edge of current) if (!wanted.includes(refsOf(edge.values[other])[0]?.id)) this.erase(edge);
+		for (const id of wanted) {
+			if (current.some((d) => refsOf(d.values[other])[0]?.id === id)) continue;
+			const neighbour = {
+				type: "Task",
+				id
+			};
+			const [down, up] = own === "task" ? [ref(task), neighbour] : [neighbour, ref(task)];
+			const edgeId = this.nextId("TaskDependency");
+			const author = this.fixtures.rows.get("ApiUser")?.[0];
+			const edge = {
+				type: "TaskDependency",
+				id: edgeId,
+				values: {
+					id: edgeId,
+					cached_display_name: null,
+					task: down,
+					dependent_task: up,
+					dependency_type: DEPENDENCY_TYPES[0],
+					offset_days: null,
+					shift_ratio: null,
+					task_id: down.id,
+					dependent_task_id: up.id,
+					created_at: isoDateTime(0),
+					updated_at: isoDateTime(0),
+					created_by: author ? ref(author) : null,
+					updated_by: author ? ref(author) : null
+				}
+			};
+			const rows = this.fixtures.rows.get("TaskDependency");
+			if (rows) rows.push(edge);
+			else this.fixtures.rows.set("TaskDependency", [edge]);
+			this.fixtures.index.set(`TaskDependency:${edgeId}`, edge);
+		}
+	}
+	/** Where the written field is one side of a two-sided link, make the other side agree. */
+	mirror(row, name) {
+		const pair = MIRRORED[`${row.type}.${name}`];
+		if (!pair) return;
+		const [otherType, otherField] = pair;
+		const linked = new Set(refsOf(row.values[name]).map((r) => r.id));
+		for (const other of this.live(otherType)) {
+			const list = refsOf(other.values[otherField]).filter((r) => !(r.type === row.type && r.id === row.id));
+			if (linked.has(other.id)) list.push(ref(row));
+			other.values[otherField] = list;
+		}
+	}
+	/**
+	* What the server derives from other rows: a Task's two edge lists from the
+	* TaskDependency rows, their ids and name, and a template's task count, a string.
+	*/
+	derive() {
+		const upstream = /* @__PURE__ */ new Map();
+		const downstream = /* @__PURE__ */ new Map();
+		const push = (map, key, value) => {
+			map.set(key, [...map.get(key) ?? [], {
+				type: "Task",
+				id: value.id
+			}]);
+		};
+		for (const edge of this.live("TaskDependency")) {
+			const down = refsOf(edge.values["task"])[0];
+			const up = refsOf(edge.values["dependent_task"])[0];
+			edge.values["task_id"] = down?.id ?? null;
+			edge.values["dependent_task_id"] = up?.id ?? null;
+			edge.values["cached_display_name"] = `Task ${down?.id ?? ""} dependent on Task ${up?.id ?? ""}`;
+			if (!down || !up) continue;
+			push(upstream, down.id, up);
+			push(downstream, up.id, down);
+		}
+		const counts = /* @__PURE__ */ new Map();
+		for (const task of this.live("Task")) {
+			task.values["upstream_tasks"] = upstream.get(task.id) ?? [];
+			task.values["downstream_tasks"] = downstream.get(task.id) ?? [];
+			const template = refsOf(task.values["task_template"])[0];
+			if (template) counts.set(template.id, (counts.get(template.id) ?? 0) + 1);
+		}
+		for (const template of this.live("TaskTemplate")) template.values["task_count"] = String(counts.get(template.id) ?? 0);
+	}
+	/**
+	* Apply the requests in order, and undo all of them when one fails (recipes/002).
+	* A create or update row carries the record under `data`; a delete row is flat.
+	*/
+	async batch(requests) {
+		await this.gate();
+		const restore = this.snapshot();
+		try {
+			return requests.map((request, i) => this.batchOne(request, i));
+		} catch (error) {
+			restore();
+			throw error;
+		}
+	}
+	batchOne(request, i) {
+		const invalid = (source) => new SgApiError(400, { errors: [{
+			status: 400,
+			code: 103,
+			title: "Request Parameters invalid.",
+			source
+		}] }, "Request Parameters invalid.");
+		const kind = request.request_type;
+		if (kind !== "create" && kind !== "update" && kind !== "delete") throw invalid({ requests: { [i]: { request_type: ["request_type must be one of: create, update, delete"] } } });
+		if (!request.entity) throw invalid({ requests: { [i]: { entity: ["entity is missing"] } } });
+		if (!SPECS[request.entity]) throw new SgApiError(400, null, "Invalid entity type: entity type [] does not exist.");
+		const id = "record_id" in request ? request.record_id ?? 0 : 0;
+		if (request.request_type === "delete") {
+			this.deleteRow(request.entity, id);
+			this.deletes += 1;
+			const uuid = `00000000-0000-4000-8000-${this.deletes.toString(16).padStart(12, "0")}`;
+			return {
+				request_type: "delete",
+				type: request.entity,
+				id,
+				uuid,
+				did_delete: true
+			};
+		}
+		const data = request.data;
+		if (data === null || typeof data !== "object") throw invalid({ data: ["data hash containing field/value pairs is required for the given request"] });
+		if (request.request_type === "create") return {
+			request_type: "create",
+			data: this.createRow(request.entity, data, true)
+		};
+		return {
+			request_type: "update",
+			data: this.updateRow(request.entity, id, data, true)
+		};
+	}
+	/** Everything a batch can change, and a function that puts it back. */
+	snapshot() {
+		const rows = new Map([...this.fixtures.rows].map(([type, list]) => [type, [...list]]));
+		const index = new Map(this.fixtures.index);
+		const values = new Map([...index.values()].map((row) => [row, structuredClone(row.values)]));
+		const retired = new Map(this.retired);
+		const unreadable = new Map(this.unreadable);
+		const cascades = new Map(this.cascades);
+		const issued = new Map(this.issued);
+		const deletes = this.deletes;
+		const refill = (target, from) => {
+			target.clear();
+			for (const [k, v] of from) target.set(k, v);
+		};
+		return () => {
+			refill(this.fixtures.rows, rows);
+			refill(this.fixtures.index, index);
+			for (const [row, saved] of values) row.values = saved;
+			refill(this.retired, retired);
+			refill(this.unreadable, unreadable);
+			refill(this.cascades, cascades);
+			refill(this.issued, issued);
+			this.deletes = deletes;
+		};
+	}
+	/**
 	* Put a file on a row, as the three-call handshake leaves the site.
 	*
 	* The field in the path picks the kind: `image` a Thumbnail, another field an
@@ -2527,7 +3208,7 @@ var MockClient = class {
 		await this.gate();
 		const spec = this.schemaOf(entityType);
 		const target = this.fixtures.index.get(`${entityType}:${id}`);
-		if (!target) throw new SgApiError(404, null, `Entity of type [${entityType}] with id=${id} does not exist.`);
+		if (!target) throw notFound(`Entity of type [${entityType}] with id=${id} does not exist.`);
 		if (!file.filename) throw new SgApiError(400, { filename: ["filename is missing"] }, "Request Parameters invalid.");
 		if (file.field !== void 0 && !spec[file.field]) throw new SgApiError(404, null, `Field '${entityType}.${file.field}' does not exist.`);
 		const attachmentId = this.nextId("Attachment");
@@ -2601,9 +3282,33 @@ var MockClient = class {
 		}
 		if (typeof value === "object" && !Array.isArray(value) && typeof value.type !== "string") throw new SgApiError(400, null, `API ${verb}() invalid/missing entity hash string 'type': ${JSON.stringify(value)}`);
 	}
+	/**
+	* Values the server checks beyond their shape. A status code must be in the site-wide
+	* `valid_values`, hidden ones included, and a create or any batch request wraps the
+	* refusal (field_types/status_list, recipes/002, 094_permission_preflight). A
+	* TaskTemplate's `entity_type` must name a type (entity_types/TaskTemplate).
+	*/
+	checkValue(wrapped, entityType, name, field, value) {
+		if (value === null || value === void 0 || value === "") return;
+		let reason = null;
+		if (field.dataType === "status_list" && !(field.validValues ?? []).includes(value)) {
+			const valid = (field.validValues ?? []).map((v) => `'${v}'`).join(", ");
+			reason = `Update failed for [${entityType}.${name}]: '${String(value)}' is not a valid status. Valid statuses: ${valid}.`;
+		}
+		if (field.dataType === "entity_type" && field.writable && !SPECS[value]) {
+			const valid = Object.keys(SPECS).map((v) => `'${v}'`).join(", ");
+			throw new SgApiError(400, null, `Update failed for [${entityType}.${name}]: '${String(value)}' is not a valid entity type. Valid entity types: ${valid}.`);
+		}
+		if (reason === null) return;
+		throw new SgApiError(400, null, wrapped ? `Invalid field value, update failed [5 - ${reason}]` : reason);
+	}
 	/** The next free id of a type, which is what a create takes. */
 	nextId(entityType) {
-		return (this.fixtures.rows.get(entityType) ?? []).reduce((max, row) => Math.max(max, row.id), 0) + 1;
+		let taken = (this.fixtures.rows.get(entityType) ?? []).reduce((max, row) => Math.max(max, row.id), 0);
+		for (const row of [...this.retired.values(), ...this.unreadable.values()]) if (row.type === entityType) taken = Math.max(taken, row.id);
+		const id = Math.max(taken, this.issued.get(entityType) ?? 0) + 1;
+		this.issued.set(entityType, id);
+		return id;
 	}
 	/** The reverse view of a link the server fills in: a Reply lands in `Note.replies`. */
 	linkBack(row) {
@@ -2898,6 +3603,19 @@ function entityTypeNamed(name) {
 	const wanted = name.toLowerCase();
 	return Object.keys(SPECS).find((type) => type.toLowerCase() === wanted || pluralPath(type) === wanted) ?? null;
 }
+/**
+* The 404 a row that is not there answers: code 104, title `Not Found`, the message in
+* `detail` (put_entity_type_id, get_entity_notes_id_thread_contents). The message is the
+* detail, as on every other mock error.
+*/
+function notFound(detail) {
+	return new SgApiError(404, { errors: [{
+		status: 404,
+		code: 104,
+		title: "Not Found",
+		detail
+	}] }, detail);
+}
 function isNullish(v) {
 	return v === null || v === void 0 || v === "";
 }