@wishknish/knishio-client-ts 0.7.7 → 0.7.8

package/dist/index.iife.js

@@ -25175,13 +25175,8 @@ ${operationTypes.join("\n")}
     }) {
       const atomMeta = new AtomMeta(meta);
       atomMeta.addPolicy(policy);
-      const wallet = Wallet.create({
-        secret: this.secret,
-        bundle: this.sourceWallet.bundle,
-        token: "USER"
-      });
       this.addAtom(Atom.create({
-        wallet,
+        wallet: this.sourceWallet,
         isotope: "R",
         metaType,
         metaId,
@@ -28592,6 +28587,20 @@ ${operationTypes.join("\n")}
         encrypt: this.cipherLink
       });
     }
+    /**
+     * F-8a (cross-SDK parity, 2026-06-03): re-point the GraphQL-subscription WebSocket
+     * without changing the HTTP endpoint. `setUri` only updates `serverUri`, leaving the
+     * subscription socket pinned to whatever was passed at construction; this lets a
+     * caller re-derive the socket when the endpoint changes.
+     */
+    setSocketUri(socketUri) {
+      this.socketUri = socketUri;
+      this.$__client = this.createUrqlClient({
+        serverUri: this.serverUri,
+        socket: { socketUri },
+        encrypt: this.cipherLink
+      });
+    }
     socketDisconnect() {
       if (this.socketUri) {
         this.unsubscribeAll();
@@ -31517,9 +31526,93 @@ ${operationTypes.join("\n")}
     }
   };
 
+  // src/response/ResponseEmbeddingStatus.ts
+  init_Response();
+  var ResponseEmbeddingStatus = class extends exports.Response {
+    /**
+     * Class constructor
+     */
+    constructor({
+      query,
+      json
+    }) {
+      super({
+        query,
+        json,
+        dataKey: "data.embeddingStatus"
+      });
+    }
+    /**
+     * Returns the array of embedding status items, or null if empty.
+     */
+    payload() {
+      const items = this.data();
+      if (!items || !Array.isArray(items) || items.length === 0) {
+        return null;
+      }
+      return items;
+    }
+  };
+
+  // src/query/QueryEmbeddingStatus.ts
+  var QueryEmbeddingStatus = class extends Query {
+    /**
+     * Create new QueryEmbeddingStatus instance
+     */
+    constructor(graphQLClient, knishIOClient) {
+      super(graphQLClient, knishIOClient);
+      this.$__query = gql`query( $metaType: String, $metaId: String, $instances: [EmbeddingStatusInput!] ) {
+      embeddingStatus( metaType: $metaType, metaId: $metaId, instances: $instances ) {
+        metaType,
+        metaId,
+        state,
+        totalMetas,
+        embeddedCount,
+        embeddedAt,
+        model
+      }
+    }`;
+    }
+    /**
+     * Builds a GraphQL-friendly variables object for embedding status queries.
+     *
+     * Single mode: createVariables({ metaType: 'product', metaId: 'SKU-001' })
+     * Bulk mode:   createVariables({ instances: [{ metaType: 'product', metaId: 'SKU-001' }, ...] })
+     */
+    static createVariables({
+      metaType = null,
+      metaId = null,
+      instances = null
+    } = {}) {
+      const variables = {};
+      if (instances && instances.length > 0) {
+        variables.instances = instances;
+      }
+      if (metaType) {
+        variables.metaType = metaType;
+      }
+      if (metaId) {
+        variables.metaId = metaId;
+      }
+      return variables;
+    }
+    /**
+     * Returns a Response object
+     */
+    createResponse(json) {
+      return new ResponseEmbeddingStatus({
+        query: this,
+        json
+      });
+    }
+  };
+
   // src/response/ResponseProposeMolecule.ts
   init_Response();
   init_Dot();
+  init_MolecularHashMismatchException();
+  init_SignatureMismatchException();
+  init_AtomIndexException();
   var ResponseProposeMolecule = class extends exports.Response {
     $__clientMolecule;
     /**
@@ -31591,6 +31684,47 @@ ${operationTypes.join("\n")}
     reason() {
       return exports.Dot.get(this.data(), "reason", "Invalid response from server");
     }
+    /**
+     * Map this rejection to a typed SDK exception when the failure mode is one
+     * we know about. Returns null on success or for rejections we don't have a
+     * typed class for.
+     *
+     * This is the single place pattern-matching against validator reason strings
+     * lives — consumers (KnishIOClient cache invalidation, callers needing to
+     * branch on failure mode) can `instanceof`-switch on the result instead.
+     * Future validator versions can rephrase reasons (or populate a structured
+     * field in the response payload) without breaking callers.
+     */
+    toException() {
+      if (this.success()) return null;
+      const reason = this.reason();
+      const lc = reason.toLowerCase();
+      if (/molecularhashmismatch|hash.*mismatch/.test(lc)) {
+        return new exports.MolecularHashMismatchException(reason, {
+          details: { reason },
+          code: "HASH_MISMATCH"
+        });
+      }
+      if (/ots.*position.*reuse|position.*already.*used|ots.*verification/.test(lc)) {
+        return new exports.SignatureMismatchException(reason, {
+          details: { reason },
+          code: "OTS_VERIFICATION_FAILED"
+        });
+      }
+      if (/continuid.*chain|previousposition|chain.*violation/.test(lc)) {
+        return new exports.AtomIndexException(reason, {
+          details: { reason },
+          code: "INDEX_CONFLICT"
+        });
+      }
+      if (/signature.*verification|signature.*invalid/.test(lc)) {
+        return new exports.SignatureMismatchException(reason, {
+          details: { reason },
+          code: "VERIFICATION_FAILED"
+        });
+      }
+      return null;
+    }
     /**
      * Returns payload object
      * Matches JavaScript SDK payload method exactly
@@ -32644,6 +32778,13 @@ ${operationTypes.join("\n")}
     $__remainderWallet = null;
     lastMoleculeQuery = null;
     abortControllers = /* @__PURE__ */ new Map();
+    $__capabilityCache = {};
+    // Promise-chain mutex serializing MutationProposeMolecule submissions on this
+    // client. Without it, concurrent createMolecule() calls both query the same
+    // ContinuID position and both sign with it — the second is rejected with
+    // OTS position reuse. Auth-token flow (MutationRequestAuthorization) inherits
+    // from MutationProposeMolecule so it's covered by the same lock.
+    $__moleculeChain = Promise.resolve();
     /**
      * Enhanced constructor with standardized configuration validation (Phase 2 Enhancement)
      */
@@ -32768,6 +32909,7 @@ ${operationTypes.join("\n")}
       this.$__authToken = null;
       this.$__remainderWallet = null;
       this.lastMoleculeQuery = null;
+      this.$__capabilityCache = {};
     }
     /**
      * Get the GraphQL client
@@ -32788,6 +32930,19 @@ ${operationTypes.join("\n")}
         this.$__client.setUri(this.getRandomUri());
       }
     }
+    /**
+     * Sets the WebSocket (subscription) endpoint for this session.
+     *
+     * F-8a (cross-SDK parity, 2026-06-03): `setUri` only updates the HTTP endpoint; the
+     * subscription socket is built once from the `socket.socketUri` passed at
+     * construction. This lets a caller re-point the socket when the endpoint changes
+     * (mirrors the JS SDK's `setSocketUri`).
+     */
+    setSocketUri(socketUri) {
+      if (this.$__client && "setSocketUri" in this.$__client) {
+        this.$__client.setSocketUri(socketUri);
+      }
+    }
     /**
      * Gets the Knish.IO server URIs
      */
@@ -32911,6 +33066,23 @@ ${operationTypes.join("\n")}
       this.lastMoleculeQuery = mutation;
       return mutation;
     }
