@aigne/aos 0.2.0-beta

package/dist/session/replication-resolver.cjs

@@ -0,0 +1,323 @@
+const require_role_level = require('./role-level.cjs');
+let _aigne_afs = require("@aigne/afs");
+
+//#region src/session/replication-resolver.ts
+/**
+* Compute the overlay mount prefix for a set of replicated collections.
+* Returns the LCP (longest common prefix) of the "pre-collection" segments
+* (everything before the collection-name segment, which sits just before `*`)
+* across all canonical patterns. This is the path at which a single
+* ReplicationResolver overlay is mounted in SessionUserAFS.
+*
+* Examples:
+*   { notes: { canonical: "instance/notes/*" } }
+*     → "instance"   (pre-collection = ["instance"])
+*   { posts: "instance/app/posts/*", comments: "instance/app/comments/*" }
+*     → "instance/app"  (LCP of ["instance","app"] and ["instance","app"])
+*   { notes: "instance/notes/*", posts: "instance/app/posts/*" }
+*     → "instance"  (LCP of ["instance"] and ["instance","app"])
+*/
+function computeReplicationMountPrefix(collections) {
+	const entries = Object.values(collections);
+	if (entries.length === 0) throw new Error("No replicated collections declared");
+	const parents = entries.map(({ canonical }) => {
+		const segs = canonical.split("/").filter((s) => s.length > 0);
+		const starIdx = segs.indexOf("*");
+		if (starIdx < 1) throw new Error(`Invalid canonical pattern (no * or too short): ${canonical}`);
+		return segs.slice(0, starIdx - 1);
+	});
+	const first = parents[0];
+	let lcpLen = first.length;
+	for (let k = 1; k < parents.length; k++) {
+		const p = parents[k];
+		let len = 0;
+		while (len < lcpLen && len < p.length && first[len] === p[len]) len++;
+		lcpLen = len;
+	}
+	return first.slice(0, lcpLen).join("/") || "instance";
+}
+/**
+* Derive the sidecar path for a given item path, using the pattern to determine
+* the injection point. Injects `.provenance/` before the collection segment
+* (segment at firstStarIndex - 1 of the pattern).
+*
+* Examples:
+*   pattern="instance/app/posts/*",         item="/instance/app/posts/p1"
+*     → "/instance/app/.provenance/posts/p1"
+*   pattern="instance/app/posts/{star}/comments/{star}", item="/instance/app/posts/p1/comments/c1"
+*     → "/instance/app/.provenance/posts/p1/comments/c1"
+*   Works for copy paths too: item="/user/app/posts/p1"
+*     → "/user/app/.provenance/posts/p1"
+*/
+function deriveSidecarPath(pattern, fullItemPath) {
+	const patternSegs = pattern.split("/").filter((s) => s.length > 0);
+	const firstStarIdx = patternSegs.indexOf("*");
+	if (firstStarIdx < 1) throw new Error(`Invalid pattern (no * or too short): ${pattern}`);
+	const preCollectionLen = firstStarIdx - 1;
+	const collectionSeg = patternSegs[firstStarIdx - 1];
+	const itemSegs = fullItemPath.replace(/^\//, "").split("/").filter((s) => s.length > 0);
+	const itemTail = itemSegs.slice(firstStarIdx);
+	return `/${[
+		...itemSegs.slice(0, preCollectionLen),
+		".provenance",
+		collectionSeg,
+		...itemTail
+	].join("/")}`;
+}
+/**
+* Find the best-matching collection for a given (normalized, no-leading-slash) item path.
+* Uses longest-match: the pattern that consumes the most path segments with static segments wins.
+* Returns null if no collection matches.
+*/
+function matchCollections(collections, normalizedPath) {
+	const itemSegs = normalizedPath.replace(/^\//, "").split("/").filter((s) => s.length > 0);
+	let best = null;
+	for (const [name, collection] of Object.entries(collections)) {
+		const score = tryMatchPattern(collection.canonical.split("/").filter((s) => s.length > 0), itemSegs);
+		if (score !== null && (best === null || score > best.score)) best = {
+			name,
+			collection,
+			score
+		};
+	}
+	return best ? {
+		name: best.name,
+		collection: best.collection
+	} : null;
+}
+/**
+* Try to match a pattern (segment array) against an item path (segment array).
+* Returns a score (higher = more specific) on match, or null on mismatch.
+* Rules:
+*   - Static segments must match exactly.
+*   - Non-terminal `*` matches exactly one segment.
+*   - Terminal `*` matches one or more remaining segments (item + subtree).
+*/
+function tryMatchPattern(patternSegs, itemSegs) {
+	let pIdx = 0;
+	let iIdx = 0;
+	let score = 0;
+	while (pIdx < patternSegs.length) {
+		const pSeg = patternSegs[pIdx];
+		if (pSeg === "*") {
+			if (pIdx === patternSegs.length - 1) {
+				if (iIdx >= itemSegs.length) return null;
+				score += 10 + (itemSegs.length - iIdx - 1);
+				return score;
+			}
+			if (iIdx >= itemSegs.length) return null;
+			iIdx++;
+			score += 100;
+		} else {
+			if (iIdx >= itemSegs.length || itemSegs[iIdx] !== pSeg) return null;
+			iIdx++;
+			score += 1e3;
+		}
+		pIdx++;
+	}
+	return null;
+}
+/**
+* Match a path against canonical collection patterns OR their derived sidecar
+* mirror patterns (`.provenance/` prefixed). Used for the read gate (P2).
+*
+* Sidecar matching: strips the `.provenance` segment from the path and checks
+* the resulting path against the canonical patterns.
+*/
+function matchCollectionsForRead(collections, normalizedPath) {
+	const direct = matchCollections(collections, normalizedPath);
+	if (direct) return direct;
+	const segs = normalizedPath.split("/").filter((s) => s.length > 0);
+	const provenanceIdx = segs.indexOf(".provenance");
+	if (provenanceIdx < 0) return null;
+	return matchCollections(collections, [...segs.slice(0, provenanceIdx), ...segs.slice(provenanceIdx + 1)].join("/"));
+}
+/**
+* Check that a path contains no `..` or empty segments (path safety).
+* Returns the normalized path (no leading `/`) on success.
+* Throws AFSForbiddenError on suspicious input.
+*/
+function assertPathSafe(path) {
+	const norm = path.replace(/^\//, "");
+	const segs = norm.split("/");
+	for (const seg of segs) if (seg === "" || seg === "..") throw new _aigne_afs.AFSForbiddenError(path, `path contains unsafe segment: "${seg === "" ? "(empty)" : seg}"`);
+	return norm;
+}
+/**
+* Convert a canonical `/instance/...` path to the author-copy `/user/...` path.
+* Replaces the first segment (`instance`) with `user`.
+* Returns the VIEW path (prefixed with /user) — callers must strip /user before
+* passing to userBackend, since userBackend operates at provider-relative paths.
+*/
+function canonicalToViewCopyPath(canonicalPath) {
+	const norm = canonicalPath.replace(/^\//, "");
+	const slashIdx = norm.indexOf("/");
+	if (slashIdx < 0) return "/user";
+	return `/user${norm.slice(slashIdx)}`;
+}
+/**
+* Strip the `/user` view prefix from a copy view path to get the
+* provider-relative path for userBackend calls.
+*/
+function copyViewToProviderPath(viewPath) {
+	if (viewPath === "/user") return "/";
+	if (viewPath.startsWith("/user/")) return viewPath.slice(5);
+	return viewPath;
+}
+/**
+* ReplicationResolver intercepts writes and deletes to replicated-collection
+* paths, enforces role gates, and fans out to both canonical (instanceBackend)
+* and author copy (userBackend) with provenance sidecars.
+*
+* Mounted as a SessionUserAFS overlay at `/${mountPrefix}` (typically
+* /instance). Receives SUB-PATHS (after prefix stripping by the overlay
+* system) and reconstructs full paths internally using mountPrefix.
+*
+* P1: write + delete implemented.
+* P2: read gate (readRole) + createSessionView wiring.
+*/
+var ReplicationResolver = class {
+	name;
+	mountPrefix;
+	constructor(opts) {
+		this.opts = opts;
+		this.name = `replication-resolver:${opts.sessionId}`;
+		this.mountPrefix = opts.mountPrefix ?? computeReplicationMountPrefix(opts.collections);
+	}
+	/**
+	* Reconstruct the full canonical path from the sub-path the overlay delivers.
+	* The overlay at `/${mountPrefix}` strips the prefix, leaving e.g. `/notes/n1`
+	* from `/instance/notes/n1`. We prepend mountPrefix to restore the full path.
+	*/
+	toFullPath(sub) {
+		const s = sub.startsWith("/") ? sub : `/${sub}`;
+		return `/${this.mountPrefix}${s}`;
+	}
+	async getEffectiveMinRole(collectionName, collection) {
+		if (this.opts.settingsResolver) try {
+			const v = (await this.opts.settingsResolver.read(`/${collectionName}/minRole.json/value`)).data?.content;
+			if (typeof v === "string" && v.length > 0) return v;
+		} catch {}
+		return collection.minRole ?? "member";
+	}
+	async getEffectiveReadRole(collectionName, collection) {
+		if (this.opts.settingsResolver) try {
+			const v = (await this.opts.settingsResolver.read(`/${collectionName}/readRole.json/value`)).data?.content;
+			if (typeof v === "string" && v.length > 0) return v;
+		} catch {}
+		return collection.readRole ?? "guest";
+	}
+	async read(path, options) {
+		const fullPath = this.toFullPath(path);
+		const normPath = assertPathSafe(fullPath);
+		const match = matchCollectionsForRead(this.opts.collections, normPath);
+		if (match) {
+			const effectiveReadRole = await this.getEffectiveReadRole(match.name, match.collection);
+			if (require_role_level.roleLevel(this.opts.callerRole) < require_role_level.roleLevel(effectiveReadRole)) throw new _aigne_afs.AFSForbiddenError(fullPath, `role '${this.opts.callerRole ?? "guest"}' is below readRole '${effectiveReadRole}'`);
+		}
+		if (!this.opts.instanceBackend.read) throw new _aigne_afs.AFSForbiddenError(fullPath, "instanceBackend does not support read");
+		return this.opts.instanceBackend.read(fullPath, options);
+	}
+	async list(path, options) {
+		const fullPath = this.toFullPath(path);
+		const normPath = assertPathSafe(fullPath);
+		const match = matchCollectionsForRead(this.opts.collections, normPath);
+		if (match) {
+			const effectiveReadRole = await this.getEffectiveReadRole(match.name, match.collection);
+			if (require_role_level.roleLevel(this.opts.callerRole) < require_role_level.roleLevel(effectiveReadRole)) throw new _aigne_afs.AFSForbiddenError(fullPath, `role '${this.opts.callerRole ?? "guest"}' is below readRole '${effectiveReadRole}'`);
+		}
+		if (!this.opts.instanceBackend.list) throw new _aigne_afs.AFSForbiddenError(fullPath, "instanceBackend does not support list");
+		return this.opts.instanceBackend.list(fullPath, options);
+	}
+	async stat(path, options) {
+		const fullPath = this.toFullPath(path);
+		const normPath = assertPathSafe(fullPath);
+		const match = matchCollectionsForRead(this.opts.collections, normPath);
+		if (match) {
+			const effectiveReadRole = await this.getEffectiveReadRole(match.name, match.collection);
+			if (require_role_level.roleLevel(this.opts.callerRole) < require_role_level.roleLevel(effectiveReadRole)) throw new _aigne_afs.AFSForbiddenError(fullPath, `role '${this.opts.callerRole ?? "guest"}' is below readRole '${effectiveReadRole}'`);
+		}
+		if (!this.opts.instanceBackend.stat) throw new _aigne_afs.AFSForbiddenError(fullPath, "instanceBackend does not support stat");
+		return this.opts.instanceBackend.stat(fullPath, options);
+	}
+	async search(path, query, options) {
+		const fullPath = this.toFullPath(path);
+		const normPath = assertPathSafe(fullPath);
+		const match = matchCollectionsForRead(this.opts.collections, normPath);
+		if (match) {
+			const effectiveReadRole = await this.getEffectiveReadRole(match.name, match.collection);
+			if (require_role_level.roleLevel(this.opts.callerRole) < require_role_level.roleLevel(effectiveReadRole)) throw new _aigne_afs.AFSForbiddenError(fullPath, `role '${this.opts.callerRole ?? "guest"}' is below readRole '${effectiveReadRole}'`);
+		}
+		if (!this.opts.instanceBackend.search) throw new _aigne_afs.AFSForbiddenError(fullPath, "instanceBackend does not support search");
+		return this.opts.instanceBackend.search(fullPath, query, options);
+	}
+	async write(path, content, options) {
+		const fullPath = this.toFullPath(path);
+		const normPath = assertPathSafe(fullPath);
+		const match = matchCollections(this.opts.collections, normPath);
+		if (!match) {
+			if ((options?.context)?.callerOrigin === "network") throw new _aigne_afs.AFSForbiddenError(fullPath, "network clients cannot write non-replicated instance paths");
+			if (!this.opts.instanceBackend.write) throw new _aigne_afs.AFSForbiddenError(fullPath, "instanceBackend does not support write");
+			return this.opts.instanceBackend.write(fullPath, content, options);
+		}
+		const { name: collectionName, collection } = match;
+		const effectiveMinRole = await this.getEffectiveMinRole(collectionName, collection);
+		if (require_role_level.roleLevel(this.opts.callerRole) < require_role_level.roleLevel(effectiveMinRole)) throw new _aigne_afs.AFSForbiddenError(fullPath, `role '${this.opts.callerRole ?? "guest"}' is below minRole '${effectiveMinRole}'`);
+		const authorDid = this.opts.callerDid ?? null;
+		const publishedAt = (/* @__PURE__ */ new Date()).toISOString();
+		if ((collection.copy ?? "mirror") !== "none" && this.opts.userBackend !== null && this.opts.userBackend.write) {
+			const copyViewPath = canonicalToViewCopyPath(fullPath);
+			const copyProviderPath = copyViewToProviderPath(copyViewPath);
+			await this.opts.userBackend.write(copyProviderPath, content);
+			const copySidecarProviderPath = copyViewToProviderPath(deriveSidecarPath(collection.canonical, copyViewPath));
+			const copySidecar = {
+				canonical_ref: {
+					instance_did: this.opts.instanceDid ?? "",
+					path: normPath.replace(/^instance\//, "")
+				},
+				published_at: publishedAt
+			};
+			await this.opts.userBackend.write(copySidecarProviderPath, { content: JSON.stringify(copySidecar) });
+		}
+		if (!this.opts.instanceBackend.write) throw new _aigne_afs.AFSForbiddenError(fullPath, "instanceBackend does not support write");
+		const result = await this.opts.instanceBackend.write(fullPath, content, options);
+		const canonicalSidecarPath = deriveSidecarPath(collection.canonical, fullPath);
+		const canonicalSidecar = {
+			author_did: authorDid,
+			published_at: publishedAt
+		};
+		await this.opts.instanceBackend.write(canonicalSidecarPath, { content: JSON.stringify(canonicalSidecar) });
+		return result;
+	}
+	async delete(path, options) {
+		const fullPath = this.toFullPath(path);
+		const normPath = assertPathSafe(fullPath);
+		const match = matchCollections(this.opts.collections, normPath);
+		if (!match) {
+			if (!this.opts.instanceBackend.delete) return {};
+			return this.opts.instanceBackend.delete(fullPath, options);
+		}
+		const { collection } = match;
+		const canonicalSidecarPath = deriveSidecarPath(collection.canonical, fullPath);
+		let provenanceAuthorDid = null;
+		if (this.opts.instanceBackend.read) try {
+			const raw = (await this.opts.instanceBackend.read(canonicalSidecarPath)).data?.content;
+			if (typeof raw === "string") provenanceAuthorDid = JSON.parse(raw).author_did ?? null;
+		} catch {}
+		const callerDid = this.opts.callerDid;
+		const anyItemRoleStr = collection.delete?.anyItem ?? "admin";
+		const isOwnItem = callerDid != null && provenanceAuthorDid != null && callerDid === provenanceAuthorDid;
+		const hasAnyItemRole = require_role_level.roleLevel(this.opts.callerRole) >= require_role_level.roleLevel(anyItemRoleStr);
+		if (!isOwnItem && !hasAnyItemRole) throw new _aigne_afs.AFSForbiddenError(fullPath, `insufficient permission to delete: role='${this.opts.callerRole ?? "guest"}'`);
+		if (!this.opts.instanceBackend.delete) return {};
+		const result = await this.opts.instanceBackend.delete(fullPath, options);
+		try {
+			await this.opts.instanceBackend.delete(canonicalSidecarPath);
+		} catch {}
+		return result;
+	}
+};
+
+//#endregion
+exports.ReplicationResolver = ReplicationResolver;
+exports.computeReplicationMountPrefix = computeReplicationMountPrefix;

package/dist/session/replication-resolver.d.cts

@@ -0,0 +1,71 @@
+import { SettingsResolver } from "./settings-resolver.cjs";
+import { AFSDeleteOptions, AFSDeleteResult, AFSListOptions, AFSListResult, AFSModule, AFSReadOptions, AFSReadResult, AFSRoot, AFSSearchOptions, AFSSearchResult, AFSStatOptions, AFSStatResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult, ReplicatedCollection } from "@aigne/afs";
+
+//#region src/session/replication-resolver.d.ts
+/**
+ * Construction options for ReplicationResolver.
+ * Injected at createSessionView (P2), not pre-built upstream.
+ */
+interface ReplicationResolverOptions {
+  /**
+   * Parsed replicated-collection declarations from the blocklet manifest.
+   * Key = logical collection name; value = validated ReplicatedCollection.
+   */
+  collections: Record<string, ReplicatedCollection>;
+  /** The canonical backend (instance space, role:system). */
+  instanceBackend: AFSRoot;
+  /** The author-copy backend (user space, role:user), or null for anonymous callers. */
+  userBackend: AFSModule | null;
+  /** SettingsResolver reference for reading effective minRole/readRole overrides. */
+  settingsResolver: SettingsResolver | null;
+  /** Verified caller DID (from AFSContext.caller.did, never client-supplied). */
+  callerDid: string | undefined;
+  /** Caller role (daemon-folded single string from getCallerForSession). */
+  callerRole: string | undefined;
+  /** Owning session id — for event origin tagging in P2+. */
+  sessionId: string;
+  /** Instance DID used in copy-side sidecar canonical_ref. */
+  instanceDid?: string;
+  /**
+   * The path prefix this resolver is mounted at, WITHOUT leading slash.
+   * e.g. "instance" when mounted at /instance. Used to reconstruct the full
+   * canonical path from the sub-path the overlay system delivers.
+   * When omitted, computed automatically via computeReplicationMountPrefix().
+   */
+  mountPrefix?: string;
+}
+/**
+ * ReplicationResolver intercepts writes and deletes to replicated-collection
+ * paths, enforces role gates, and fans out to both canonical (instanceBackend)
+ * and author copy (userBackend) with provenance sidecars.
+ *
+ * Mounted as a SessionUserAFS overlay at `/${mountPrefix}` (typically
+ * /instance). Receives SUB-PATHS (after prefix stripping by the overlay
+ * system) and reconstructs full paths internally using mountPrefix.
+ *
+ * P1: write + delete implemented.
+ * P2: read gate (readRole) + createSessionView wiring.
+ */
+declare class ReplicationResolver implements AFSModule {
+  private readonly opts;
+  readonly name: string;
+  private readonly mountPrefix;
+  constructor(opts: ReplicationResolverOptions);
+  /**
+   * Reconstruct the full canonical path from the sub-path the overlay delivers.
+   * The overlay at `/${mountPrefix}` strips the prefix, leaving e.g. `/notes/n1`
+   * from `/instance/notes/n1`. We prepend mountPrefix to restore the full path.
+   */
+  private toFullPath;
+  private getEffectiveMinRole;
+  private getEffectiveReadRole;
+  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  stat(path: string, options?: AFSStatOptions): Promise<AFSStatResult>;
+  search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  write(path: string, content: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+}
+//#endregion
+export { ReplicationResolver, ReplicationResolverOptions };
+//# sourceMappingURL=replication-resolver.d.cts.map

package/dist/session/replication-resolver.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replication-resolver.d.cts","names":[],"sources":["../../src/session/replication-resolver.ts"],"mappings":";;;;;;;;UAqCiB,0BAAA;EAKa;;;;EAA5B,WAAA,EAAa,MAAA,SAAe,oBAAA;EAM5B;EAJA,eAAA,EAAiB,OAAA;EAMjB;EAJA,WAAA,EAAa,SAAA;EAQb;EANA,gBAAA,EAAkB,gBAAA;EAelB;EAbA,SAAA;EAaW;EAXX,UAAA;EAkP+B;EAhP/B,SAAA;EAoPmC;EAlPnC,WAAA;EA2S4D;;;;;;EApS5D,WAAA;AAAA;;;;;;;;;;;;;cAuOW,mBAAA,YAA+B,SAAA;EAAA,iBAIb,IAAA;EAAA,SAHpB,IAAA;EAAA,iBACQ,WAAA;cAEY,IAAA,EAAM,0BAAA;EAgP7B;;;;;EAAA,QApOE,UAAA;EAAA,QAOM,mBAAA;EAAA,QAkBA,oBAAA;EAoBR,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAyBtD,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAsBtD,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAsBtD,MAAA,CAAO,IAAA,UAAc,KAAA,UAAe,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAsBzE,KAAA,CACJ,IAAA,UACA,OAAA,EAAS,oBAAA,EACT,OAAA,GAAU,eAAA,GACT,OAAA,CAAQ,cAAA;EAwFL,MAAA,CAAO,IAAA,UAAc,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,eAAA;AAAA"}

package/dist/session/replication-resolver.d.mts

@@ -0,0 +1,71 @@
+import { SettingsResolver } from "./settings-resolver.mjs";
+import { AFSDeleteOptions, AFSDeleteResult, AFSListOptions, AFSListResult, AFSModule, AFSReadOptions, AFSReadResult, AFSRoot, AFSSearchOptions, AFSSearchResult, AFSStatOptions, AFSStatResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult, ReplicatedCollection } from "@aigne/afs";
+
+//#region src/session/replication-resolver.d.ts
+/**
+ * Construction options for ReplicationResolver.
+ * Injected at createSessionView (P2), not pre-built upstream.
+ */
+interface ReplicationResolverOptions {
+  /**
+   * Parsed replicated-collection declarations from the blocklet manifest.
+   * Key = logical collection name; value = validated ReplicatedCollection.
+   */
+  collections: Record<string, ReplicatedCollection>;
+  /** The canonical backend (instance space, role:system). */
+  instanceBackend: AFSRoot;
+  /** The author-copy backend (user space, role:user), or null for anonymous callers. */
+  userBackend: AFSModule | null;
+  /** SettingsResolver reference for reading effective minRole/readRole overrides. */
+  settingsResolver: SettingsResolver | null;
+  /** Verified caller DID (from AFSContext.caller.did, never client-supplied). */
+  callerDid: string | undefined;
+  /** Caller role (daemon-folded single string from getCallerForSession). */
+  callerRole: string | undefined;
+  /** Owning session id — for event origin tagging in P2+. */
+  sessionId: string;
+  /** Instance DID used in copy-side sidecar canonical_ref. */
+  instanceDid?: string;
+  /**
+   * The path prefix this resolver is mounted at, WITHOUT leading slash.
+   * e.g. "instance" when mounted at /instance. Used to reconstruct the full
+   * canonical path from the sub-path the overlay system delivers.
+   * When omitted, computed automatically via computeReplicationMountPrefix().
+   */
+  mountPrefix?: string;
+}
+/**
+ * ReplicationResolver intercepts writes and deletes to replicated-collection
+ * paths, enforces role gates, and fans out to both canonical (instanceBackend)
+ * and author copy (userBackend) with provenance sidecars.
+ *
+ * Mounted as a SessionUserAFS overlay at `/${mountPrefix}` (typically
+ * /instance). Receives SUB-PATHS (after prefix stripping by the overlay
+ * system) and reconstructs full paths internally using mountPrefix.
+ *
+ * P1: write + delete implemented.
+ * P2: read gate (readRole) + createSessionView wiring.
+ */
+declare class ReplicationResolver implements AFSModule {
+  private readonly opts;
+  readonly name: string;
+  private readonly mountPrefix;
+  constructor(opts: ReplicationResolverOptions);
+  /**
+   * Reconstruct the full canonical path from the sub-path the overlay delivers.
+   * The overlay at `/${mountPrefix}` strips the prefix, leaving e.g. `/notes/n1`
+   * from `/instance/notes/n1`. We prepend mountPrefix to restore the full path.
+   */
+  private toFullPath;
+  private getEffectiveMinRole;
+  private getEffectiveReadRole;
+  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  stat(path: string, options?: AFSStatOptions): Promise<AFSStatResult>;
+  search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  write(path: string, content: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+}
+//#endregion
+export { ReplicationResolver, ReplicationResolverOptions };
+//# sourceMappingURL=replication-resolver.d.mts.map

package/dist/session/replication-resolver.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replication-resolver.d.mts","names":[],"sources":["../../src/session/replication-resolver.ts"],"mappings":";;;;;;;;UAqCiB,0BAAA;EAKa;;;;EAA5B,WAAA,EAAa,MAAA,SAAe,oBAAA;EAM5B;EAJA,eAAA,EAAiB,OAAA;EAMjB;EAJA,WAAA,EAAa,SAAA;EAQb;EANA,gBAAA,EAAkB,gBAAA;EAelB;EAbA,SAAA;EAaW;EAXX,UAAA;EAkP+B;EAhP/B,SAAA;EAoPmC;EAlPnC,WAAA;EA2S4D;;;;;;EApS5D,WAAA;AAAA;;;;;;;;;;;;;cAuOW,mBAAA,YAA+B,SAAA;EAAA,iBAIb,IAAA;EAAA,SAHpB,IAAA;EAAA,iBACQ,WAAA;cAEY,IAAA,EAAM,0BAAA;EAgP7B;;;;;EAAA,QApOE,UAAA;EAAA,QAOM,mBAAA;EAAA,QAkBA,oBAAA;EAoBR,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAyBtD,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAsBtD,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAsBtD,MAAA,CAAO,IAAA,UAAc,KAAA,UAAe,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAsBzE,KAAA,CACJ,IAAA,UACA,OAAA,EAAS,oBAAA,EACT,OAAA,GAAU,eAAA,GACT,OAAA,CAAQ,cAAA;EAwFL,MAAA,CAAO,IAAA,UAAc,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,eAAA;AAAA"}