@oxy.so/core 1.7.1 → 1.7.4

package/dist/types/mixins/OxyServices.auth.d.ts

@@ -391,10 +391,13 @@ export declare function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(B
         /**
          * Whether this process can prove what it is (ADR 0026).
          *
-         * The check and the module that performs it are loaded LAZILY and only on a
-         * Node host. `@oxy.so/core`'s root barrel reaches React Native and Expo, and
-         * `server/workloadIdentity` imports `node:crypto` — a static import here
-         * would pull it into every mobile bundle for a path a phone can never take.
+         * `#workload-identity` (package.json `imports`) selects a client
+         * implementation for native and browser bundlers, and the signer only for
+         * Node hosts. The runtime Node guard avoids calling attestation on clients;
+         * the module boundary keeps node:crypto out of their bundle graphs (a guard
+         * alone cannot). It is a package import, not a self-reference to an export
+         * subpath: a self-reference only resolves where `@oxy.so/core` is reachable
+         * through `node_modules`, which bundlers inside this workspace are not.
          *
          * @internal
          */

package/dist/types/server/workloadIdentity.client.d.ts

@@ -0,0 +1,4 @@
+import type { WorkloadServiceToken, WorkloadServiceTokenOptions } from './workloadIdentity';
+/** Workload attestation belongs to a Node host, never a browser or device. */
+export declare function canAttestWorkloadIdentity(): boolean;
+export declare function requestWorkloadServiceToken(_options: WorkloadServiceTokenOptions): Promise<WorkloadServiceToken>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxy.so/core",
-  "version": "1.7.1",
+  "version": "1.7.4",
   "description": "OxyHQ SDK Foundation — API client, authentication, cryptographic identity, and shared utilities",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -119,7 +119,7 @@
     "@noble/ciphers": "^1.3.0",
     "@noble/hashes": "^1.8.0",
     "@oxy.so/contracts": "^1.3.0",
-    "@oxy.so/protocol": "^1.0.1",
+    "@oxy.so/protocol": "^1.1.0",
     "@scure/bip39": "^1.6.0",
     "buffer": "^6.0.3",
     "express-rate-limit": "^8.6.0",

package/src/mixins/OxyServices.auth.ts

@@ -647,17 +647,20 @@ export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T)
     /**
      * Whether this process can prove what it is (ADR 0026).
      *
-     * The check and the module that performs it are loaded LAZILY and only on a
-     * Node host. `@oxy.so/core`'s root barrel reaches React Native and Expo, and
-     * `server/workloadIdentity` imports `node:crypto` — a static import here
-     * would pull it into every mobile bundle for a path a phone can never take.
+     * `#workload-identity` (package.json `imports`) selects a client
+     * implementation for native and browser bundlers, and the signer only for
+     * Node hosts. The runtime Node guard avoids calling attestation on clients;
+     * the module boundary keeps node:crypto out of their bundle graphs (a guard
+     * alone cannot). It is a package import, not a self-reference to an export
+     * subpath: a self-reference only resolves where `@oxy.so/core` is reachable
+     * through `node_modules`, which bundlers inside this workspace are not.
      *
      * @internal
      */
     async _canUseWorkloadIdentity(): Promise<boolean> {
       if (typeof process === 'undefined' || !process.versions?.node) return false;
       try {
-        const { canAttestWorkloadIdentity } = await import('../server/workloadIdentity');
+        const { canAttestWorkloadIdentity } = await import('#workload-identity');
         return canAttestWorkloadIdentity();
       } catch {
         // A bundler that dropped the server subpath, or a runtime without it.
@@ -684,7 +687,7 @@ export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T)
       if (entry?.token && entry.expiresAt > now + 60_000) return entry.token;
       if (entry?.pending) return entry.pending;
 
-      const { requestWorkloadServiceToken } = await import('../server/workloadIdentity');
+      const { requestWorkloadServiceToken } = await import('#workload-identity');
       const seeded = entry ?? {
         token: '',
         expiresAt: 0,

package/src/server/__tests__/workloadIdentity.client.test.ts

@@ -0,0 +1,16 @@
+import { canAttestWorkloadIdentity, requestWorkloadServiceToken } from '../workloadIdentity.client';
+
+describe('client workload identity boundary', () => {
+  it('cannot attest even when Node process globals are present', () => {
+    expect(process.versions.node).toBeTruthy();
+    expect(canAttestWorkloadIdentity()).toBe(false);
+  });
+
+  it('rejects before contacting a server when explicitly requested', async () => {
+    const fetchSpy = jest.spyOn(globalThis, 'fetch');
+    await expect(requestWorkloadServiceToken({ baseUrl: 'https://example.test' }))
+      .rejects.toThrow('only available on a Node host');
+    expect(fetchSpy).not.toHaveBeenCalled();
+    fetchSpy.mockRestore();
+  });
+});

package/src/server/workloadIdentity.client.ts

@@ -0,0 +1,12 @@
+import type { WorkloadServiceToken, WorkloadServiceTokenOptions } from './workloadIdentity';
+
+/** Workload attestation belongs to a Node host, never a browser or device. */
+export function canAttestWorkloadIdentity(): boolean {
+  return false;
+}
+
+export async function requestWorkloadServiceToken(
+  _options: WorkloadServiceTokenOptions,
+): Promise<WorkloadServiceToken> {
+  throw new Error('Workload identity is only available on a Node host');
+}