@ai-matrx/records 0.3.3 → 0.4.1

package/CHANGELOG.md

@@ -1,33 +1,42 @@
 # Changelog — @ai-matrx/records
 
-## 0.3.3
+## 0.4.1
 
-Lets a legitimate competing live-store verification finish instead of treating
-five seconds of advisory-lock contention as a package failure, while retaining
-a hard statement timeout for genuinely abandoned transactions.
+Carries the live Supabase adapter proof through the shared npm publishing lane
+by supplying its existing main-database HTTP URL and publishable-key secrets to
+the verification step.
 
 ### Consumer action
 
-None. This changes only the release-time real-store verification lane.
-
-## 0.3.2
-
-Refreshes the generated store contract to the live 238-door, 32-knob registry
-and serializes the shared record-store release lane with `records-ui`. This
-prevents either package's live verification from observing the other suite's
-temporary store state.
-
-### Consumer action
-
-None. The new door and knob entries are additive generated contract data.
-
-## 0.3.1
-
-The real-store verification lane now takes one transaction-scoped advisory lock before it
-opens the record-store feature knob. Parallel package and UI verification waits its turn
-instead of converting unrelated knob contention into a false store refusal.
-
-**Consumer action:** none.
+None beyond taking `latest`; the 0.4.0 API is unchanged.
+
+## 0.4.0
+
+**The browser can reach the store again — `supabaseDataSource`.** Every screen
+of the record store was dead from a browser, for everybody, and the cause was a
+single silent drop. `RecordsDataSource.rpc(fn, args, { schema })` says the
+schema out loud, because every door is `custom.<name>` and every trust door is
+`iam.<name>`. supabase-js's own `rpc()` has NO schema option — its third
+argument is `{ head, get, count }` — so a host that bound its client as a bare
+structural cast handed the option to a function that dropped it, every door call
+went to PostgREST's default profile, and the store answered, correctly and
+uselessly, `PGRST202 — Could not find the function public.table_kernel_id in the
+schema cache`. Independent verdict, 2026-09-19.
+
+The fix is ONE adapter in the headless core, exported from `/core`, that every
+host inherits — never three hosts (web, desktop, extension) each remembering the
+same thing. It routes through `client.schema(name).rpc(...)`, which is the one
+way supabase-js offers, and it refuses two things by name rather than sending
+them: a call with no schema (which would reach `public`), and a client with no
+`.schema()` method (which would throw inside a render).
+
+**The test that would have caught it**, `src/__tests__/supabase-adapter.test.ts`:
+a real supabase-js client against the MAIN database, signed in as `test@test.com`,
+calling a real door. A raw `fetch` to `/rest/v1/rpc/...` would NOT have caught
+this — the bug is in supabase-js's option handling, so only a real client
+exercises it. The RED half reconstructs the bare cast that shipped and asserts
+the store's own PGRST202 naming `public`; the GREEN half is the same call
+through the adapter answering the kernel id.
 
 ## 0.3.0
 

package/dist/core/index.cjs

@@ -90,6 +90,7 @@ __export(core_exports, {
   predictValueRefusals: () => predictValueRefusals,
   predictWriteRefusals: () => predictWriteRefusals,
   staleWriteDetail: () => staleWriteDetail,
+  supabaseDataSource: () => supabaseDataSource,
   toAoa: () => toAoa
 });
 module.exports = __toCommonJS(core_exports);
@@ -2575,6 +2576,42 @@ function asWriteConflict(error, recordId) {
   };
 }
 
+// src/core/supabase.ts
+function refuse(code, message, hint) {
+  return { data: null, error: { code, message, hint, details: "" } };
+}
+function supabaseDataSource(client) {
+  const supabase = client;
+  const hasSchema = typeof supabase.schema === "function";
+  return {
+    rpc(fn, args, options) {
+      if (!hasSchema) {
+        return Promise.resolve(
+          refuse(
+            "data_source_unbound",
+            `The records client was given something that is not a supabase client: it has no schema() method, so the door ${fn} cannot be called in the schema it lives in.`,
+            "Pass a supabase-js v2 client (createClient(...)) to supabaseDataSource()."
+          )
+        );
+      }
+      const name = options?.schema;
+      if (!name) {
+        return Promise.resolve(
+          refuse(
+            "schema_unsaid",
+            `The door ${fn} was called without saying which schema it lives in. Every door of this store is custom.${fn} and every trust door is iam.${fn}; an unqualified call reaches PostgREST's default profile (public) and is refused there.`,
+            "This is a bug in the caller, not in your data: /core says the schema on every call."
+          )
+        );
+      }
+      return supabase.schema(name).rpc(fn, args);
+    },
+    schema(name) {
+      return supabase.schema(name);
+    }
+  };
+}
+
 // src/core/validation.ts
 var DEFAULT_VALUE_MAX_BYTES = 1e5;
 var DEFAULT_DOCUMENT_MAX_BYTES = 1048576;