+    /**
+     * Serializes the given async work behind a per-client promise chain. Used to
+     * guarantee that at most one MutationProposeMolecule submission runs at a
+     * time on this client — query position, sign, submit, observe response must
+     * complete before the next one starts, or two callers race for the same OTS
+     * position and the second gets rejected.
+     *
+     * `.then(fn, fn)` runs fn whether the previous holder resolved or rejected;
+     * the queue's `.catch` swallows the rejection so a single failure doesn't
+     * poison every subsequent caller, while the rejection still propagates to
+     * the caller whose fn threw.
+     */
+    withMoleculeLock(fn) {
+      const result = this.$__moleculeChain.then(fn, fn);
+      this.$__moleculeChain = result.catch(() => void 0);
+      return result;
+    }
     /**
      * Executes a query or mutation
      */
@@ -32923,8 +33095,34 @@ ${operationTypes.join("\n")}
           encrypt: this.$__encrypt
         });
       }
+      if (query instanceof MutationProposeMolecule) {
+        return await this.withMoleculeLock(async () => {
+          const response = await query.execute({ variables: variables || {} });
+          this.handlePositionDrift(response);
+          return response;
+        });
+      }
       return await query.execute({ variables: variables || {} });
     }
+    /**
+     * When a ProposeMolecule submission is rejected for a position-related
+     * reason (OTS reuse, ContinuID chain violation, molecular hash mismatch),
+     * the cached remainder wallet and lastMoleculeQuery are stale — the
+     * validator's chain has advanced past what we know. Clear them so the next
+     * createMolecule call re-queries queryContinuId for the authoritative
+     * position. Other failure modes (network, malformed meta, bad signature
+     * bytes) don't imply drift; leave cached state alone.
+     */
+    handlePositionDrift(response) {
+      if (!(response instanceof ResponseProposeMolecule)) return;
+      const exc = response.toException();
+      if (!exc) return;
+      if (exc instanceof exports.MolecularHashMismatchException || exc instanceof exports.AtomIndexException || exc instanceof exports.SignatureMismatchException && exc.code === "OTS_VERIFICATION_FAILED") {
+        this.$__remainderWallet = null;
+        this.lastMoleculeQuery = null;
+        this.log("warn", `KnishIOClient::executeQuery() - position drift detected (${exc.name}/${exc.code}); cleared cached remainder wallet`);
+      }
+    }
     /**
      * Sets the secret for this session
      */
