@dispatch-foo/protocol 0.0.0-stage → 0.2.0

package/dist/serve-CVPZbCpT.js

@@ -0,0 +1,672 @@
+import { d as SYSTEM_ADDRESS, o as GATE_TYPES, r as DELIVERY_STATES } from "./constants-CRXF4f7g.js";
+import { C as parseAddress, c as createUlidFactory, g as gateOf, i as openMessagesDb, l as renderDigestLine, r as SqliteMessageStore, s as DeliveryEngine, t as PROTOCOL_VERSION, u as renderForAgent, v as validateSendInput, w as MessagingError } from "./version-Ds8ZFZLh.js";
+import { queryAll } from "@dispatch-foo/core";
+
+//#region src/conformance/errors.ts
+var UnsupportedOp = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UnsupportedOp";
+	}
+};
+
+//#endregion
+//#region src/conformance/fields.ts
+function malformed(where, why) {
+	throw new Error(`malformed vector field ${where}: ${why}`);
+}
+function isObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asObject(value, where) {
+	return isObject(value) ? value : malformed(where, "expected an object");
+}
+function text(obj, key, where) {
+	const value = obj[key];
+	return typeof value === "string" ? value : malformed(`${where}.${key}`, "expected a string");
+}
+function optionalText(obj, key, where) {
+	return obj[key] === void 0 ? void 0 : text(obj, key, where);
+}
+function texts(value, where) {
+	if (!Array.isArray(value)) return malformed(where, "expected a list");
+	return value.map((v, i) => typeof v === "string" ? v : malformed(`${where}[${i}]`, "expected a string"));
+}
+function bare(session) {
+	return session.startsWith("run:") ? session.slice(4) : session;
+}
+
+//#endregion
+//#region src/conformance/host.ts
+const DEFAULT_CLOCK = "2026-09-23T10:00:00.000Z";
+const RULINGS = [
+	"allow",
+	"ask",
+	"deny"
+];
+function worldFrom(given) {
+	const world = {
+		clockMs: Date.parse(given.clock ?? DEFAULT_CLOCK),
+		liveRuns: /* @__PURE__ */ new Map(),
+		runTasks: /* @__PURE__ */ new Map(),
+		auxRuns: new Set((given.auxSessions ?? []).map(bare)),
+		implicit: new Map(Object.entries(given.implicit ?? {})),
+		owner: given.owner ?? "human:owner",
+		rulings: new Map(Object.entries(given.rulings ?? {})),
+		wakeResults: new Map(Object.entries(given.wakeResults ?? {}).map(([target, r]) => [target, r.ok ? {
+			ok: true,
+			runId: bare(r.session)
+		} : r])),
+		failPush: new Set((given.failPush ?? []).map(bare)),
+		failOnAnswered: given.failOnAnswered === true,
+		external: new Map(Object.entries(given.external ?? {}))
+	};
+	for (const item of given.workItems ?? []) {
+		for (const s of item.sessions ?? []) world.runTasks.set(bare(s), item.id);
+		if (item.liveSession !== void 0) {
+			world.liveRuns.set(item.id, bare(item.liveSession));
+			world.runTasks.set(bare(item.liveSession), item.id);
+		}
+	}
+	return world;
+}
+function rulingOf(value, where) {
+	return RULINGS.find((r) => r === value) ?? malformed(where, `expected one of ${RULINGS.join(", ")}`);
+}
+function wakeResultOf(value, where) {
+	const r = asObject(value, where);
+	if (r["ok"] === true) return {
+		ok: true,
+		runId: bare(text(r, "session", where))
+	};
+	if (r["ok"] === false) return {
+		ok: false,
+		reason: text(r, "reason", where)
+	};
+	return malformed(`${where}.ok`, "expected a boolean");
+}
+function applyWorld(world, change) {
+	const keys = Object.keys(change);
+	const key = keys[0];
+	if (keys.length !== 1 || key === void 0) throw new UnsupportedOp(`a world change names exactly one key, not ${keys.length}`);
+	const value = change[key];
+	const where = `world.${key}`;
+	switch (key) {
+		case "startSession": {
+			const s = asObject(value, where);
+			const item = text(s, "workItem", where);
+			const run = bare(text(s, "session", where));
+			world.liveRuns.set(item, run);
+			world.runTasks.set(run, item);
+			return;
+		}
+		case "endSession":
+			world.liveRuns.delete(text(asObject(value, where), "workItem", where));
+			return;
+		case "ruling": {
+			const r = asObject(value, where);
+			world.rulings.set(text(r, "target", where), rulingOf(r["ruling"], `${where}.ruling`));
+			return;
+		}
+		case "wakeResult": {
+			const r = asObject(value, where);
+			world.wakeResults.set(text(r, "target", where), wakeResultOf(r["result"], `${where}.result`));
+			return;
+		}
+		case "failPush":
+			world.failPush = new Set(texts(value, where).map(bare));
+			return;
+		case "failOnAnswered":
+			if (typeof value !== "boolean") malformed(where, "expected a boolean");
+			world.failOnAnswered = value;
+			return;
+		case "advanceMs":
+			if (typeof value !== "number" || !Number.isFinite(value)) malformed(where, "expected a number");
+			world.clockMs += value;
+			return;
+		default: throw new UnsupportedOp(`world change ${key} is not implemented`);
+	}
+}
+var ConformanceHost = class {
+	calls = [];
+	constructor(world) {
+		this.world = world;
+	}
+	liveRunFor(taskId) {
+		return this.world.liveRuns.get(taskId) ?? null;
+	}
+	isLiveRun(runId) {
+		return this.world.auxRuns.has(runId) || [...this.world.liveRuns.values()].includes(runId);
+	}
+	taskOfRun(runId) {
+		return this.world.runTasks.get(runId) ?? null;
+	}
+	push(runId, _rendered, message) {
+		this.calls.push({
+			hook: "push",
+			session: `run:${runId}`,
+			message: message.id
+		});
+		return this.settle(runId, "push failed");
+	}
+	notify(runId, _digest, message) {
+		this.calls.push({
+			hook: "notify",
+			session: `run:${runId}`,
+			message: message.id
+		});
+		return this.settle(runId, "notify failed");
+	}
+	notifyHuman(actor, message) {
+		this.calls.push({
+			hook: "notifyHuman",
+			actor,
+			message: message.id
+		});
+	}
+	wake(target, message) {
+		this.calls.push({
+			hook: "wake",
+			target,
+			message: message.id
+		});
+		return Promise.resolve(this.world.wakeResults.get(target) ?? {
+			ok: true,
+			runId: "r-00000f"
+		});
+	}
+	decide(request) {
+		this.calls.push({
+			hook: "decide",
+			target: request.target,
+			message: request.message.id
+		});
+		return this.world.rulings.get(request.target) ?? "deny";
+	}
+	owner() {
+		return this.world.owner;
+	}
+	implicitMembers(channel) {
+		return this.world.implicit.get(channel) ?? [];
+	}
+	onAnswered(question, answer) {
+		this.calls.push({
+			hook: "onAnswered",
+			question: question.id,
+			answer: answer.id
+		});
+		if (this.world.failOnAnswered) return Promise.reject(/* @__PURE__ */ new Error("effect failed"));
+		const gate = gateOf(question);
+		if (gate?.type === "wake" && answer.choice === "approve") this.calls.push({
+			hook: "wake",
+			target: gate.target,
+			message: gate.message
+		});
+		return Promise.resolve();
+	}
+	now() {
+		return new Date(this.world.clockMs);
+	}
+	external(address) {
+		return this.world.external.get(address) ?? null;
+	}
+	admitExternal(target, _sender, _replyTarget, message) {
+		this.calls.push({
+			hook: "admitExternal",
+			recipient: target.recipient,
+			message: message.id
+		});
+		return "deliver";
+	}
+	settle(runId, why) {
+		return this.world.failPush.has(runId) ? Promise.reject(new Error(why)) : Promise.resolve();
+	}
+};
+
+//#endregion
+//#region src/conformance/seed.ts
+function seededBytes(seed) {
+	let state = seed >>> 0;
+	return (n) => {
+		const out$1 = new Uint8Array(n);
+		for (let i = 0; i < n; i++) {
+			state = state + 1831565813 >>> 0;
+			let t = state;
+			t = Math.imul(t ^ t >>> 15, t | 1);
+			t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+			out$1[i] = (t ^ t >>> 14) & 255;
+		}
+		return out$1;
+	};
+}
+
+//#endregion
+//#region src/conformance/seedStore.ts
+const VIAS = ["direct", "channel"];
+function nullableText(obj, key, where) {
+	return obj[key] === null ? null : optionalText(obj, key, where) ?? null;
+}
+function refsOf(value, where) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) return malformed(where, "expected a list");
+	return value.map((raw, i) => {
+		const at = `${where}[${i}]`;
+		const r = asObject(raw, at);
+		const ref = {
+			type: text(r, "type", at),
+			id: text(r, "id", at)
+		};
+		const commit = optionalText(r, "at", at);
+		if (commit !== void 0) ref.at = commit;
+		return ref;
+	});
+}
+function seededMessage(row, at, where) {
+	const id = text(row, "id", where);
+	const message = {
+		id,
+		thread: optionalText(row, "thread", where) ?? id,
+		replyTo: nullableText(row, "replyTo", where),
+		from: text(row, "from", where),
+		to: texts(row["to"], `${where}.to`),
+		kind: text(row, "kind", where),
+		body: text(row, "body", where),
+		refs: refsOf(row["refs"], `${where}.refs`),
+		urgent: row["urgent"] === true,
+		blocking: row["blocking"] === true,
+		wake: row["wake"] === "request" ? "request" : "none",
+		createdAt: optionalText(row, "createdAt", where) ?? at
+	};
+	const session = optionalText(row, "session", where);
+	if (session !== void 0) message.session = session;
+	const data = row["data"];
+	if (data !== void 0) message.data = data;
+	if (row["choices"] !== void 0) message.choices = texts(row["choices"], `${where}.choices`);
+	const choice = optionalText(row, "choice", where);
+	if (choice !== void 0) message.choice = choice;
+	return message;
+}
+function seededDelivery(row, at, where) {
+	const session = nullableText(row, "session", where);
+	const via = row["via"] === void 0 ? "direct" : row["via"];
+	return {
+		id: text(row, "id", where),
+		messageId: text(row, "message", where),
+		recipient: text(row, "recipient", where),
+		runId: session === null ? null : bare(session),
+		via: VIAS.find((v) => v === via) ?? malformed(`${where}.via`, `expected one of ${VIAS.join(", ")}`),
+		state: DELIVERY_STATES.find((s) => s === row["state"]) ?? malformed(`${where}.state`, `expected one of ${DELIVERY_STATES.join(", ")}`),
+		updatedAt: at
+	};
+}
+function seedStore(store, given, world) {
+	const at = new Date(world.clockMs).toISOString();
+	store.transaction(() => {
+		for (const agent of given.agents ?? []) store.putAgent({
+			address: agent.address,
+			displayName: agent.address,
+			client: "conformance",
+			tokenHash: `seed:${agent.address}`,
+			status: agent.status,
+			muted: agent.muted === true,
+			approvedBy: world.owner,
+			createdAt: at
+		});
+		for (const channel of given.channels ?? []) {
+			store.ensureChannel(channel.name, at, false);
+			for (const member of channel.members) store.addMember(channel.name, member, at);
+		}
+		const rows = given.store ?? {};
+		(rows.messages ?? []).forEach((row, i) => store.insertMessage(seededMessage(row, at, `given.store.messages[${i}]`)));
+		(rows.deliveries ?? []).forEach((row, i) => store.insertDelivery(seededDelivery(row, at, `given.store.deliveries[${i}]`)));
+		for (const id of rows.appliedGates ?? []) store.markGateApplied(id, at);
+	});
+}
+
+//#endregion
+//#region src/conformance/adapter.ts
+const CREATES = new Set([
+	"send",
+	"reply",
+	"close",
+	"a2a.inbound"
+]);
+const ROLE = /\$(?:s|gate|notice)[0-9]+\b/g;
+const ORIGINS = ["local", "received"];
+const AGENT_STATUSES = [
+	"pending",
+	"approved",
+	"revoked"
+];
+const REFERENCE_HELLO = {
+	dmp: "hello",
+	implementation: {
+		name: "dispatch-reference",
+		version: PROTOCOL_VERSION
+	},
+	classes: ["envelope", "host-core"],
+	profiles: ["core", "dispatch"],
+	capabilities: ["implicit-members", "muted-senders"],
+	systemAddress: SYSTEM_ADDRESS,
+	gateTypes: [...GATE_TYPES],
+	render: {
+		quotePrefix: "│ ",
+		header: "^\\[message from ",
+		hostLines: [
+			"^\\(in reply to ",
+			"^choices: ",
+			"^choice: ",
+			"^refs: ",
+			"^The sender is waiting\\. "
+		],
+		digestLead: "^📬(?: #[^ ]+ ·)? [^ ]+ from [^ ]+(?: \\(external\\))?: "
+	}
+};
+function mapStrings(value, f) {
+	if (typeof value === "string") return f(value);
+	if (Array.isArray(value)) return value.map((v) => mapStrings(v, f));
+	if (isObject(value)) return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, mapStrings(v, f)]));
+	return value;
+}
+var RoleBinder = class {
+	bound = /* @__PURE__ */ new Map();
+	created = /* @__PURE__ */ new Set();
+	seeded;
+	constructor(db, vector) {
+		this.db = db;
+		this.seeded = new Set((vector.given.store?.messages ?? []).flatMap((r) => typeof r["id"] === "string" ? [r["id"]] : []));
+	}
+	bindStep(step, id) {
+		this.bound.set(`$s${step}`, id);
+		this.created.add(id);
+	}
+	resolve(step) {
+		this.bindRaised();
+		return mapStrings(step, (s) => s.replace(ROLE, (token) => this.bound.get(token) ?? token));
+	}
+	bindRaised() {
+		let gates = 0;
+		let notices = 0;
+		const rows = queryAll(this.db, "SELECT id, kind FROM messages WHERE from_addr = ? ORDER BY rowid", [SYSTEM_ADDRESS]);
+		for (const { id, kind } of rows) {
+			if (this.created.has(id) || this.seeded.has(id)) continue;
+			if (kind === "question") this.bound.set(`$gate${++gates}`, id);
+			else if (kind === "notice") this.bound.set(`$notice${++notices}`, id);
+		}
+	}
+};
+function gateTypesOf(options) {
+	return options.gateTypes ?? GATE_TYPES;
+}
+function senderOf(step) {
+	const as = asObject(step["as"], "as");
+	const canDecide = as["canDecide"];
+	if (typeof canDecide !== "boolean") malformed("as.canDecide", "expected a boolean");
+	return {
+		address: text(as, "address", "as"),
+		canDecide
+	};
+}
+function inputOf(step) {
+	return asObject(step["input"], "input");
+}
+function originOf(step) {
+	const origin = step["origin"] ?? "local";
+	return ORIGINS.find((o) => o === origin) ?? malformed("origin", `expected one of ${ORIGINS.join(", ")}`);
+}
+function sendResult(r) {
+	const result = {
+		message: r.message.id,
+		downgraded: r.downgraded
+	};
+	if (r.replayed === true) result["replayed"] = true;
+	return result;
+}
+function setAgentStatus(store, value) {
+	const where = "world.agentStatus";
+	const change = asObject(value, where);
+	const address = text(change, "address", where);
+	const status = AGENT_STATUSES.find((s) => s === change["status"]) ?? malformed(`${where}.status`, `expected one of ${AGENT_STATUSES.join(", ")}`);
+	const agent = store.getAgent(address) ?? malformed(`${where}.address`, "no such agent");
+	store.putAgent({
+		...agent,
+		status
+	});
+}
+function statesOf(step) {
+	if (step["states"] === void 0) return void 0;
+	return texts(step["states"], "states").map((s) => DELIVERY_STATES.find((d) => d === s) ?? malformed("states", `unknown delivery state ${s}`));
+}
+function createdId(result) {
+	if (result === void 0 || !isObject(result)) return null;
+	const id = result["message"];
+	return typeof id === "string" ? id : null;
+}
+async function runStep(step, ctx, options, record) {
+	const custom = options.ops?.[step.op];
+	if (custom !== void 0) return custom(step, ctx);
+	const { engine, store, host } = ctx;
+	switch (step.op) {
+		case "send": return sendResult(await engine.send(inputOf(step), senderOf(step), { origin: originOf(step) }));
+		case "reply": return sendResult(await engine.reply(text(step, "message", "reply"), inputOf(step), senderOf(step)));
+		case "close": return { message: engine.close(text(step, "question", "close"), text(step, "reason", "close")).id };
+		case "markRead": {
+			const recipient = text(step, "recipient", "markRead");
+			const found = store.deliveries({ messageId: text(step, "message", "markRead") }).find((d) => d.recipient === recipient);
+			if (found === void 0) throw new MessagingError("not-found", `no delivery to ${recipient}`, "recipient");
+			return { state: engine.markRead(found.id).state };
+		}
+		case "inbox": return { messages: engine.inbox(text(step, "recipient", "inbox"), statesOf(step)).map((x) => x.message.id) };
+		case "thread": return { messages: engine.thread(text(step, "thread", "thread")).messages.map((m) => m.id) };
+		case "canRead": return { readable: engine.canRead(text(step, "message", "canRead"), senderOf(step)) };
+		case "openBlocking": return { messages: engine.openBlocking().map((m) => m.id) };
+		case "join":
+			engine.join(text(step, "channel", "join"), text(step, "member", "join"));
+			return {};
+		case "leave": return { removed: engine.leave(text(step, "channel", "leave"), text(step, "member", "leave")) };
+		case "deliverHeld": return { deliveries: (await engine.deliverHeld(bare(text(step, "session", "deliverHeld")), text(step, "workItem", "deliverHeld"))).map((d) => ({
+			message: d.messageId,
+			recipient: d.recipient,
+			state: d.state
+		})) };
+		case "recover": {
+			const { retried, reverted, replayed, voided } = await engine.recover();
+			return {
+				retried,
+				reverted,
+				replayed,
+				voided
+			};
+		}
+		case "parseAddress": return { ...parseAddress(text(step, "input", "parseAddress")) };
+		case "validate": {
+			const as = senderOf(step);
+			const target = optionalText(step, "replyTarget", "validate");
+			validateSendInput(inputOf(step), as.address, as.canDecide, target === void 0 ? null : store.getMessage(target), {
+				gateTypes: new Set(gateTypesOf(options)),
+				origin: originOf(step)
+			});
+			return {};
+		}
+		case "render": {
+			const id = text(step, "message", "render");
+			const message = store.getMessage(id);
+			if (message === null) throw new MessagingError("not-found", `no message ${id}`, "message");
+			const external = step["external"] === true;
+			const rendered = step["form"] === "digest" ? renderDigestLine(message, external) : renderForAgent(message, external);
+			record(rendered);
+			return { text: rendered };
+		}
+		case "world": {
+			const change = asObject(step["change"], "change");
+			const keys = Object.keys(change);
+			if (keys.length === 1 && keys[0] === "agentStatus") setAgentStatus(store, change["agentStatus"]);
+			else applyWorld(host.world, change);
+			return;
+		}
+		default: throw new UnsupportedOp(`op ${step.op} is not implemented`);
+	}
+}
+function observedMessage(m) {
+	return {
+		id: m.id,
+		thread: m.thread,
+		replyTo: m.replyTo,
+		from: m.from,
+		to: m.to,
+		kind: m.kind,
+		body: m.body,
+		refs: m.refs.map((r) => r.at === void 0 ? {
+			type: r.type,
+			id: r.id
+		} : {
+			type: r.type,
+			id: r.id,
+			at: r.at
+		}),
+		...m.data === void 0 ? {} : { data: m.data },
+		urgent: m.urgent,
+		blocking: m.blocking,
+		...m.choices === void 0 ? {} : { choices: m.choices },
+		...m.choice === void 0 ? {} : { choice: m.choice },
+		wake: m.wake,
+		createdAt: m.createdAt
+	};
+}
+function observedDelivery(d) {
+	return {
+		id: d.id,
+		message: d.messageId,
+		recipient: d.recipient,
+		session: d.runId === null ? null : `run:${d.runId}`,
+		via: d.via,
+		state: d.state
+	};
+}
+function observe(id, db, store, host, steps, render) {
+	const messages = queryAll(db, "SELECT id FROM messages ORDER BY rowid").flatMap((row) => {
+		const m = store.getMessage(row.id);
+		return m === null ? [] : [observedMessage(m)];
+	});
+	const gateEffects = queryAll(db, "SELECT question_id FROM gate_effects ORDER BY question_id").map((row) => row.question_id);
+	return {
+		dmp: "observation",
+		id,
+		steps,
+		messages,
+		deliveries: store.deliveries({}).map(observedDelivery),
+		calls: host.calls,
+		gateEffects,
+		voided: queryAll(db, "SELECT answer_id FROM voided_answers ORDER BY answer_id").map((row) => row.answer_id),
+		channels: store.channels().map((c) => ({
+			name: c.name,
+			members: store.members(c.name)
+		})),
+		render
+	};
+}
+async function runVector(vector, options = {}) {
+	const db = openMessagesDb(":memory:");
+	try {
+		const store = new SqliteMessageStore(db);
+		const host = new ConformanceHost(worldFrom(vector.given));
+		seedStore(store, vector.given, host.world);
+		const engine = new DeliveryEngine({
+			store,
+			host,
+			limits: vector.given.limits,
+			newUlid: createUlidFactory(seededBytes(vector.given.seed ?? 1)),
+			gateTypes: gateTypesOf(options)
+		});
+		engine.subscribe((e) => {
+			if (e.type === "message") host.calls.push({
+				hook: "published",
+				message: e.message.id
+			});
+		});
+		const roles = new RoleBinder(db, vector);
+		const steps = [];
+		const render = [];
+		for (const [i, raw] of vector.when.entries()) {
+			const step = roles.resolve(raw);
+			try {
+				const result = await runStep(step, {
+					engine,
+					store,
+					host
+				}, options, (rendered) => render.push({
+					step: i + 1,
+					text: rendered
+				}));
+				steps.push(result === void 0 ? { ok: true } : {
+					ok: true,
+					result
+				});
+				const created = createdId(result);
+				if (CREATES.has(step.op) && created !== null) roles.bindStep(i + 1, created);
+			} catch (err) {
+				if (!(err instanceof MessagingError)) throw err;
+				steps.push({
+					ok: false,
+					error: err.field === void 0 ? { code: err.code } : {
+						code: err.code,
+						field: err.field
+					}
+				});
+			}
+		}
+		return observe(vector.id, db, store, host, steps, render);
+	} finally {
+		db.close();
+	}
+}
+
+//#endregion
+//#region src/conformance/serve.ts
+const SEPARATORS = /[\u2028\u2029]/g;
+function out(msg) {
+	const text$1 = JSON.stringify(msg).replace(SEPARATORS, (c) => `\\u${c.charCodeAt(0).toString(16)}`);
+	process.stdout.write(`${text$1}\n`);
+}
+function serveStdio(hello, run) {
+	async function handle(line) {
+		const msg = JSON.parse(line);
+		if (msg.dmp === "hello") {
+			out(hello);
+			return;
+		}
+		if (msg.dmp === "bye") process.exit(0);
+		if (msg.dmp !== "run" || msg.vector === void 0) return;
+		try {
+			out(await run(msg.vector));
+		} catch (err) {
+			if (!(err instanceof UnsupportedOp)) throw err;
+			out({
+				dmp: "unsupported",
+				id: msg.vector.id,
+				reason: err.message
+			});
+		}
+	}
+	let queue = Promise.resolve();
+	function enqueue(line) {
+		queue = queue.then(() => handle(line)).catch((err) => {
+			const why = err instanceof Error ? err.stack ?? err.message : String(err);
+			process.stderr.write(`${why}\n`, () => process.exit(1));
+		});
+	}
+	let buffered = "";
+	process.stdin.setEncoding("utf8");
+	process.stdin.on("data", (chunk) => {
+		const lines = (buffered + chunk).split("\n");
+		buffered = lines.pop() ?? "";
+		for (const line of lines) enqueue(line.endsWith("\r") ? line.slice(0, -1) : line);
+	});
+	process.stdin.on("end", () => {
+		if (buffered !== "") enqueue(buffered);
+	});
+}
+
+//#endregion
+export { applyWorld as a, ConformanceHost as i, REFERENCE_HELLO as n, worldFrom as o, runVector as r, UnsupportedOp as s, serveStdio as t };
+//# sourceMappingURL=serve-CVPZbCpT.js.map