@lantharos/pult 0.0.0-stage → 0.8.0

package/index.mjs

@@ -0,0 +1,950 @@
+import { A as mapBlocks, C as HEADER, D as sign, O as verify, P as findActionDef, T as NonceWindow, a as collect, b as KIND, d as Transport, f as b, g as home, h as isPendingAttachment, i as validate, j as DEFAULT_STATES, k as eachBlock, m as fieldValues, n as reviveDates, o as findAction, p as bindActions, s as flag, t as ValidationError, u as PultError, v as page, w as refKey, x as captureOrigin, y as view } from "./schema-CzG8J_9_.mjs";
+//#region ../protocol/src/flags.ts
+function rampAt(ramp, now = Date.now()) {
+	if (now >= ramp.end) return ramp.to;
+	if (now <= ramp.start) return ramp.from;
+	const elapsed = ramp.every ? Math.floor((now - ramp.start) / ramp.every) * ramp.every : now - ramp.start;
+	const value = ramp.from + (ramp.to - ramp.from) * elapsed / (ramp.end - ramp.start);
+	return ramp.whole ? Math.round(value) : value;
+}
+function currentRollout(state, now = Date.now()) {
+	return state.ramp?.of === "rollout" ? rampAt(state.ramp, now) : state.rollout;
+}
+function currentValue(state, now = Date.now()) {
+	return state.ramp?.of === "value" ? rampAt(state.ramp, now) : state.value;
+}
+function resolveFlag(name, state, context = {}, now = Date.now()) {
+	const { key, attributes = {} } = context;
+	if (key !== void 0 && key in state.targets) return state.targets[key];
+	const rule = state.rules.find((candidate) => candidate.conditions.every((condition) => holds(condition, attributes[condition.attribute])));
+	if (rule) return rule.rollout === null ? rule.value : share(name, key, rule.rollout);
+	const rollout = currentRollout(state, now);
+	if (rollout !== null) return share(name, key, rollout);
+	return currentValue(state, now);
+}
+function holds(condition, value) {
+	if (value === null || value === void 0) return condition.op === "is not";
+	switch (condition.op) {
+		case "is": return condition.values.includes(value);
+		case "is not": return !condition.values.includes(value);
+		case "above": return typeof value === "number" && value > Number(condition.values[0]);
+		case "below": return typeof value === "number" && value < Number(condition.values[0]);
+	}
+}
+function share(name, key, rollout) {
+	return key === void 0 ? rollout >= 100 : bucket(name, key) < rollout;
+}
+function bucket(name, key) {
+	let hash = 2166136261;
+	for (const char of `${name}:${key}`) {
+		hash ^= char.codePointAt(0);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0) % 1e4 / 100;
+}
+//#endregion
+//#region src/client/runtime.ts
+const onWorkers = globalThis.navigator?.userAgent === "Cloudflare-Workers";
+//#endregion
+//#region src/client/batch.ts
+const FLUSH_MS = 8;
+const MAX_ITEMS = 200;
+const MAX_BYTES = 15e5;
+const schedule = onWorkers ? queueMicrotask : (flush) => setTimeout(flush, FLUSH_MS);
+var Batcher = class {
+	transport;
+	sync;
+	#queue = [];
+	#bytes = 0;
+	#scheduled = false;
+	constructor(transport, sync) {
+		this.transport = transport;
+		this.sync = sync;
+	}
+	send(item) {
+		return new Promise((resolve, reject) => {
+			const size = JSON.stringify(item).length;
+			if (this.#bytes + size > MAX_BYTES) this.#flush();
+			this.#queue.push({
+				item,
+				size,
+				resolve,
+				reject
+			});
+			this.#bytes += size;
+			if (this.#queue.length >= MAX_ITEMS) this.#flush();
+			else if (!this.#scheduled) {
+				this.#scheduled = true;
+				schedule(() => {
+					this.#scheduled = false;
+					this.#flush();
+				});
+			}
+		});
+	}
+	#flush() {
+		const batch = this.#queue;
+		this.#queue = [];
+		this.#bytes = 0;
+		if (batch.length) this.#post(batch);
+	}
+	async #post(batch) {
+		const body = { items: batch.map((entry) => entry.item) };
+		try {
+			let response;
+			try {
+				response = await this.transport.request("POST", "/v1/items", body);
+			} catch (error) {
+				if (!(error instanceof PultError && error.code === "manifest_required")) throw error;
+				await this.sync();
+				response = await this.transport.request("POST", "/v1/items", body);
+			}
+			response.results.forEach((outcome, index) => {
+				const entry = batch[index];
+				if ("error" in outcome) entry.reject(new PultError(outcome.error, 400, outcome.code));
+				else entry.resolve(outcome);
+			});
+		} catch (error) {
+			for (const entry of batch) entry.reject(error);
+		}
+	}
+};
+//#endregion
+//#region src/define/inbox.ts
+function inbox(name, options) {
+	const states = options.states ?? DEFAULT_STATES;
+	const closed = options.closed ?? (options.states ? states.slice(1) : ["handled"]);
+	for (const state of closed) if (!states.includes(state)) throw new Error(`Inbox "${name}" closes on "${state}", which isn't one of its states`);
+	for (const state of Object.keys(options.sla ?? {})) if (!states.includes(state)) throw new Error(`Inbox "${name}" has a response time for "${state}", which isn't one of its states`);
+	return {
+		[KIND]: "inbox",
+		origin: captureOrigin(),
+		name,
+		options,
+		states,
+		closed
+	};
+}
+function liveView(title, data, record) {
+	return {
+		title,
+		data,
+		record,
+		occurrences: { live: "occurrences" },
+		users: { live: "users" },
+		firstSeen: { live: "firstSeen" },
+		lastSeen: { live: "lastSeen" },
+		due: { live: "due" }
+	};
+}
+//#endregion
+//#region src/define/triage.ts
+function noul(prompt, criteria) {
+	return {
+		type: "noul",
+		prompt,
+		...criteria ? { criteria } : {}
+	};
+}
+function choice(options, prompt) {
+	return {
+		type: "choice",
+		prompt,
+		options: Array.isArray(options) ? Object.fromEntries(options.map((option) => [option, option])) : options
+	};
+}
+function score(levels, prompt) {
+	return {
+		type: "score",
+		prompt,
+		levels: [...levels]
+	};
+}
+function triage(options) {
+	return {
+		instructions: options.instructions ?? "",
+		questions: options.questions,
+		rules: options.rules ?? []
+	};
+}
+const setState = (state) => ({
+	type: "state",
+	state
+});
+const tag = (name) => ({
+	type: "tag",
+	tag: name
+});
+const run = (action, input) => ({
+	type: "run",
+	action: action.id,
+	input
+});
+function decide(rules, answers) {
+	const index = rules.findIndex((rule) => rule.when(answers));
+	if (index === -1) return null;
+	const then = rules[index].then;
+	return {
+		rule: index,
+		decisions: Array.isArray(then) ? then : [then]
+	};
+}
+//#endregion
+//#region src/define/resource.ts
+function action(name, options) {
+	return {
+		[KIND]: "action",
+		origin: captureOrigin(),
+		options,
+		resource: null,
+		name,
+		id: name
+	};
+}
+const identity = (value) => value;
+function resource(name, options) {
+	const origin = captureOrigin();
+	const actions = { "*": { id: `${name}.*` } };
+	for (const [key, action] of Object.entries(options.actions?.(identity) ?? {})) actions[key] = {
+		[KIND]: "action",
+		origin,
+		options: action,
+		resource: name,
+		name: key,
+		id: `${name}.${key}`
+	};
+	return {
+		[KIND]: "resource",
+		origin,
+		name,
+		options,
+		actions
+	};
+}
+function recordId(resource, record) {
+	return resource.options.id ? resource.options.id(record) : String(record.id);
+}
+//#endregion
+//#region src/client/records.ts
+function resourceOf(definitions, name) {
+	const resource = definitions.resources.get(name);
+	if (!resource) throw new Error(`Unknown resource "${name}"`);
+	return resource;
+}
+async function target(definitions, action, id) {
+	if (action.resource === null) return null;
+	const resource = resourceOf(definitions, action.resource);
+	const record = id === null ? null : await resource.options.get(id);
+	if (!record) throw new Error(`${resource.name} ${id} doesn't exist`);
+	return record;
+}
+function found(resource, record) {
+	return {
+		id: recordId(resource, record),
+		title: resource.options.title(record),
+		subtitle: resource.options.subtitle?.(record)
+	};
+}
+function listed(resource, record) {
+	return {
+		...found(resource, record),
+		fields: fieldValues(resource.options.fields?.(record) ?? {})
+	};
+}
+async function find(definitions, request) {
+	const resource = resourceOf(definitions, request.resource);
+	if (!resource.options.find) return [];
+	return (await resource.options.find(request.query, request.limit)).slice(0, request.limit).map((record) => found(resource, record));
+}
+async function get(definitions, request, upload) {
+	const resource = resourceOf(definitions, request.resource);
+	const record = await resource.options.get(request.id);
+	if (!record) return null;
+	const blocks = resource.options.render ? await resource.options.render(record) : [];
+	return {
+		...found(resource, record),
+		url: resource.options.url?.(record),
+		blocks: await settle(definitions, await upload(blocks), {
+			resource,
+			record
+		})
+	};
+}
+async function list(definitions, request) {
+	const resource = resourceOf(definitions, request.resource);
+	const options = resource.options.list;
+	if (!options) throw new Error(`${resource.name} can't be listed`);
+	const filters = options.filters ? await validate(options.filters, request.filters) : {};
+	const page = await options.run({
+		query: request.query,
+		filters,
+		cursor: request.cursor,
+		limit: request.limit
+	});
+	return {
+		records: page.records.slice(0, request.limit).map((record) => listed(resource, record)),
+		cursor: page.cursor ?? null
+	};
+}
+async function related(definitions, request) {
+	const resource = resourceOf(definitions, request.resource);
+	const relation = resource.options.related?.[request.relation];
+	if (!relation) throw new Error(`${resource.name} has no relation "${request.relation}"`);
+	const record = await resource.options.get(request.id);
+	if (!record) return [];
+	const target = resourceOf(definitions, relation.resource);
+	return (await relation.list(record, request.limit)).slice(0, request.limit).map((entry) => listed(target, entry));
+}
+async function choices(definitions, request) {
+	const action = findAction(definitions, request.action);
+	if (!action) throw new Error(`Unknown action "${request.action}"`);
+	const record = await target(definitions, action, request.record).catch(() => void 0);
+	if (record === void 0) return {};
+	const entries = Object.entries(action.options.choices ?? {});
+	const resolved = await Promise.all(entries.map(async ([field, options]) => [field, (await options(record)).map(toChoice)]));
+	return Object.fromEntries(resolved);
+}
+function toChoice(choice) {
+	return typeof choice === "string" ? {
+		value: choice,
+		label: choice
+	} : choice;
+}
+async function titles(definitions, request) {
+	const resolved = await Promise.all(request.refs.map(async (ref) => {
+		const resource = definitions.resources.get(ref.resource);
+		const record = resource && await resource.options.get(ref.id);
+		return record ? [refKey(ref), resource.options.title(record)] : null;
+	}));
+	return Object.fromEntries(resolved.filter((entry) => entry !== null));
+}
+async function available(definitions, request) {
+	const availability = {};
+	for (const ref of request.refs) {
+		const resource = definitions.resources.get(ref.resource);
+		const record = resource && await resource.options.get(ref.id);
+		if (!resource || !record) continue;
+		const actions = {};
+		for (const [name, action] of Object.entries(resource.actions)) {
+			if (!("options" in action)) continue;
+			const { when, defaults } = action.options;
+			if (when && !when(record)) continue;
+			actions[name] = defaults ? JSON.parse(JSON.stringify(defaults(record))) : null;
+		}
+		availability[`${ref.resource}:${ref.id}`] = actions;
+	}
+	return availability;
+}
+async function settle(definitions, blocks, scope) {
+	const bound = scope ? bindActions(blocks, scope.resource, recordId(scope.resource, scope.record)) : blocks;
+	const loaded = /* @__PURE__ */ new Map();
+	if (scope) loaded.set(`${scope.resource.name}:${recordId(scope.resource, scope.record)}`, Promise.resolve(scope.record));
+	const load = (resource, id) => {
+		const key = `${resource.name}:${id}`;
+		if (!loaded.has(key)) loaded.set(key, Promise.resolve(resource.options.get(id)));
+		return loaded.get(key);
+	};
+	const verdict = async ({ action: id, record: target }) => {
+		const action = findAction(definitions, id);
+		if (!action) return { applies: true };
+		const record = action.resource && target !== null ? await load(resourceOf(definitions, action.resource), target) : null;
+		if (action.resource && target !== null && !record) return { applies: false };
+		if (record && action.options.when && !action.options.when(record)) return { applies: false };
+		const defaults = action.options.input ? action.options.defaults?.(record) : void 0;
+		return {
+			applies: true,
+			...defaults && { defaults: JSON.parse(JSON.stringify(defaults)) }
+		};
+	};
+	const targets = /* @__PURE__ */ new Map();
+	const keyOf = (target) => `${target.action}@${target.record ?? ""}`;
+	const visit = (target) => {
+		if (!targets.has(keyOf(target))) targets.set(keyOf(target), verdict(target));
+	};
+	const editsIn = (value) => {
+		if (value && typeof value === "object" && "edit" in value) visit(value.edit);
+	};
+	eachBlock(bound, (block) => {
+		if (block.type === "actions") for (const button of block.actions) visit(button);
+		if (block.type === "form") visit(block.form);
+		if (block.type === "fields") for (const field of block.fields) editsIn(field.value);
+		if (block.type === "stats") for (const stat of block.stats) editsIn(stat.value);
+		if (block.type === "table") for (const row of block.rows) for (const value of row) editsIn(value);
+	});
+	if (!targets.size) return bound;
+	const verdicts = new Map(await Promise.all([...targets].map(async ([key, pending]) => [key, await pending])));
+	const editable = (value) => value && typeof value === "object" && "edit" in value && !verdicts.get(keyOf(value.edit))?.applies ? value.edit.value : value;
+	const settled = (button) => {
+		const found = verdicts.get(keyOf(button));
+		if (!found.applies) return null;
+		return found.defaults ? {
+			...button,
+			input: {
+				...found.defaults,
+				...button.input
+			}
+		} : button;
+	};
+	return mapBlocks(bound, (block) => {
+		if (block.type === "actions") {
+			const actions = block.actions.flatMap((button) => settled(button) ?? []);
+			return actions.length ? {
+				...block,
+				actions
+			} : null;
+		}
+		if (block.type === "form") {
+			const form = settled(block.form);
+			return form ? {
+				...block,
+				form
+			} : null;
+		}
+		if (block.type === "fields") return {
+			...block,
+			fields: block.fields.map((field) => ({
+				...field,
+				value: editable(field.value)
+			}))
+		};
+		if (block.type === "stats") return {
+			...block,
+			stats: block.stats.map((stat) => ({
+				...stat,
+				value: editable(stat.value)
+			}))
+		};
+		if (block.type === "table") return {
+			...block,
+			rows: block.rows.map((row) => row.map(editable))
+		};
+		return block;
+	});
+}
+//#endregion
+//#region src/client/actions.ts
+const ignoreProgress = async () => {};
+async function runAction(definitions, manifest, { id, request, actor }, upload, jobs) {
+	const action = findAction(definitions, request.action);
+	if (!action) throw new Error(`Unknown action "${request.action}"`);
+	const def = findActionDef(manifest, request.action);
+	const record = await target(definitions, action, request.record);
+	if (action.options.when && !action.options.when(record)) {
+		const title = resourceOf(definitions, action.resource).options.title(record);
+		throw new Error(`${def?.label ?? action.name} doesn't apply to ${title} right now`);
+	}
+	const raw = reviveDates(def?.input ?? null, request.input);
+	const input = action.options.input ? await validate(action.options.input, raw) : {};
+	const background = Boolean(action.options.background) && !request.preview;
+	const progress = background ? (fraction, note) => jobs.report(id, {
+		progress: fraction,
+		note
+	}) : ignoreProgress;
+	const context = {
+		record,
+		input,
+		actor,
+		item: request.item,
+		progress
+	};
+	if (request.preview) {
+		if (!action.options.preview) return {};
+		return { blocks: await upload(await action.options.preview(context)) };
+	}
+	if (!background) return toResult(await action.options.run(context), upload);
+	jobs.defer((async () => {
+		try {
+			await jobs.report(id, { result: await toResult(await action.options.run(context), upload) });
+		} catch (error) {
+			await jobs.report(id, { error: error.message });
+		}
+	})());
+	return { running: true };
+}
+async function toResult(value, upload) {
+	if (!value) return {};
+	if (typeof value === "string") return { message: value };
+	return {
+		message: value.message,
+		blocks: value.blocks && await upload(value.blocks)
+	};
+}
+//#endregion
+//#region src/client/dispatch.ts
+var Dispatcher = class {
+	project;
+	upload;
+	report;
+	#definitions = null;
+	constructor(project, upload, report) {
+		this.project = project;
+		this.upload = upload;
+		this.report = report;
+	}
+	definitions() {
+		this.#definitions ??= Promise.all(Object.values(this.project.modules).map((load) => load())).then(collect);
+		return this.#definitions;
+	}
+	async handle(envelope, defer = () => {}) {
+		const { request } = envelope;
+		const definitions = await this.definitions();
+		switch (request.kind) {
+			case "ping": return null;
+			case "action": return runAction(definitions, this.project.manifest, envelope, this.upload, {
+				report: this.report,
+				defer
+			});
+			case "find": return find(definitions, request);
+			case "get": return get(definitions, request, this.upload);
+			case "list": return list(definitions, request);
+			case "related": return related(definitions, request);
+			case "choices": return choices(definitions, request);
+			case "titles": return titles(definitions, request);
+			case "available": return available(definitions, request);
+			case "page": return this.#page(definitions, envelope);
+			case "render": return renderItem(this.#inbox(definitions, request.inbox), request, this.upload);
+			case "triage": return this.#triage(definitions, request);
+			case "replay": return this.#replay(definitions, request);
+			case "state": return this.#state(definitions, envelope);
+			case "reply": return this.#reply(definitions, envelope);
+		}
+	}
+	async #page(definitions, { request, actor }) {
+		const page = definitions.pages.get(request.page);
+		if (!page) throw new Error(`Unknown page "${request.page}"`);
+		const { params, render } = page.options;
+		const parsed = params ? await validate(params, request.params) : {};
+		const blocks = typeof render === "function" ? await render({
+			params: parsed,
+			actor
+		}) : render;
+		return settle(definitions, await this.upload(blocks), null);
+	}
+	#inbox(definitions, name) {
+		const inbox = definitions.inboxes.get(name);
+		if (!inbox) throw new Error(`Unknown inbox "${name}"`);
+		return inbox;
+	}
+	async #state(definitions, { request, actor }) {
+		const inbox = this.#inbox(definitions, request.inbox);
+		const item = {
+			id: request.item,
+			title: request.title,
+			record: request.record,
+			data: request.data
+		};
+		await inbox.options.onState?.({
+			item,
+			from: request.from,
+			to: request.to,
+			actor
+		});
+		return null;
+	}
+	async #reply(definitions, { request, actor }) {
+		const reply = this.#inbox(definitions, request.inbox).options.reply;
+		if (!reply) throw new Error(`${request.inbox} can't send email`);
+		const { item, to, subject, text, thread } = request;
+		await reply.send({
+			item,
+			to,
+			subject,
+			text,
+			thread,
+			actor
+		});
+		return null;
+	}
+	#replay(definitions, request) {
+		const rules = this.#inbox(definitions, request.inbox).options.triage?.rules ?? [];
+		return request.answers.map((answers) => decide(rules, answers));
+	}
+	#triage(definitions, request) {
+		const inbox = this.#inbox(definitions, request.inbox);
+		return inbox.options.triage ? decide(inbox.options.triage.rules, request.answers) : null;
+	}
+};
+async function renderItem(inbox, item, upload) {
+	const data = inbox.options.data ? await validate(inbox.options.data, item.data) : item.data;
+	const title = item.title || inbox.options.title?.(data) || inbox.options.label || inbox.name;
+	const view = liveView(title, data, item.record ?? null);
+	const blocks = inbox.options.render ? await inbox.options.render(view) : defaultBlocks(data);
+	return {
+		title,
+		record: item.record ?? void 0,
+		data: JSON.parse(JSON.stringify(data)),
+		blocks: bindActions(await upload(blocks), inbox.options.resource ?? null, item.record ?? null),
+		replyTo: inbox.options.reply?.to(view)
+	};
+}
+function defaultBlocks(data) {
+	if (!data || typeof data !== "object") return [];
+	const fields = Object.entries(data).filter(([, value]) => value !== null && typeof value !== "object").map(([label, value]) => ({
+		label,
+		value
+	}));
+	return fields.length ? [{
+		type: "fields",
+		fields
+	}] : [];
+}
+//#endregion
+//#region src/client/flags.ts
+const FRESH_MS = 1e4;
+const EMPTY = {
+	version: -1,
+	flags: {}
+};
+var Flags = class {
+	transport;
+	#snapshot = null;
+	#checkedAt = 0;
+	#live = false;
+	#refreshing = null;
+	#parsed = /* @__PURE__ */ new Map();
+	#reads = /* @__PURE__ */ new Map();
+	constructor(transport) {
+		this.transport = transport;
+	}
+	receive(snapshot) {
+		this.#live = snapshot !== null;
+		if (snapshot) this.#store(snapshot);
+	}
+	async value(flag, context) {
+		this.#reads.set(flag.name, (this.#reads.get(flag.name) ?? 0) + 1);
+		const state = (await this.#current()).flags[flag.name];
+		const raw = state === void 0 ? void 0 : resolveFlag(flag.name, state, contextOf(context));
+		if (raw === void 0 || raw === null) return flag.options.default;
+		return this.#validated(flag, raw);
+	}
+	takeReads() {
+		if (!this.#reads.size) return null;
+		const reads = Object.fromEntries(this.#reads);
+		this.#reads.clear();
+		return reads;
+	}
+	#store(snapshot) {
+		if (snapshot.version !== this.#snapshot?.version) this.#parsed.clear();
+		this.#snapshot = snapshot;
+		this.#checkedAt = Date.now();
+	}
+	async #current() {
+		const fresh = this.#live || Date.now() - this.#checkedAt < FRESH_MS;
+		if (this.#snapshot && fresh) return this.#snapshot;
+		if (onWorkers) return this.#refresh();
+		this.#refreshing ??= this.#refresh().finally(() => {
+			this.#refreshing = null;
+		});
+		return this.#refreshing;
+	}
+	async #refresh() {
+		const since = this.#snapshot?.version ?? -1;
+		const reads = this.takeReads();
+		const counted = reads ? `&reads=${encodeURIComponent(Object.entries(reads).map(([name, count]) => `${name}:${count}`).join(","))}` : "";
+		try {
+			const answer = await this.transport.request("GET", `/v1/flags?since=${since}${counted}`);
+			if ("unchanged" in answer) this.#checkedAt = Date.now();
+			else this.#store(answer);
+		} catch {
+			this.#checkedAt = Date.now();
+		}
+		return this.#snapshot ?? EMPTY;
+	}
+	#validated(flag, raw) {
+		const key = `${flag.name}\u0000${JSON.stringify(raw)}`;
+		let parsed = this.#parsed.get(key);
+		if (!parsed) {
+			const schema = flag.options.value;
+			parsed = schema ? validate(schema, raw).catch(() => flag.options.default) : Promise.resolve(typeof raw === "boolean" ? raw : flag.options.default);
+			this.#parsed.set(key, parsed);
+		}
+		return parsed;
+	}
+};
+function contextOf(context) {
+	if (context === void 0 || typeof context === "string") return { key: context };
+	const { key, ...attributes } = context;
+	return {
+		key,
+		attributes
+	};
+}
+//#endregion
+//#region src/client/socket.ts
+const HEARTBEAT_MS = 25e3;
+const MAX_BACKOFF_MS = 3e4;
+function connect({ transport, version, onRequest, onSyncManifest, onFlags, reads, onStatus }) {
+	const nonces = new NonceWindow();
+	let socket = null;
+	let heartbeat;
+	let attempt = 0;
+	let closed = false;
+	const send = (message) => socket?.send(JSON.stringify(message));
+	const respond = async (response) => {
+		const body = JSON.stringify(response);
+		send({
+			type: "response",
+			signature: await sign(transport.key.secret, "response", body),
+			body
+		});
+	};
+	const handle = async (message) => {
+		if (message.type === "welcome") {
+			attempt = 0;
+			onStatus?.("connected");
+			const manifest = message.syncManifest ? onSyncManifest(message.environment) : null;
+			if (manifest) send(manifest);
+			return;
+		}
+		if (message.type === "flags") {
+			onFlags(message.snapshot);
+			return;
+		}
+		if (await verify(transport.key.secret, "request", message.body, message.signature) || !nonces.claim(message.signature.nonce)) return;
+		const envelope = JSON.parse(message.body);
+		try {
+			await respond({
+				id: envelope.id,
+				ok: true,
+				result: await onRequest(envelope) ?? null
+			});
+		} catch (error) {
+			await respond({
+				id: envelope.id,
+				ok: false,
+				error: { message: error.message }
+			});
+		}
+	};
+	const open = async () => {
+		const signature = await sign(transport.key.secret, "connect", version);
+		const params = new URLSearchParams({
+			environment: transport.key.environment,
+			version,
+			...signature
+		});
+		socket = new WebSocket(`${transport.url.replace(/^http/, "ws")}/v1/connect?${params}`);
+		socket.addEventListener("message", (event) => {
+			if (event.data !== "pong") handle(JSON.parse(String(event.data)));
+		});
+		socket.addEventListener("open", () => {
+			heartbeat = setInterval(() => {
+				socket?.send("ping");
+				const counted = reads();
+				if (counted) send({
+					type: "reads",
+					reads: counted
+				});
+			}, HEARTBEAT_MS);
+		});
+		socket.addEventListener("close", () => {
+			if (heartbeat) clearInterval(heartbeat);
+			onFlags(null);
+			onStatus?.("disconnected");
+			if (closed) return;
+			const delay = Math.min(MAX_BACKOFF_MS, 500 * 2 ** attempt++) * (.5 + Math.random() / 2);
+			setTimeout(open, delay);
+		});
+	};
+	open();
+	return { close() {
+		closed = true;
+		socket?.close();
+	} };
+}
+//#endregion
+//#region src/client/pult.ts
+function createPult({ key = env("PULT_KEY"), project, url = env("PULT_URL") ?? "https://app.pult.sh", fetch = globalThis.fetch }) {
+	if (!key) throw new Error("Pult needs a key: pass `key` or set PULT_KEY");
+	const transport = new Transport(key, url, (input, init) => fetch(input, init));
+	const upload = async (blocks) => Promise.all(blocks.map(async (block) => {
+		if (!isPendingAttachment(block)) return block;
+		const data = block.data instanceof Blob ? block.data : new Uint8Array(block.data);
+		const { key } = await transport.upload(block.name, block.contentType, data);
+		return {
+			type: "attachment",
+			name: block.name,
+			key,
+			contentType: block.contentType,
+			size: byteLength(data)
+		};
+	}));
+	const report = async (job, update) => {
+		await transport.request("POST", `/v1/jobs/${job}`, update);
+	};
+	const dispatcher = new Dispatcher(project, upload, report);
+	const { manifest } = project;
+	const deploy = () => transport.request("POST", "/v1/manifest", manifest);
+	const sync = () => transport.request("POST", "/v1/manifest/sync", manifest);
+	const batcher = new Batcher(transport, sync);
+	const flags = new Flags(transport);
+	async function send(inbox, item) {
+		const rendered = await renderItem(inbox, item, upload);
+		return batcher.send({
+			inbox: inbox.name,
+			fingerprint: item.fingerprint,
+			tags: item.tags,
+			suggest: item.suggest?.map(({ action, ...rest }) => ({
+				action: action.id,
+				...rest
+			})),
+			version: manifest.version,
+			...rendered
+		});
+	}
+	async function log(resource, id, text, options = {}) {
+		await transport.request("POST", "/v1/history", {
+			resource: resource.name,
+			id,
+			text,
+			by: options.by,
+			blocks: options.blocks && await upload(options.blocks)
+		});
+	}
+	async function receive(message) {
+		try {
+			return await transport.request("POST", "/v1/messages", message);
+		} catch (error) {
+			if (error instanceof PultError && error.code === "no_thread") return null;
+			throw error;
+		}
+	}
+	function listen(options = {}) {
+		return connect({
+			transport,
+			version: manifest.version,
+			onRequest: (envelope) => dispatcher.handle(envelope),
+			onSyncManifest: (environment) => environment === manifest.sync ? {
+				type: "manifest",
+				manifest
+			} : null,
+			onFlags: (snapshot) => flags.receive(snapshot),
+			reads: () => flags.takeReads(),
+			onStatus: options.onStatus
+		});
+	}
+	function handler() {
+		const nonces = new NonceWindow();
+		return async (request, context) => {
+			const body = await request.text();
+			const signature = signedHeaders(request.headers);
+			const failure = signature && await verify(transport.key.secret, "request", body, signature);
+			if (!signature || failure || !nonces.claim(signature.nonce)) return Response.json({ error: "invalid signature" }, { status: 401 });
+			const envelope = JSON.parse(body);
+			let response;
+			try {
+				const result = await dispatcher.handle(envelope, (work) => context?.waitUntil(work));
+				response = {
+					id: envelope.id,
+					ok: true,
+					result: result ?? null
+				};
+			} catch (error) {
+				response = {
+					id: envelope.id,
+					ok: false,
+					error: { message: error.message }
+				};
+			}
+			const payload = JSON.stringify(response);
+			const signed = await sign(transport.key.secret, "response", payload);
+			return new Response(payload, { headers: {
+				"content-type": "application/json",
+				[HEADER.timestamp]: signed.timestamp,
+				[HEADER.nonce]: signed.nonce,
+				[HEADER.signature]: signed.signature
+			} });
+		};
+	}
+	const status = { async set(component, state) {
+		if (!manifest.status?.components[component]) throw new Error(`Your status page has no component "${component}"`);
+		await transport.request("POST", "/v1/status", {
+			component,
+			state
+		});
+	} };
+	function flag(definition, context) {
+		return flags.value(definition, context);
+	}
+	return {
+		send,
+		log,
+		receive,
+		flag,
+		status,
+		listen,
+		handler,
+		deploy
+	};
+}
+function signedHeaders(headers) {
+	const timestamp = headers.get(HEADER.timestamp);
+	const nonce = headers.get(HEADER.nonce);
+	const signature = headers.get(HEADER.signature);
+	return timestamp && nonce && signature ? {
+		timestamp,
+		nonce,
+		signature
+	} : null;
+}
+function byteLength(data) {
+	return data instanceof Blob ? data.size : data.byteLength;
+}
+function env(name) {
+	return globalThis.process?.env[name];
+}
+//#endregion
+//#region src/define/config.ts
+function defineConfig(options) {
+	const environments = options.environments ?? [
+		"dev",
+		"staging",
+		"prod"
+	];
+	const sync = options.sync ?? environments[0];
+	if (!environments.includes(sync)) throw new Error(`sync is "${sync}", which isn't one of your environments (${environments.join(", ")})`);
+	return {
+		[KIND]: "config",
+		origin: captureOrigin(),
+		options: {
+			delivery: { mode: "socket" },
+			...options,
+			environments,
+			sync
+		}
+	};
+}
+//#endregion
+//#region src/define/notify.ts
+function slack(channel) {
+	return { channel: channel.replace(/^#/, "") };
+}
+function notify(name, options) {
+	return {
+		[KIND]: "notify",
+		origin: captureOrigin(),
+		name,
+		options
+	};
+}
+//#endregion
+//#region src/define/role.ts
+function role(name, options) {
+	return {
+		[KIND]: "role",
+		origin: captureOrigin(),
+		name,
+		options
+	};
+}
+//#endregion
+//#region src/define/status.ts
+function status(options) {
+	return {
+		[KIND]: "status",
+		origin: captureOrigin(),
+		options
+	};
+}
+//#endregion
+export { PultError, ValidationError, action, b, choice, createPult, defineConfig, flag, home, inbox, notify, noul, page, resource, role, run, score, setState, slack, status, tag, triage, view };