sh3-core 0.8.0 → 0.8.2

package/dist/server-sync.js

@@ -0,0 +1,634 @@
+// src/documents/journal-hook.ts
+var appender = null;
+function setJournalAppender(fn) {
+  appender = fn;
+}
+
+// src/documents/notifications.ts
+var DocumentChangeEmitter = class {
+  #listeners = /* @__PURE__ */ new Set();
+  subscribe(fn) {
+    this.#listeners.add(fn);
+    return () => {
+      this.#listeners.delete(fn);
+    };
+  }
+  emit(change) {
+    for (const fn of this.#listeners) {
+      try {
+        fn(change);
+      } catch (e) {
+        console.error("SH3: document change listener threw", e);
+      }
+    }
+  }
+};
+var documentChanges = new DocumentChangeEmitter();
+
+// src/documents/sync/hash.ts
+async function hashContent(content) {
+  const buf = typeof content === "string" ? new TextEncoder().encode(content) : new Uint8Array(content);
+  const digest = await crypto.subtle.digest("SHA-256", buf);
+  const hex = Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hex.slice(0, 16);
+}
+
+// src/documents/sync/types.ts
+var SYNC_RESERVED_SHARD_ID = "__sync__";
+var ScopeNotGrantedError = class extends Error {
+  constructor(scope) {
+    super(`Scope not granted: ${JSON.stringify(scope)}`);
+    this.scope = scope;
+    this.name = "ScopeNotGrantedError";
+  }
+};
+
+// src/documents/sync/serialization.ts
+async function readJson(backend, tenantId, path) {
+  const raw = await backend.read(tenantId, SYNC_RESERVED_SHARD_ID, path);
+  if (raw === null) return null;
+  const str = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+  return JSON.parse(str);
+}
+async function writeJson(backend, tenantId, path, value) {
+  await backend.write(tenantId, SYNC_RESERVED_SHARD_ID, path, JSON.stringify(value));
+}
+async function deletePath(backend, tenantId, path) {
+  await backend.delete(tenantId, SYNC_RESERVED_SHARD_ID, path);
+}
+async function listJsonPaths(backend, tenantId, prefix) {
+  const all = await backend.list(tenantId, SYNC_RESERVED_SHARD_ID);
+  return all.map((m) => m.path).filter((p) => p.startsWith(prefix));
+}
+
+// src/documents/sync/journal.ts
+var META_PATH = "journal/meta.json";
+var SEGMENT_PREFIX = "journal/seg-";
+var CURSOR_PREFIX = "cursors/";
+var DEFAULT_SEGMENT_SIZE = 500;
+var DEFAULT_PAGE_SIZE = 100;
+function segmentPath(i) {
+  return `${SEGMENT_PREFIX}${i}.json`;
+}
+function cursorPath(connectorId) {
+  return `${CURSOR_PREFIX}${encodeURIComponent(connectorId)}.json`;
+}
+function matchesScope(entry, scope) {
+  switch (scope.kind) {
+    case "tenant":
+      return true;
+    case "shard":
+      return entry.shardId === scope.shardId;
+    case "path":
+      return entry.shardId === scope.shardId && entry.path.startsWith(scope.prefix);
+  }
+}
+var Journal = class _Journal {
+  constructor(backend, tenantId, opts = {}) {
+    this.backend = backend;
+    this.tenantId = tenantId;
+    this.#segmentSize = opts.segmentSize ?? DEFAULT_SEGMENT_SIZE;
+    this.#pageSize = opts.pageSize ?? DEFAULT_PAGE_SIZE;
+  }
+  #meta = { currentSeq: 0, currentSegment: 0, oldestSegment: 0, version: 0 };
+  #segmentSize;
+  #pageSize;
+  async init() {
+    const meta = await readJson(this.backend, this.tenantId, META_PATH);
+    if (meta) this.#meta = meta;
+  }
+  static encodeCursor(seq, version) {
+    return `${seq}:${version}`;
+  }
+  static decodeCursor(cursor) {
+    const m = /^(\d+):(\d+)$/.exec(cursor);
+    if (!m) return null;
+    return { seq: Number(m[1]), version: Number(m[2]) };
+  }
+  async append(entry) {
+    const seq = this.#meta.currentSeq + 1;
+    const full = { ...entry, seq, ts: Date.now() };
+    const segIdx = this.#meta.currentSegment;
+    const current = await readJson(this.backend, this.tenantId, segmentPath(segIdx)) ?? [];
+    current.push(full);
+    await writeJson(this.backend, this.tenantId, segmentPath(segIdx), current);
+    this.#meta.currentSeq = seq;
+    if (current.length >= this.#segmentSize) {
+      this.#meta.currentSegment = segIdx + 1;
+    }
+    await writeJson(this.backend, this.tenantId, META_PATH, this.#meta);
+    return full;
+  }
+  async oldestRetainedSeq() {
+    const first = await readJson(this.backend, this.tenantId, segmentPath(this.#meta.oldestSegment));
+    if (!first || first.length === 0) return 0;
+    return first[0].seq;
+  }
+  async changesSince(scope, cursor) {
+    let startSeq = 0;
+    if (cursor) {
+      const decoded = _Journal.decodeCursor(cursor);
+      if (!decoded) return { entries: [], nextCursor: cursor, hasMore: false };
+      const oldest = await this.oldestRetainedSeq();
+      if (decoded.version < this.#meta.version && decoded.seq < oldest) {
+        return { entries: [], nextCursor: cursor, hasMore: false, truncated: true };
+      }
+      startSeq = decoded.seq;
+    }
+    const out = [];
+    let lastSeq = startSeq;
+    let hasMore = false;
+    for (let seg = this.#meta.oldestSegment; seg <= this.#meta.currentSegment; seg++) {
+      const entries = await readJson(this.backend, this.tenantId, segmentPath(seg)) ?? [];
+      for (const e of entries) {
+        if (e.seq <= startSeq) continue;
+        if (!matchesScope(e, scope)) {
+          lastSeq = e.seq;
+          continue;
+        }
+        if (out.length >= this.#pageSize) {
+          hasMore = true;
+          break;
+        }
+        out.push(e);
+        lastSeq = e.seq;
+      }
+      if (hasMore) break;
+    }
+    return {
+      entries: out,
+      nextCursor: _Journal.encodeCursor(lastSeq, this.#meta.version),
+      hasMore
+    };
+  }
+  async getCursor(connectorId) {
+    return readJson(this.backend, this.tenantId, cursorPath(connectorId));
+  }
+  async ackCursor(connectorId, cursor) {
+    await writeJson(this.backend, this.tenantId, cursorPath(connectorId), cursor);
+  }
+  async dropCursor(connectorId) {
+    await deletePath(this.backend, this.tenantId, cursorPath(connectorId));
+  }
+  async listCursors() {
+    const paths = await listJsonPaths(this.backend, this.tenantId, CURSOR_PREFIX);
+    const out = [];
+    for (const p of paths) {
+      const cursor = await readJson(this.backend, this.tenantId, p);
+      if (cursor === null) continue;
+      const id = decodeURIComponent(p.slice(CURSOR_PREFIX.length, -".json".length));
+      out.push({ connectorId: id, cursor });
+    }
+    return out;
+  }
+  async minSeqAckedByAll(connectorIds) {
+    if (connectorIds.length === 0) return 0;
+    let min = Infinity;
+    for (const id of connectorIds) {
+      const c = await this.getCursor(id);
+      const decoded = c ? _Journal.decodeCursor(c) : null;
+      const seq = decoded ? decoded.seq : 0;
+      if (seq < min) min = seq;
+    }
+    return min === Infinity ? 0 : min;
+  }
+  /** Test-only: simulate truncating all segments whose entries are <= uptoSeq. */
+  async __truncateForTest(uptoSeq) {
+    for (let seg = this.#meta.oldestSegment; seg <= this.#meta.currentSegment; seg++) {
+      const entries = await readJson(this.backend, this.tenantId, segmentPath(seg)) ?? [];
+      const last = entries[entries.length - 1];
+      if (last && last.seq <= uptoSeq) {
+        await deletePath(this.backend, this.tenantId, segmentPath(seg));
+        this.#meta.oldestSegment = seg + 1;
+      } else break;
+    }
+    this.#meta.version += 1;
+    await writeJson(this.backend, this.tenantId, META_PATH, this.#meta);
+  }
+};
+
+// src/documents/sync/tombstones.ts
+var PREFIX = "tombstones/";
+function key(shardId, path) {
+  return `${PREFIX}${shardId}__${encodeURIComponent(path)}.json`;
+}
+var TombstoneStore = class {
+  constructor(backend, tenantId) {
+    this.backend = backend;
+    this.tenantId = tenantId;
+  }
+  async record(shardId, path, lastHash, deletedAt) {
+    await writeJson(this.backend, this.tenantId, key(shardId, path), {
+      deletedAt,
+      lastHash
+    });
+  }
+  async get(shardId, path) {
+    return readJson(this.backend, this.tenantId, key(shardId, path));
+  }
+  async clear(shardId, path) {
+    await deletePath(this.backend, this.tenantId, key(shardId, path));
+  }
+  async listByShard(shardId) {
+    const prefix = `${PREFIX}${shardId}__`;
+    const paths = await listJsonPaths(this.backend, this.tenantId, prefix);
+    const out = [];
+    for (const p of paths) {
+      const rec = await readJson(this.backend, this.tenantId, p);
+      if (!rec) continue;
+      const originalPath = decodeURIComponent(p.slice(prefix.length, -".json".length));
+      out.push({ shardId, path: originalPath, ...rec });
+    }
+    return out;
+  }
+  async listAll() {
+    const paths = await listJsonPaths(this.backend, this.tenantId, PREFIX);
+    const out = [];
+    for (const p of paths) {
+      const rec = await readJson(this.backend, this.tenantId, p);
+      if (!rec) continue;
+      const rest = p.slice(PREFIX.length, -".json".length);
+      const sep = rest.indexOf("__");
+      if (sep < 0) continue;
+      const shardId = rest.slice(0, sep);
+      const path = decodeURIComponent(rest.slice(sep + 2));
+      out.push({ shardId, path, ...rec });
+    }
+    return out;
+  }
+};
+
+// src/documents/sync/conflicts.ts
+var BASES_PREFIX = "bases/";
+function baseKey(connectorId, shardId, path) {
+  return `${BASES_PREFIX}${encodeURIComponent(connectorId)}__${shardId}__${encodeURIComponent(path)}.json`;
+}
+function isArtifactName(name) {
+  return /\.sync-conflict-[^.]+-\d+$/.test(name);
+}
+var ConflictManager = class {
+  constructor(backend, tenantId) {
+    this.backend = backend;
+    this.tenantId = tenantId;
+  }
+  async resolve(policy, input) {
+    const p = typeof policy === "function" ? await policy({
+      path: input.path,
+      shardId: input.shardId,
+      localHash: input.localHash,
+      remoteHash: input.remoteHash,
+      baseHash: input.baseHash
+    }) : policy;
+    switch (p) {
+      case "remote-wins":
+        return { action: "apply-remote" };
+      case "local-wins":
+        return { action: "skip" };
+      case "keep-both": {
+        const asPath = `${input.path}.incoming-${input.connectorId}-${Date.now()}`;
+        return { action: "apply-remote", asPath };
+      }
+      case "default":
+      default: {
+        const ts = Date.now();
+        const artifact = `${input.path}.sync-conflict-${input.connectorId}-${ts}`;
+        if (input.remoteContent !== void 0) {
+          await this.backend.write(this.tenantId, input.shardId, artifact, input.remoteContent);
+        }
+        const resolution = {
+          path: input.path,
+          shardId: input.shardId,
+          localHash: input.localHash,
+          remoteHash: input.remoteHash,
+          conflictArtifactPath: artifact,
+          base: input.baseHash ? { hash: input.baseHash } : void 0
+        };
+        return { action: "conflict", resolution };
+      }
+    }
+  }
+  async getBaseHash(connectorId, shardId, path) {
+    return readJson(this.backend, this.tenantId, baseKey(connectorId, shardId, path));
+  }
+  async setBaseHash(connectorId, shardId, path, hash) {
+    await writeJson(this.backend, this.tenantId, baseKey(connectorId, shardId, path), hash);
+  }
+  async listConflicts(shardId) {
+    const metas = await this.backend.list(this.tenantId, shardId);
+    const out = [];
+    for (const m of metas) {
+      const name = m.path;
+      if (!isArtifactName(name)) continue;
+      const m2 = /^(.*)\.sync-conflict-([^-]+)-(\d+)$/.exec(name);
+      if (!m2) continue;
+      const originalPath = m2[1];
+      out.push({
+        path: originalPath,
+        shardId,
+        localHash: "",
+        remoteHash: "",
+        conflictArtifactPath: name
+      });
+    }
+    return out;
+  }
+};
+
+// src/documents/sync/engine.ts
+function scopeCovers(scope, shardId, path) {
+  switch (scope.kind) {
+    case "tenant":
+      return true;
+    case "shard":
+      return scope.shardId === shardId;
+    case "path":
+      return scope.shardId === shardId && path.startsWith(scope.prefix);
+  }
+}
+var SyncEngine = class {
+  constructor(backend, tenantId, opts = {}) {
+    this.backend = backend;
+    this.tenantId = tenantId;
+    this.#journal = new Journal(backend, tenantId, { segmentSize: opts.segmentSize });
+    this.#tombstones = new TombstoneStore(backend, tenantId);
+    this.#conflicts = new ConflictManager(backend, tenantId);
+  }
+  #journal;
+  #tombstones;
+  #conflicts;
+  async init() {
+    await this.#journal.init();
+  }
+  get journal() {
+    return this.#journal;
+  }
+  async getManifest(_connectorId, scope) {
+    const shardIds = await this.#shardsInScope(scope);
+    const entries = [];
+    for (const shardId of shardIds) {
+      const metas = await this.backend.list(this.tenantId, shardId);
+      for (const m of metas) {
+        if (!scopeCovers(scope, shardId, m.path)) continue;
+        if (m.path.startsWith(".") || /\.sync-conflict-/.test(m.path)) continue;
+        const raw = await this.backend.read(this.tenantId, shardId, m.path);
+        if (raw === null) continue;
+        const hash = await hashContent(raw);
+        entries.push({ path: m.path, shardId, hash, size: m.size, lastModified: m.lastModified });
+      }
+      const tombs = await this.#tombstones.listByShard(shardId);
+      for (const t of tombs) {
+        if (!scopeCovers(scope, shardId, t.path)) continue;
+        entries.push({
+          path: t.path,
+          shardId,
+          hash: t.lastHash,
+          size: 0,
+          lastModified: t.deletedAt,
+          tombstone: { deletedAt: t.deletedAt }
+        });
+      }
+    }
+    return entries;
+  }
+  async changesSince(scope, cursor) {
+    return this.#journal.changesSince(scope, cursor);
+  }
+  async ack(connectorId, _scope, cursor) {
+    await this.#journal.ackCursor(connectorId, cursor);
+  }
+  async apply(connectorId, scope, entry, opts = {}) {
+    if (!scopeCovers(scope, entry.shardId, entry.path)) {
+      throw new Error(`ApplyEntry {${entry.shardId}:${entry.path}} falls outside scope`);
+    }
+    if (entry.op === "upsert") return this.#applyUpsert(connectorId, entry, opts);
+    return this.#applyDelete(connectorId, entry);
+  }
+  async applyBatch(connectorId, scope, manifest, opts = {}) {
+    const applied = [];
+    const skipped = [];
+    const conflicts = [];
+    for (const e of manifest) {
+      const out = await this.apply(connectorId, scope, e, opts);
+      if (out.status === "applied") applied.push({ path: e.path, shardId: e.shardId, newHash: out.newHash });
+      else if (out.status === "skipped-identical") skipped.push({ path: e.path, shardId: e.shardId, reason: "identical" });
+      else conflicts.push(out.resolution);
+    }
+    return { applied, skipped, conflicts };
+  }
+  async forget(scope, path) {
+    const shardIds = await this.#shardsInScope(scope);
+    for (const shardId of shardIds) {
+      if (!scopeCovers(scope, shardId, path)) continue;
+      await this.#tombstones.clear(shardId, path);
+    }
+  }
+  // ----- internals -----
+  async #applyUpsert(connectorId, entry, opts) {
+    const existing = await this.backend.read(this.tenantId, entry.shardId, entry.path);
+    const existed = existing !== null;
+    const localHash = existed ? await hashContent(existing) : null;
+    if (localHash !== null && localHash === entry.remoteHash) {
+      return { status: "skipped-identical" };
+    }
+    const conflictTriggered = existed && (opts.expectedLocalHash !== void 0 && opts.expectedLocalHash !== localHash || opts.expectedLocalHash === void 0 && await this.#hasDivergedBase(connectorId, entry, localHash));
+    if (conflictTriggered) {
+      const baseHash = await this.#conflicts.getBaseHash(connectorId, entry.shardId, entry.path) ?? void 0;
+      const action = await this.#conflicts.resolve(opts.onConflict ?? "default", {
+        connectorId,
+        shardId: entry.shardId,
+        path: entry.path,
+        localHash,
+        remoteHash: entry.remoteHash,
+        remoteContent: entry.content,
+        baseHash
+      });
+      if (action.action === "skip") return { status: "skipped-identical" };
+      if (action.action === "conflict") return { status: "conflict", resolution: action.resolution };
+      const writePath = action.asPath ?? entry.path;
+      return this.#writeAndRecord(connectorId, entry, writePath, existed);
+    }
+    return this.#writeAndRecord(connectorId, entry, entry.path, existed);
+  }
+  async #writeAndRecord(connectorId, entry, writePath, existed) {
+    if (entry.content === void 0) {
+      throw new Error(`Upsert without content for ${entry.shardId}:${entry.path}`);
+    }
+    await this.backend.write(this.tenantId, entry.shardId, writePath, entry.content);
+    await this.#tombstones.clear(entry.shardId, writePath);
+    const newHash = await hashContent(entry.content);
+    await this.#conflicts.setBaseHash(connectorId, entry.shardId, writePath, newHash);
+    await this.#journal.append({ shardId: entry.shardId, path: writePath, op: "upsert", hash: newHash });
+    this.#emit({ type: existed && writePath === entry.path ? "update" : "create", path: writePath, tenantId: this.tenantId, shardId: entry.shardId });
+    return { status: "applied", newHash };
+  }
+  async #applyDelete(connectorId, entry) {
+    const existing = await this.backend.read(this.tenantId, entry.shardId, entry.path);
+    if (existing === null) {
+      await this.#tombstones.record(entry.shardId, entry.path, entry.remoteHash, Date.now());
+      await this.#journal.append({ shardId: entry.shardId, path: entry.path, op: "delete", hash: null });
+      return { status: "applied", newHash: "" };
+    }
+    const lastHash = await hashContent(existing);
+    await this.backend.delete(this.tenantId, entry.shardId, entry.path);
+    await this.#tombstones.record(entry.shardId, entry.path, lastHash, Date.now());
+    await this.#conflicts.setBaseHash(connectorId, entry.shardId, entry.path, "");
+    await this.#journal.append({ shardId: entry.shardId, path: entry.path, op: "delete", hash: null });
+    this.#emit({ type: "delete", path: entry.path, tenantId: this.tenantId, shardId: entry.shardId });
+    return { status: "applied", newHash: "" };
+  }
+  async #hasDivergedBase(connectorId, entry, localHash) {
+    const base = await this.#conflicts.getBaseHash(connectorId, entry.shardId, entry.path);
+    if (!base) return false;
+    return base !== localHash;
+  }
+  async #shardsInScope(scope) {
+    if (scope.kind === "tenant") {
+      return [];
+    }
+    return [scope.shardId];
+  }
+  #emit(change) {
+    documentChanges.emit(change);
+  }
+};
+
+// src/documents/sync/registry.ts
+var GRANTS_PREFIX = "grants/";
+function grantPath(connectorId) {
+  return `${GRANTS_PREFIX}${encodeURIComponent(connectorId)}.json`;
+}
+function scopesEqual(a, b) {
+  if (a.kind !== b.kind) return false;
+  if (a.kind === "tenant") return true;
+  if (a.kind === "shard" && b.kind === "shard") return a.shardId === b.shardId;
+  if (a.kind === "path" && b.kind === "path")
+    return a.shardId === b.shardId && a.prefix === b.prefix;
+  return false;
+}
+function createSyncRegistry(backend, tenantId) {
+  const conflicts = new ConflictManager(backend, tenantId);
+  async function readGrants(connectorId) {
+    return await readJson(backend, tenantId, grantPath(connectorId)) ?? [];
+  }
+  return {
+    async list(connectorId) {
+      if (connectorId) return readGrants(connectorId);
+      const paths = await listJsonPaths(backend, tenantId, GRANTS_PREFIX);
+      const out = [];
+      for (const p of paths) {
+        const arr = await readJson(backend, tenantId, p);
+        if (arr) out.push(...arr);
+      }
+      return out;
+    },
+    async revoke(connectorId, scope) {
+      const grants = await readGrants(connectorId);
+      const next = grants.filter((g) => !scopesEqual(g.scope, scope));
+      if (next.length === 0) await deletePath(backend, tenantId, grantPath(connectorId));
+      else await writeJson(backend, tenantId, grantPath(connectorId), next);
+    },
+    async listConflicts(shardId) {
+      if (shardId !== void 0) return conflicts.listConflicts(shardId);
+      const shards = await backend.listAllShards(tenantId);
+      const out = [];
+      for (const s of shards) {
+        out.push(...await conflicts.listConflicts(s));
+      }
+      return out;
+    },
+    async listAllConnectorIds() {
+      const paths = await listJsonPaths(backend, tenantId, GRANTS_PREFIX);
+      return paths.map(
+        (p) => decodeURIComponent(p.slice(GRANTS_PREFIX.length, -".json".length))
+      );
+    }
+  };
+}
+
+// src/documents/sync/singleton.ts
+var bundles = /* @__PURE__ */ new Map();
+async function getSyncBundle(backend, tenantId) {
+  const existing = bundles.get(tenantId);
+  if (existing) return existing;
+  const engine = new SyncEngine(backend, tenantId);
+  await engine.init();
+  const registry = createSyncRegistry(backend, tenantId);
+  setJournalAppender(async (e) => {
+    await engine.journal.append(e);
+  });
+  const bundle = { engine, registry };
+  bundles.set(tenantId, bundle);
+  return bundle;
+}
+
+// src/documents/sync/handle.ts
+function scopeContains(parent, child) {
+  if (parent.kind === "tenant") return true;
+  if (parent.kind === "shard") {
+    if (child.kind === "shard") return parent.shardId === child.shardId;
+    if (child.kind === "path") return parent.shardId === child.shardId;
+    return false;
+  }
+  if (child.kind === "path")
+    return child.shardId === parent.shardId && child.prefix.startsWith(parent.prefix);
+  return false;
+}
+function createSyncHandle(deps) {
+  const { connectorId, engine, registry } = deps;
+  async function currentGrants() {
+    const records = await registry.list(connectorId);
+    return records.map((r) => r.scope);
+  }
+  async function requireScope(requested) {
+    const grants = await currentGrants();
+    const matching = grants.filter((g) => scopeContains(g, requested));
+    if (matching.length === 0) throw new ScopeNotGrantedError(requested);
+    if (requested.kind === "tenant") {
+      const concrete = grants.filter((g) => g.kind === "shard" || g.kind === "path");
+      return concrete.length > 0 ? concrete : [requested];
+    }
+    return [requested];
+  }
+  return {
+    connectorId,
+    async grantedScopes() {
+      return currentGrants();
+    },
+    async getManifest(scope) {
+      const concreteScopes = await requireScope(scope);
+      const out = [];
+      if (scope.kind === "tenant" && concreteScopes[0]?.kind !== "tenant") {
+        for (const s of concreteScopes) out.push(...await engine.getManifest(connectorId, s));
+      } else {
+        out.push(...await engine.getManifest(connectorId, scope));
+      }
+      return out;
+    },
+    async changesSince(scope, cursor) {
+      await requireScope(scope);
+      return engine.changesSince(scope, cursor);
+    },
+    async ack(scope, cursor) {
+      await requireScope(scope);
+      await engine.ack(connectorId, scope, cursor);
+    },
+    async apply(scope, entry, opts) {
+      await requireScope(scope);
+      return engine.apply(connectorId, scope, entry, opts);
+    },
+    async applyBatch(scope, manifest, opts) {
+      await requireScope(scope);
+      return engine.applyBatch(connectorId, scope, manifest, opts);
+    },
+    async forget(scope, path) {
+      await requireScope(scope);
+      await engine.forget(scope, path);
+    }
+  };
+}
+export {
+  createSyncHandle,
+  createSyncRegistry,
+  getSyncBundle
+};
+//# sourceMappingURL=server-sync.js.map