@sage-protocol/sdk 0.1.24 → 0.2.0

package/dist/node/index.mjs

@@ -20,7 +20,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.24",
+      version: "0.2.0",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -73,6 +73,7 @@ var require_package = __commonJS({
         build: "tsup --config tsup.config.ts",
         clean: "rm -rf dist",
         test: 'yarn build && node --test "tests/**/*.test.js"',
+        prepublishOnly: "npm run build",
         release: "yarn build && npm publish --workspace @sage-protocol/sdk"
       },
       dependencies: {
@@ -3117,8 +3118,9 @@ var require_ipfs = __commonJS({
       async function uploadJson(payload, name = "metadata", options2 = {}) {
         const data = {
           name,
-          timestamp: Date.now(),
-          ...payload
+          description: options2.description || `JSON: ${name}`,
+          content: typeof payload === "string" ? payload : JSON.stringify(payload, null, 2),
+          timestamp: Date.now()
         };
         const metadata = {
           name,
@@ -3129,6 +3131,7 @@ var require_ipfs = __commonJS({
           provider: options2.provider,
           warm: options2.warm,
           gateways: options2.gateways,
+          pin: options2.pin,
           filename: `${name}.json`,
           metadata
         });
@@ -3655,7 +3658,13 @@ var require_validation = __commonJS({
         return { schema: null, schemaPath: null };
       }
       function detectVersion(manifest) {
-        return "3.0.0";
+        const version = manifest?.version;
+        if (typeof version === "string") {
+          const trimmed = version.trim();
+          if (trimmed === "3.0.0") return "3.0.0";
+          return "2.0.0";
+        }
+        return "2.0.0";
       }
       function lintManifest(manifest, { enforceVersion = true, manifestPath = null } = {}) {
         if (!manifest || typeof manifest !== "object") {
@@ -5983,13 +5992,16 @@ var require_operations = __commonJS({
       proposalId,
       refresh = false,
       cache = null,
-      fromBlock = 0,
+      fromBlock = null,
+      // null means auto-detect from current block
       helperAddress = null,
       subgraphUrl = null,
       hints = {},
       chunkSizeBlocks = 1e4,
       lookBackBlocks = 2e3,
-      lookAheadBlocks = 2e3
+      lookAheadBlocks = 2e3,
+      maxBlockRange = 5e4
+      // Default to 50k blocks to avoid RPC limits
     }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const govAddr = normaliseGovernor(governor);
@@ -6051,7 +6063,8 @@ var require_operations = __commonJS({
         metadata = null;
       }
       if (!metadata) {
-        let lower = fromBlock || 0;
+        const currentBlock = await provider.getBlockNumber();
+        let lower = fromBlock !== null ? fromBlock : Math.max(0, currentBlock - maxBlockRange);
         try {
           const govAbi = new Interface(ABI.Governor);
           const govC = new Contract(govAddr, govAbi, provider);
@@ -9795,6 +9808,335 @@ var require_contributions = __commonJS({
   }
 });
 
+// src/browser/reputation.js
+var require_reputation = __commonJS({
+  "src/browser/reputation.js"(exports2, module2) {
+    var { getAddress } = require_utils();
+    var subgraph = require_subgraph2();
+    function safeGetAddress(value) {
+      try {
+        return getAddress(value);
+      } catch {
+        return null;
+      }
+    }
+    function clampInt(value, { min = 1, max = 100, fallback = 100 } = {}) {
+      const n = Number(value);
+      if (!Number.isFinite(n)) return fallback;
+      return Math.min(max, Math.max(min, Math.trunc(n)));
+    }
+    function toBigIntString(value, fallback = "0") {
+      try {
+        if (typeof value === "bigint") return value.toString();
+        if (typeof value === "number") return String(Math.trunc(value));
+        const str = String(value).trim();
+        if (!str) return fallback;
+        if (!/^-?\d+$/.test(str)) return fallback;
+        return str;
+      } catch {
+        return fallback;
+      }
+    }
+    function mapSafe(list, mapper) {
+      const out = [];
+      for (const item of list || []) {
+        try {
+          const v = mapper(item);
+          if (v != null) out.push(v);
+        } catch {
+        }
+      }
+      return out;
+    }
+    async function getBadgesByRecipient({ url, recipient, first = 50 }) {
+      if (!url) throw new Error("subgraph url required");
+      if (!recipient) throw new Error("recipient required");
+      const addr = safeGetAddress(recipient);
+      if (!addr) throw new Error("invalid recipient address");
+      const doc = `
+    query($recipient: Bytes!, $first: Int!) {
+      soulboundBadges(
+        where: { recipient: $recipient }
+        first: $first
+        orderBy: blockTimestamp
+        orderDirection: desc
+      ) {
+        id
+        contract
+        badgeId
+        recipient
+        evidenceURI
+        blockNumber
+        blockTimestamp
+        transactionHash
+      }
+    }
+  `;
+      const data = await subgraph.query(url, doc, {
+        recipient: addr.toLowerCase(),
+        first: clampInt(first, { min: 1, max: 100, fallback: 50 })
+      });
+      return mapSafe(data?.soulboundBadges, (row) => {
+        const contract = safeGetAddress(row.contract);
+        const recipientAddr = safeGetAddress(row.recipient);
+        if (!contract || !recipientAddr) return null;
+        return {
+          id: String(row.id),
+          contract,
+          badgeId: toBigIntString(row.badgeId, "0"),
+          recipient: recipientAddr,
+          evidenceURI: row.evidenceURI || null,
+          blockNumber: Number(row.blockNumber || 0),
+          blockTimestamp: Number(row.blockTimestamp || 0),
+          transactionHash: row.transactionHash || null
+        };
+      });
+    }
+    async function listContributions({ url, contributor, subdao, first = 50, orderBy = "updatedAt", orderDirection = "desc" }) {
+      if (!url) throw new Error("subgraph url required");
+      const filters = [];
+      if (contributor) {
+        const addr = safeGetAddress(contributor);
+        if (!addr) throw new Error("invalid contributor address");
+        filters.push(`contributor: "${addr.toLowerCase()}"`);
+      }
+      if (subdao) {
+        const addr = safeGetAddress(subdao);
+        if (!addr) throw new Error("invalid subdao address");
+        filters.push(`dao: "${addr.toLowerCase()}"`);
+      }
+      const where = filters.length ? `where: { ${filters.join(", ")} }` : "";
+      const safeOrderBy = ["updatedAt", "createdAt"].includes(orderBy) ? orderBy : "updatedAt";
+      const safeOrderDirection = orderDirection === "asc" ? "asc" : "desc";
+      const doc = `
+    query($first: Int!) {
+      promptContributions(
+        ${where}
+        first: $first
+        orderBy: ${safeOrderBy}
+        orderDirection: ${safeOrderDirection}
+      ) {
+        id
+        dao
+        promptKey
+        contributor
+        cid
+        proposalId
+        forVotes
+        againstVotes
+        abstainVotes
+        uniqueVoters
+        quorum
+        fromBounty
+        bountyId
+        badgeId
+        badgeEvidenceURI
+        createdAt
+        updatedAt
+        transactionHash
+      }
+    }
+  `;
+      const data = await subgraph.query(url, doc, {
+        first: clampInt(first, { min: 1, max: 100, fallback: 50 })
+      });
+      return mapSafe(data?.promptContributions, (row) => {
+        const dao = safeGetAddress(row.dao);
+        const contributorAddr = safeGetAddress(row.contributor);
+        if (!dao) return null;
+        return {
+          id: String(row.id),
+          dao,
+          promptKey: String(row.promptKey),
+          contributor: contributorAddr || "0x0000000000000000000000000000000000000000",
+          cid: String(row.cid),
+          timestamp: Number(row.updatedAt || 0),
+          createdAt: Number(row.createdAt || 0),
+          updatedAt: Number(row.updatedAt || 0),
+          transactionHash: row.transactionHash || null,
+          proposalId: row.proposalId != null ? toBigIntString(row.proposalId) : null,
+          forVotes: row.forVotes != null ? toBigIntString(row.forVotes) : null,
+          againstVotes: row.againstVotes != null ? toBigIntString(row.againstVotes) : null,
+          abstainVotes: row.abstainVotes != null ? toBigIntString(row.abstainVotes) : null,
+          uniqueVoters: row.uniqueVoters != null ? Number(row.uniqueVoters) : null,
+          quorum: row.quorum != null ? toBigIntString(row.quorum) : null,
+          fromBounty: Boolean(row.fromBounty),
+          bountyId: row.bountyId != null ? toBigIntString(row.bountyId) : null,
+          badgeId: row.badgeId != null ? toBigIntString(row.badgeId) : null,
+          badgeEvidenceURI: row.badgeEvidenceURI || null
+        };
+      });
+    }
+    function computeAggregates(contributions) {
+      if (!contributions || contributions.length === 0) {
+        return {
+          totalContributions: 0,
+          uniqueContributors: 0,
+          bountyOriginated: 0,
+          governanceOriginated: 0,
+          totalForVotes: "0",
+          totalAgainstVotes: "0",
+          averageVoterCount: 0,
+          badgeCount: 0
+        };
+      }
+      const contributorSet = /* @__PURE__ */ new Set();
+      let bountyOriginated = 0;
+      let governanceOriginated = 0;
+      let totalForVotes = 0n;
+      let totalAgainstVotes = 0n;
+      let voterCountSum = 0;
+      let voterCountN = 0;
+      let badgeCount = 0;
+      for (const c of contributions) {
+        if (c.contributor) contributorSet.add(c.contributor.toLowerCase());
+        if (c.fromBounty) {
+          bountyOriginated++;
+        } else {
+          governanceOriginated++;
+        }
+        if (c.forVotes != null) {
+          try {
+            totalForVotes += BigInt(c.forVotes);
+          } catch {
+          }
+        }
+        if (c.againstVotes != null) {
+          try {
+            totalAgainstVotes += BigInt(c.againstVotes);
+          } catch {
+          }
+        }
+        if (c.uniqueVoters != null) {
+          voterCountSum += c.uniqueVoters;
+          voterCountN++;
+        }
+        if (c.badgeId != null) badgeCount++;
+      }
+      return {
+        totalContributions: contributions.length,
+        uniqueContributors: contributorSet.size,
+        bountyOriginated,
+        governanceOriginated,
+        totalForVotes: totalForVotes.toString(),
+        totalAgainstVotes: totalAgainstVotes.toString(),
+        averageVoterCount: voterCountN > 0 ? Math.round(voterCountSum / voterCountN) : 0,
+        badgeCount
+      };
+    }
+    async function getByAddress({
+      url,
+      address,
+      subdao,
+      includeBadges = true,
+      includeContributions = true,
+      first = 100
+    } = {}) {
+      if (!url) throw new Error("subgraph url required");
+      if (!address) throw new Error("address required");
+      const addr = safeGetAddress(address);
+      if (!addr) throw new Error("invalid address");
+      const subdaoAddr = subdao ? safeGetAddress(subdao) : null;
+      if (subdao && !subdaoAddr) throw new Error("invalid subdao address");
+      const limit = clampInt(first, { min: 1, max: 200, fallback: 100 });
+      let badges = void 0;
+      if (includeBadges) {
+        badges = await getBadgesByRecipient({ url, recipient: addr, first: limit });
+      }
+      let contributionAggregates = void 0;
+      let lastContributionAt = null;
+      if (includeContributions) {
+        const rows = await listContributions({
+          url,
+          contributor: addr,
+          subdao: subdaoAddr || void 0,
+          first: limit,
+          orderBy: "updatedAt",
+          orderDirection: "desc"
+        });
+        if (rows && rows.length) {
+          const updatedAt = rows[0]?.updatedAt ?? rows[0]?.timestamp ?? null;
+          lastContributionAt = updatedAt != null ? Number(updatedAt) : null;
+          if (!Number.isFinite(lastContributionAt)) lastContributionAt = null;
+        }
+        contributionAggregates = computeAggregates(rows || []);
+      }
+      const signals = {
+        badgeCount: includeBadges ? badges ? badges.length : 0 : null,
+        totalContributions: includeContributions ? contributionAggregates ? contributionAggregates.totalContributions : 0 : null,
+        governanceOriginated: includeContributions ? contributionAggregates ? contributionAggregates.governanceOriginated : 0 : null,
+        bountyOriginated: includeContributions ? contributionAggregates ? contributionAggregates.bountyOriginated : 0 : null,
+        lastContributionAt: includeContributions ? lastContributionAt : null
+      };
+      const out = {
+        address: addr,
+        subdao: subdaoAddr || null,
+        signals
+      };
+      if (includeBadges) out.badges = badges;
+      if (includeContributions) {
+        out.contributionAggregates = contributionAggregates;
+        out.lastContributionAt = lastContributionAt;
+      }
+      return out;
+    }
+    function normalizeGateInt(value, name) {
+      if (value === void 0 || value === null) return null;
+      const n = Number(value);
+      if (!Number.isFinite(n) || n < 0) {
+        throw new Error(`invalid gate: ${name}`);
+      }
+      return Math.trunc(n);
+    }
+    function normalizeRequiredBadgeIds(value) {
+      const list = Array.isArray(value) ? value : value != null ? [value] : [];
+      const out = [];
+      for (const item of list) {
+        const id2 = toBigIntString(item, "");
+        if (id2) out.push(id2);
+      }
+      return out;
+    }
+    function evaluate(result, gates = {}) {
+      const reasons = [];
+      const minBadges = normalizeGateInt(gates.minBadges, "minBadges");
+      const minContributions = normalizeGateInt(gates.minContributions, "minContributions");
+      const requiredBadges = normalizeRequiredBadgeIds(gates.requireBadges ?? gates.requireBadge);
+      const badgeCount = Number(result?.signals?.badgeCount ?? (result?.badges?.length ?? 0));
+      const totalContributions = Number(result?.signals?.totalContributions ?? (result?.contributionAggregates?.totalContributions ?? 0));
+      if (minBadges != null) {
+        if (!Number.isFinite(badgeCount)) {
+          reasons.push("badges_unavailable");
+        } else if (badgeCount < minBadges) {
+          reasons.push(`minBadges:${badgeCount}<${minBadges}`);
+        }
+      }
+      if (minContributions != null) {
+        if (!Number.isFinite(totalContributions)) {
+          reasons.push("contributions_unavailable");
+        } else if (totalContributions < minContributions) {
+          reasons.push(`minContributions:${totalContributions}<${minContributions}`);
+        }
+      }
+      if (requiredBadges.length) {
+        const have = new Set((result?.badges || []).map((b) => toBigIntString(b?.badgeId, "")).filter(Boolean));
+        for (const req2 of requiredBadges) {
+          if (!have.has(req2)) reasons.push(`missingBadge:${req2}`);
+        }
+      }
+      return { ok: reasons.length === 0, reasons };
+    }
+    module2.exports = {
+      getByAddress,
+      evaluate,
+      // Expose lower-level functions for advanced usage
+      getBadgesByRecipient,
+      listContributions,
+      computeAggregates
+    };
+  }
+});
+
 // src/votingMultiplier/index.js
 var require_votingMultiplier = __commonJS({
   "src/votingMultiplier/index.js"(exports2, module2) {
@@ -13225,32 +13567,156 @@ var require_git_storage_client = __commonJS({
         this._authCacheExpiry = 0;
       }
       // =========================================================================
-      // Library Management
+      // Path Building Helpers
+      // =========================================================================
+      /**
+       * Build a library path based on tier
+       * @private
+       * @param {'dao'|'personal'|'cache'} tier - Library tier
+       * @param {string} [subdao] - SubDAO address (required for DAO tier)
+       * @param {string} libraryId - Library identifier
+       * @param {string} [subpath] - Additional path segment
+       * @returns {string}
+       */
+      _buildLibraryPath(tier, subdao, libraryId, subpath = "") {
+        const encodedLibraryId = encodeURIComponent(libraryId);
+        const suffix = subpath ? `/${subpath}` : "";
+        switch (tier) {
+          case "dao":
+            if (!subdao) throw new Error("subdao required for DAO tier");
+            return `/git/dao/${encodeURIComponent(subdao)}/${encodedLibraryId}${suffix}`;
+          case "personal":
+            return `/git/personal/${encodedLibraryId}${suffix}`;
+          case "cache":
+            return `/git/cache${suffix}`;
+          default:
+            throw new Error(`Unknown tier: ${tier}`);
+        }
+      }
+      /**
+       * Build path from context object
+       * @private
+       * @param {LibraryContext} ctx - Library context
+       * @param {string} [subpath] - Additional path segment
+       * @returns {string}
+       */
+      _buildPath(ctx, subpath = "") {
+        return this._buildLibraryPath(ctx.tier, ctx.subdao, ctx.libraryId, subpath);
+      }
+      // =========================================================================
+      // Library Management - DAO Libraries
       // =========================================================================
       /**
-       * Create a new library
+       * Create a new DAO library (requires governance authority)
        * @param {string} subdao - SubDAO address
        * @param {string} name - Library name
        * @param {Object} [options] - Creation options
+       * @param {string} [options.libraryId] - Custom library ID (auto-generated from name if not provided)
        * @param {string} [options.description] - Library description
        * @param {'public'|'private'} [options.visibility='public'] - Library visibility
        * @returns {Promise<LibraryMetadata>}
        */
-      async createLibrary(subdao, name, options = {}) {
-        return this._post("/git/libraries", {
-          subdao,
+      async createDAOLibrary(subdao, name, options = {}) {
+        return this._post(`/git/dao/${encodeURIComponent(subdao)}/libraries`, {
           name,
+          libraryId: options.libraryId,
           description: options.description,
           visibility: options.visibility || "public"
         }, { auth: true });
       }
       /**
-       * Get library metadata
+       * List libraries for a SubDAO
+       * @param {string} subdao - SubDAO address
+       * @returns {Promise<{libraries: LibraryMetadata[], subdao: string}>}
+       */
+      async listDAOLibraries(subdao) {
+        return this._get(`/git/dao/${encodeURIComponent(subdao)}/libraries`);
+      }
+      /**
+       * Get DAO library metadata
+       * @param {string} subdao - SubDAO address
+       * @param {string} libraryId - Library identifier
+       * @returns {Promise<LibraryMetadata>}
+       */
+      async getDAOLibrary(subdao, libraryId) {
+        return this._get(this._buildLibraryPath("dao", subdao, libraryId));
+      }
+      /**
+       * Delete a DAO library (requires admin or governance authority)
+       * @param {string} subdao - SubDAO address
+       * @param {string} libraryId - Library identifier
+       * @returns {Promise<{deleted: boolean, libraryId: string}>}
+       */
+      async deleteDAOLibrary(subdao, libraryId) {
+        return this._delete(this._buildLibraryPath("dao", subdao, libraryId), { auth: true });
+      }
+      // =========================================================================
+      // Library Management - Personal Libraries
+      // =========================================================================
+      /**
+       * Create a new personal library
+       * @param {string} name - Library name
+       * @param {Object} [options] - Creation options
+       * @param {string} [options.libraryId] - Custom library ID (auto-generated from name if not provided)
+       * @param {string} [options.description] - Library description
+       * @param {'public'|'private'} [options.visibility='private'] - Library visibility
+       * @returns {Promise<LibraryMetadata>}
+       */
+      async createPersonalLibrary(name, options = {}) {
+        return this._post("/git/personal/libraries", {
+          name,
+          libraryId: options.libraryId,
+          description: options.description,
+          visibility: options.visibility || "private"
+        }, { auth: true });
+      }
+      /**
+       * List personal libraries for authenticated user
+       * @returns {Promise<{libraries: LibraryMetadata[], owner: string}>}
+       */
+      async listPersonalLibraries() {
+        return this._get("/git/personal/libraries", { auth: true });
+      }
+      /**
+       * Get personal library metadata
+       * @param {string} libraryId - Library identifier
+       * @returns {Promise<LibraryMetadata>}
+       */
+      async getPersonalLibrary(libraryId) {
+        return this._get(this._buildLibraryPath("personal", null, libraryId), { auth: true });
+      }
+      /**
+       * Delete a personal library
+       * @param {string} libraryId - Library identifier
+       * @returns {Promise<{deleted: boolean, libraryId: string}>}
+       */
+      async deletePersonalLibrary(libraryId) {
+        return this._delete(this._buildLibraryPath("personal", null, libraryId), { auth: true });
+      }
+      // =========================================================================
+      // Library Management - Legacy/Generic (Backwards Compatibility)
+      // =========================================================================
+      /**
+       * Create a new library (legacy - use createDAOLibrary or createPersonalLibrary)
+       * @deprecated Use createDAOLibrary() or createPersonalLibrary() instead
+       * @param {string} subdao - SubDAO address
+       * @param {string} name - Library name
+       * @param {Object} [options] - Creation options
+       * @param {string} [options.description] - Library description
+       * @param {'public'|'private'} [options.visibility='public'] - Library visibility
+       * @returns {Promise<LibraryMetadata>}
+       */
+      async createLibrary(subdao, name, options = {}) {
+        return this.createDAOLibrary(subdao, name, { ...options, libraryId: "default" });
+      }
+      /**
+       * Get library metadata (legacy - use getDAOLibrary or getPersonalLibrary)
+       * @deprecated Use getDAOLibrary() or getPersonalLibrary() instead
        * @param {string} subdao - SubDAO address
        * @returns {Promise<LibraryMetadata>}
        */
       async getLibrary(subdao) {
-        return this._get(`/git/libraries/${encodeURIComponent(subdao)}`);
+        return this.getDAOLibrary(subdao, "default");
       }
       /**
        * List all libraries
@@ -13267,207 +13733,251 @@ var require_git_storage_client = __commonJS({
         return this._get(`/git/libraries${queryString ? "?" + queryString : ""}`);
       }
       /**
-       * Delete a library (admin only)
+       * Delete a library (legacy - use deleteDAOLibrary or deletePersonalLibrary)
+       * @deprecated Use deleteDAOLibrary() or deletePersonalLibrary() instead
        * @param {string} subdao - SubDAO address
        * @returns {Promise<{ok: boolean}>}
        */
       async deleteLibrary(subdao) {
-        return this._delete(`/git/libraries/${encodeURIComponent(subdao)}`, { auth: true });
+        return this.deleteDAOLibrary(subdao, "default");
       }
       // =========================================================================
       // Git Object Operations
       // =========================================================================
       /**
        * Store git objects (batch)
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {GitObject[]} objects - Objects to store
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{stored: number}>}
        */
-      async putObjects(subdao, objects) {
-        return this._post(`/git/${encodeURIComponent(subdao)}/objects`, { objects }, { auth: true });
+      async putObjects(target, objects, libraryId = "default") {
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, "objects") : this._buildPath(target, "objects");
+        return this._post(path2, { objects }, { auth: true });
       }
       /**
        * Get a single git object
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {string} oid - Object ID
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<GitObject>}
        */
-      async getObject(subdao, oid) {
-        return this._get(`/git/${encodeURIComponent(subdao)}/objects/${oid}`);
+      async getObject(target, oid, libraryId = "default") {
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, `objects/${oid}`) : this._buildPath(target, `objects/${oid}`);
+        return this._get(path2);
       }
       /**
        * Get multiple git objects
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {string[]} oids - Object IDs
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{objects: GitObject[]}>}
        */
-      async getObjects(subdao, oids) {
-        return this._get(`/git/${encodeURIComponent(subdao)}/objects?oids=${oids.join(",")}`);
+      async getObjects(target, oids, libraryId = "default") {
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, `objects?oids=${oids.join(",")}`) : this._buildPath(target, `objects?oids=${oids.join(",")}`);
+        return this._get(path2);
       }
       // =========================================================================
       // Reference Operations
       // =========================================================================
       /**
        * List all refs
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{refs: GitRef[]}>}
        */
-      async listRefs(subdao) {
-        return this._get(`/git/${encodeURIComponent(subdao)}/refs`);
+      async listRefs(target, libraryId = "default") {
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, "refs") : this._buildPath(target, "refs");
+        return this._get(path2);
       }
       /**
        * Get a specific ref
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {string} refName - Reference name (e.g., 'refs/heads/main')
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<GitRef>}
        */
-      async getRef(subdao, refName) {
-        return this._get(`/git/${encodeURIComponent(subdao)}/refs/${encodeURIComponent(refName)}`);
+      async getRef(target, refName, libraryId = "default") {
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, `refs/${encodeURIComponent(refName)}`) : this._buildPath(target, `refs/${encodeURIComponent(refName)}`);
+        return this._get(path2);
       }
       /**
        * Update a ref
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {string} refName - Reference name
        * @param {string} oid - New object ID
        * @param {Object} [options] - Update options
        * @param {string} [options.oldOid] - Expected current OID (for optimistic concurrency)
+       * @param {string} [options.libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{ok: boolean}>}
        */
-      async updateRef(subdao, refName, oid, options = {}) {
-        return this._post(
-          `/git/${encodeURIComponent(subdao)}/refs/${encodeURIComponent(refName)}`,
-          { oid, oldOid: options.oldOid },
-          { auth: true }
-        );
+      async updateRef(target, refName, oid, options = {}) {
+        const libraryId = options.libraryId || "default";
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, `refs/${encodeURIComponent(refName)}`) : this._buildPath(target, `refs/${encodeURIComponent(refName)}`);
+        return this._post(path2, { oid, oldOid: options.oldOid }, { auth: true });
       }
       // =========================================================================
       // Sync Operations
       // =========================================================================
       /**
        * Push changes to library
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {Object} payload - Push payload
        * @param {GitObject[]} payload.objects - Objects to push
        * @param {Record<string, string>} payload.refs - Ref updates (name -> oid)
        * @param {string} payload.message - Commit message
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<PushResult>}
        */
-      async push(subdao, payload) {
-        return this._post(`/git/${encodeURIComponent(subdao)}/push`, payload, { auth: true });
+      async push(target, payload, libraryId = "default") {
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, "push") : this._buildPath(target, "push");
+        return this._post(path2, payload, { auth: true });
       }
       /**
        * Clone a library (get all objects and refs)
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{objects: GitObject[], refs: Record<string, string>, metadata: LibraryMetadata}>}
        */
-      async clone(subdao) {
-        return this._get(`/git/${encodeURIComponent(subdao)}/clone`);
+      async clone(target, libraryId = "default") {
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, "clone") : this._buildPath(target, "clone");
+        return this._get(path2);
       }
       /**
        * Fetch changes since a commit
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {string} [since] - Commit OID to fetch since
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{objects: GitObject[], refs: Record<string, string>}>}
        */
-      async fetch(subdao, since) {
+      async fetch(target, since, libraryId = "default") {
         const params = since ? `?since=${since}` : "";
-        return this._get(`/git/${encodeURIComponent(subdao)}/fetch${params}`);
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, `fetch${params}`) : this._buildPath(target, `fetch${params}`);
+        return this._get(path2);
       }
       // =========================================================================
       // File Access
       // =========================================================================
       /**
        * Get commit history
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {Object} [options] - History options
        * @param {string} [options.ref='refs/heads/main'] - Reference to get history from
        * @param {number} [options.limit=50] - Max commits to return
+       * @param {string} [options.libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{commits: GitCommit[]}>}
        */
-      async getHistory(subdao, options = {}) {
+      async getHistory(target, options = {}) {
         const params = new URLSearchParams();
         if (options.ref) params.set("ref", options.ref);
         if (options.limit !== void 0) params.set("limit", String(options.limit));
-        return this._get(`/git/${encodeURIComponent(subdao)}/log?${params}`);
+        const libraryId = options.libraryId || "default";
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, `log?${params}`) : this._buildPath(target, `log?${params}`);
+        return this._get(path2);
       }
       /**
        * Get directory listing
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {string} ref - Reference (e.g., 'main')
-       * @param {string} path - Directory path
+       * @param {string} filePath - Directory path
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{entries: Array}>}
        */
-      async getTree(subdao, ref, path2) {
-        return this._get(
-          `/git/${encodeURIComponent(subdao)}/tree/${encodeURIComponent(ref)}/${encodeURIComponent(path2)}`
-        );
+      async getTree(target, ref, filePath, libraryId = "default") {
+        const subpath = `tree/${encodeURIComponent(ref)}/${encodeURIComponent(filePath)}`;
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, subpath) : this._buildPath(target, subpath);
+        return this._get(path2);
       }
       /**
        * Get file contents
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {string} ref - Reference (e.g., 'main')
-       * @param {string} path - File path
+       * @param {string} filePath - File path
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{content: string}>}
        */
-      async getBlob(subdao, ref, path2) {
-        return this._get(
-          `/git/${encodeURIComponent(subdao)}/blob/${encodeURIComponent(ref)}/${encodeURIComponent(path2)}`
-        );
+      async getBlob(target, ref, filePath, libraryId = "default") {
+        const subpath = `blob/${encodeURIComponent(ref)}/${encodeURIComponent(filePath)}`;
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, subpath) : this._buildPath(target, subpath);
+        return this._get(path2);
       }
       /**
        * Get file contents as string (convenience method)
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {string} ref - Reference (e.g., 'main')
-       * @param {string} path - File path
+       * @param {string} filePath - File path
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<string>}
        */
-      async getFile(subdao, ref, path2) {
-        const result = await this.getBlob(subdao, ref, path2);
+      async getFile(target, ref, filePath, libraryId = "default") {
+        const result = await this.getBlob(target, ref, filePath, libraryId);
         return result.content;
       }
       // =========================================================================
       // Fork Operations
       // =========================================================================
       /**
-       * Fork a library to a new SubDAO
+       * Fork a DAO library to a new SubDAO
        * @param {string} sourceSubdao - Source SubDAO address to fork from
+       * @param {string} sourceLibraryId - Source library ID
        * @param {string} targetSubdao - Target SubDAO address for the fork
        * @param {Object} [options] - Fork options
+       * @param {string} [options.targetLibraryId] - Library ID for the fork
        * @param {string} [options.targetName] - Name for the forked library
        * @param {string} [options.targetDescription] - Description for the forked library
        * @returns {Promise<{ok: boolean, forkedLibrary: string, sourceLibrary: string, commitsCopied: number}>}
        */
-      async fork(sourceSubdao, targetSubdao, options = {}) {
-        return this._post(`/git/libraries/${encodeURIComponent(sourceSubdao)}/fork`, {
+      async forkDAOLibrary(sourceSubdao, sourceLibraryId, targetSubdao, options = {}) {
+        const path2 = this._buildLibraryPath("dao", sourceSubdao, sourceLibraryId, "fork");
+        return this._post(path2, {
           targetSubdao,
+          targetLibraryId: options.targetLibraryId,
           targetName: options.targetName,
           targetDescription: options.targetDescription
         }, { auth: true });
       }
+      /**
+       * Fork a library (legacy - uses 'default' libraryId)
+       * @deprecated Use forkDAOLibrary() instead
+       * @param {string} sourceSubdao - Source SubDAO address to fork from
+       * @param {string} targetSubdao - Target SubDAO address for the fork
+       * @param {Object} [options] - Fork options
+       * @param {string} [options.targetName] - Name for the forked library
+       * @param {string} [options.targetDescription] - Description for the forked library
+       * @returns {Promise<{ok: boolean, forkedLibrary: string, sourceLibrary: string, commitsCopied: number}>}
+       */
+      async fork(sourceSubdao, targetSubdao, options = {}) {
+        return this.forkDAOLibrary(sourceSubdao, "default", targetSubdao, options);
+      }
       /**
        * List forks of a library
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{forks: Array, count: number}>}
        */
-      async getForks(subdao) {
-        return this._get(`/git/libraries/${encodeURIComponent(subdao)}/forks`);
+      async getForks(target, libraryId = "default") {
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, "forks") : this._buildPath(target, "forks");
+        return this._get(path2);
       }
       /**
        * Get upstream fork info (for forked libraries)
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{upstreamSubdao: string, upstreamCommit: string, forkedAt: number}>}
        */
-      async getUpstream(subdao) {
-        return this._get(`/git/${encodeURIComponent(subdao)}/upstream`);
+      async getUpstream(target, libraryId = "default") {
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, "upstream") : this._buildPath(target, "upstream");
+        return this._get(path2);
       }
       /**
        * Check if a library is a fork
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<boolean>}
        */
-      async isFork(subdao) {
+      async isFork(target, libraryId = "default") {
         try {
-          await this.getUpstream(subdao);
+          await this.getUpstream(target, libraryId);
           return true;
         } catch (e) {
           if (e.message && e.message.includes("404")) {
@@ -13481,59 +13991,62 @@ var require_git_storage_client = __commonJS({
       // =========================================================================
       /**
        * List collaborators
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{collaborators: Collaborator[]}>}
        */
-      async listCollaborators(subdao) {
-        return this._get(`/git/${encodeURIComponent(subdao)}/collaborators`);
+      async listCollaborators(target, libraryId = "default") {
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, "collaborators") : this._buildPath(target, "collaborators");
+        return this._get(path2);
       }
       /**
        * Add a collaborator
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {string} address - Collaborator wallet address
        * @param {'read'|'write'|'admin'} permission - Permission level
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{ok: boolean}>}
        */
-      async addCollaborator(subdao, address, permission) {
-        return this._post(`/git/${encodeURIComponent(subdao)}/collaborators`, {
-          address,
-          permission
-        }, { auth: true });
+      async addCollaborator(target, address, permission, libraryId = "default") {
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, "collaborators") : this._buildPath(target, "collaborators");
+        return this._post(path2, { address, permission }, { auth: true });
       }
       /**
        * Remove a collaborator
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {string} address - Collaborator wallet address
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{ok: boolean}>}
        */
-      async removeCollaborator(subdao, address) {
-        return this._delete(
-          `/git/${encodeURIComponent(subdao)}/collaborators/${encodeURIComponent(address)}`,
-          { auth: true }
-        );
+      async removeCollaborator(target, address, libraryId = "default") {
+        const subpath = `collaborators/${encodeURIComponent(address)}`;
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, subpath) : this._buildPath(target, subpath);
+        return this._delete(path2, { auth: true });
       }
       /**
        * Check permissions for an address
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {string} address - Wallet address to check
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<{canRead: boolean, canWrite: boolean, isAdmin: boolean, permission?: string}>}
        */
-      async getPermissions(subdao, address) {
-        return this._get(
-          `/git/${encodeURIComponent(subdao)}/collaborators/${encodeURIComponent(address)}/permissions`
-        );
+      async getPermissions(target, address, libraryId = "default") {
+        const subpath = `collaborators/${encodeURIComponent(address)}/permissions`;
+        const path2 = typeof target === "string" ? this._buildLibraryPath("dao", target, libraryId, subpath) : this._buildPath(target, subpath);
+        return this._get(path2);
       }
       // =========================================================================
       // High-Level Convenience Methods
       // =========================================================================
       /**
        * Push a manifest file (convenience method)
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {Object} manifest - Manifest object to push
        * @param {string} message - Commit message
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<PushResult>}
        */
-      async pushManifest(subdao, manifest, message) {
+      async pushManifest(target, manifest, message, libraryId = "default") {
         const content = JSON.stringify(manifest, null, 2);
         const oid = await this._computeOid(content);
         const objects = [{
@@ -13552,7 +14065,7 @@ var require_git_storage_client = __commonJS({
         });
         let parentOid = null;
         try {
-          const currentRef = await this.getRef(subdao, "refs/heads/main");
+          const currentRef = await this.getRef(target, "refs/heads/main", libraryId);
           parentOid = currentRef.oid;
         } catch (e) {
         }
@@ -13571,20 +14084,21 @@ var require_git_storage_client = __commonJS({
           size: commitContent.length,
           data: this._toBase64(commitContent)
         });
-        return this.push(subdao, {
+        return this.push(target, {
           objects,
           refs: { "refs/heads/main": commitOid },
           message
-        });
+        }, libraryId);
       }
       /**
        * Get manifest from library (convenience method)
-       * @param {string} subdao - SubDAO address
+       * @param {string|LibraryContext} target - SubDAO address (legacy) or LibraryContext
        * @param {string} [ref='main'] - Reference to get manifest from
+       * @param {string} [libraryId='default'] - Library ID (only used if target is string)
        * @returns {Promise<Object>}
        */
-      async getManifest(subdao, ref = "main") {
-        const content = await this.getFile(subdao, ref, "manifest.json");
+      async getManifest(target, ref = "main", libraryId = "default") {
+        const content = await this.getFile(target, ref, "manifest.json", libraryId);
         return JSON.parse(content);
       }
       // =========================================================================
@@ -14049,6 +14563,7 @@ var require_src = __commonJS({
     var boost = require_boost();
     var bounty = require_bounty();
     var contributions = require_contributions();
+    var reputation = require_reputation();
     var votingMultiplier = require_votingMultiplier();
     var auction = require_auction();
     var wallet = require_wallet();
@@ -14102,6 +14617,7 @@ var require_src = __commonJS({
       utils: { ...utils, privateTx, safe, time },
       bounty,
       contributions,
+      reputation,
       votingMultiplier,
       auction,
       wallet: Object.assign(wallet, {