@@ -33304,6 +33502,63 @@ ${operationTypes.join("\n")}
       }
       return response;
     }
+    /**
+     * Probes the connected server to check whether it supports a named root query field.
+     * Result is cached per URI so the network round-trip happens at most once per URI.
+     *
+     * Uses GraphQL introspection which is universally supported by spec-compliant servers.
+     *
+     * @param fieldName - The root Query field name to check (e.g. 'embeddingStatus')
+     * @returns true if the server schema includes the field, false otherwise
+     */
+    async hasQueryField(fieldName) {
+      const uri = this.$__client.getUri();
+      const cacheKey = `${uri}::${fieldName}`;
+      if (typeof this.$__capabilityCache[cacheKey] === "boolean") {
+        return this.$__capabilityCache[cacheKey];
+      }
+      try {
+        const result = await this.$__client.query({
+          query: "{ __schema { queryType { fields { name } } } }",
+          variables: {}
+        });
+        const data = result?.data;
+        const fields = data?.__schema?.queryType?.fields || [];
+        const supported = fields.some((f3) => f3.name === fieldName);
+        this.$__capabilityCache[cacheKey] = supported;
+        return supported;
+      } catch (err) {
+        this.log("warn", `KnishIOClient::hasQueryField() - Capability probe for '${fieldName}' failed: ${err.message}`);
+        this.$__capabilityCache[cacheKey] = false;
+        return false;
+      }
+    }
+    /**
+     * Queries embedding status for one or more meta instances (DataBraid observability).
+     *
+     * If the connected server does not support the embeddingStatus query,
+     * returns null without throwing an error (graceful degradation).
+     *
+     * Single mode: queryEmbeddingStatus({ metaType: 'product', metaId: 'SKU-001' })
+     * Bulk mode:   queryEmbeddingStatus({ instances: [{ metaType: 'product', metaId: 'SKU-001' }, ...] })
+     *
+     * @returns Response with payload(), or null if the server does not support this query
+     */
+    async queryEmbeddingStatus({
+      metaType = null,
+      metaId = null,
+      instances = null
+    }) {
+      this.log("info", `KnishIOClient::queryEmbeddingStatus() - Checking embedding status for metaType: ${metaType || "(bulk)"}...`);
+      const supported = await this.hasQueryField("embeddingStatus");
+      if (!supported) {
+        this.log("warn", "KnishIOClient::queryEmbeddingStatus() - Server does not support embeddingStatus query. Returning null.");
+        return null;
+      }
+      const query = this.createQuery(QueryEmbeddingStatus);
+      const variables = QueryEmbeddingStatus.createVariables({ metaType, metaId, instances });
+      return this.executeQuery(query, variables);
+    }
     /**
      * Query cascading meta instances for batchId
      */
@@ -34305,6 +34560,7 @@ ${operationTypes.join("\n")}
   exports.QueryBalance = QueryBalance;
   exports.QueryBatch = QueryBatch;
   exports.QueryContinuId = QueryContinuId;
+  exports.QueryEmbeddingStatus = QueryEmbeddingStatus;
   exports.QueryMetaType = QueryMetaType;
   exports.QueryMetaTypeViaAtom = QueryMetaTypeViaAtom;
   exports.QueryWalletBundle = QueryWalletBundle;
@@ -34316,6 +34572,7 @@ ${operationTypes.join("\n")}
   exports.ResponseCreateMeta = ResponseCreateMeta;
   exports.ResponseCreateToken = ResponseCreateToken;
   exports.ResponseCreateWallet = ResponseCreateWallet;
+  exports.ResponseEmbeddingStatus = ResponseEmbeddingStatus;
   exports.ResponseMetaType = ResponseMetaType;
   exports.ResponseMetaTypeViaAtom = ResponseMetaTypeViaAtom;
   exports.ResponsePeering = ResponsePeering;