diff --git a/.changeset/clever-hounds-brake.md b/.changeset/clever-hounds-brake.md
new file mode 100644
index 000000000..a3634467d
--- /dev/null
+++ b/.changeset/clever-hounds-brake.md
@@ -0,0 +1,20 @@
+---
+'@object-ui/console': patch
+---
+
+Console: restore `crypto.randomUUID` on insecure origins so list views stop crashing on LAN IPs
+
+`crypto.randomUUID` is exposed only in secure contexts (HTTPS or
+`http://localhost`). Reaching a dev box over plain HTTP from another machine —
+`http://192.168.x.x:4001/_console/`, the ordinary second-device flow — left the
+method undefined, and every unguarded caller threw
+`TypeError: crypto.randomUUID is not a function`, taking the console's list
+views into the ErrorBoundary.
+
+The console's HTML entry now installs an RFC 4122 v4 fallback built on
+`crypto.getRandomValues` (which is not secure-context-gated, so the entropy
+stays cryptographic). It runs as an inline classic script, synchronously during
+parse, so it precedes every bundled chunk. It is guarded on absence and never
+replaces a native implementation, so secure origins are unaffected; with no
+entropy source available it installs nothing rather than degrading to
+`Math.random`.
diff --git a/apps/console/index.html b/apps/console/index.html
index 9d5037c90..4337b6796 100644
--- a/apps/console/index.html
+++ b/apps/console/index.html
@@ -46,6 +46,78 @@
     <script>
       window.process = window.process || { env: { NODE_ENV: 'development' }, version: '', platform: 'browser' };
     </script>
+    <!--
+      crypto.randomUUID fallback for INSECURE ORIGINS (objectui#4563).
+
+      `crypto.randomUUID` is secure-context-only, so on `http://LAN-IP` — the
+      ordinary way a second device reaches a dev box — the browser omits it and
+      every unguarded caller throws "crypto.randomUUID is not a function",
+      taking the console's list views into the ErrorBoundary. The console's own
+      graph carries unguarded calls in five packages, and the report's stack
+      attributes the throwing frame to a VENDORED chunk this repository does not
+      author, so guaranteeing the platform method is the only fix that reaches
+      every caller. `crypto.getRandomValues` is NOT secure-context-gated, so the
+      entropy stays cryptographic; we only rebuild the RFC 4122 formatting.
+
+      WHY THIS IS AN INLINE CLASSIC SCRIPT, and not a module one.
+      A classic inline script runs SYNCHRONOUSLY, during parse, before any
+      module chunk executes. That is the only bundler-independent guarantee, and
+      it is not theoretical: shipping this as a separate module-type entry
+      placed above the app entry was MEASURED to be too late. Vite merges the
+      two HTML module entries into a single chunk, and the merged entry's static
+      imports are hoisted above the shim's body — 16 chunks, vendor-react,
+      ui-components and RecordDetailView among them, evaluated before the shim
+      installed. Document order between module scripts is real but it is not
+      preserved through bundling, so it cannot carry this guarantee.
+
+      Behaviour, pinned by src/__tests__/insecure-origin-crypto.test.ts, which
+      extracts THIS script text and executes it (so the tests grade exactly what
+      ships, with no second copy to drift): guarded on ABSENCE, so a native
+      implementation is never replaced; and with no entropy source it installs
+      NOTHING rather than degrading to Math.random — an id generator that only
+      looks like crypto is worse than the honest absence. Surfacing that state
+      to the user is objectui#4570, deliberately not this shim's job.
+    -->
+    <script>
+      (function installInsecureOriginRandomUuid() {
+        var cryptoRef = typeof globalThis !== 'undefined' ? globalThis.crypto : undefined;
+        if (!cryptoRef || typeof cryptoRef.getRandomValues !== 'function') return;
+        // Never override a working implementation (a real CSPRNG must win).
+        if (typeof cryptoRef.randomUUID === 'function') return;
+
+        var octets = [];
+        for (var i = 0; i < 256; i++) octets.push((i + 0x100).toString(16).slice(1));
+
+        var randomUUID = function () {
+          var b = new Uint8Array(16);
+          cryptoRef.getRandomValues(b);
+          b[6] = (b[6] & 0x0f) | 0x40; // version 4
+          b[8] = (b[8] & 0x3f) | 0x80; // RFC 4122 variant
+          return (
+            octets[b[0]] + octets[b[1]] + octets[b[2]] + octets[b[3]] + '-' +
+            octets[b[4]] + octets[b[5]] + '-' +
+            octets[b[6]] + octets[b[7]] + '-' +
+            octets[b[8]] + octets[b[9]] + '-' +
+            octets[b[10]] + octets[b[11]] + octets[b[12]] + octets[b[13]] +
+            octets[b[14]] + octets[b[15]]
+          );
+        };
+
+        try {
+          Object.defineProperty(cryptoRef, 'randomUUID', {
+            value: randomUUID,
+            writable: true,
+            configurable: true,
+          });
+        } catch (_defineFailed) {
+          try {
+            cryptoRef.randomUUID = randomUUID;
+          } catch (_assignFailed) {
+            /* Nothing installable here — refuse rather than pretend. */
+          }
+        }
+      })();
+    </script>
   </head>
   <body>
     <div id="root"></div>
diff --git a/apps/console/src/__tests__/insecure-origin-crypto.placement.test.ts b/apps/console/src/__tests__/insecure-origin-crypto.placement.test.ts
new file mode 100644
index 000000000..25d5d62a4
--- /dev/null
+++ b/apps/console/src/__tests__/insecure-origin-crypto.placement.test.ts
@@ -0,0 +1,92 @@
+/**
+ * objectui#4563 — the shim's PLACEMENT is the fix, not just its code.
+ *
+ * A `crypto.randomUUID` fallback that runs after a consumer has already called
+ * the missing method fixes nothing, so what this file defends is ORDER.
+ *
+ * The guarantee relied upon is that a CLASSIC inline script executes
+ * synchronously during parse, before any module script and therefore before any
+ * bundled chunk. The weaker guarantee — document order between two
+ * `type="module"` scripts — was tried first and MEASURED to fail: Vite merges
+ * multiple HTML module entries into one chunk, whose static imports are hoisted
+ * above the merged body, so 16 chunks (`vendor-react`, `ui-components` and
+ * `RecordDetailView` among them) evaluated before the shim installed. Document
+ * order is real in the browser but it does not survive bundling.
+ *
+ * Hence the assertions below: the shim must stay a classic inline script, and
+ * it must stay ahead of every script that carries a `src`.
+ */
+// Read through Vite's `?raw` rather than `node:fs`: this app's tsconfig is
+// browser-only (`lib: ES2020, DOM`, and `types` without `node`), so a
+// `node:fs`/`node:path` import fails `tsc` in the console's build even while
+// the test itself passes under Vitest.
+import html from '../../index.html?raw';
+import { describe, it, expect } from 'vitest';
+
+const SHIM_MARKER = 'installInsecureOriginRandomUuid';
+const APP_ENTRY = '/src/main.tsx';
+
+/**
+ * Every `<script ...>` open tag plus its inline body, in document order.
+ *
+ * HTML comments are stripped FIRST, and that is load-bearing rather than
+ * tidiness: prose describing a script tag reads as a script tag to any regex,
+ * and a comment above this very shim once did exactly that — the parse paired
+ * the comment's opening tag with the shim's closing tag and reported the shim
+ * as a `type="module" src=...` script. (Measured; this test failed that way.)
+ */
+const scripts = [
+  ...html.replace(/<!--[\s\S]*?-->/g, '').matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script>/g),
+].map((match) => ({
+  attrs: match[1] ?? '',
+  body: match[2] ?? '',
+}));
+
+const shimIndex = scripts.findIndex((script) => script.body.includes(SHIM_MARKER));
+const entryIndex = scripts.findIndex((script) => script.attrs.includes(APP_ENTRY));
+
+describe('apps/console/index.html — insecure-origin crypto shim placement', () => {
+  it('is present at all', () => {
+    expect(shimIndex).toBeGreaterThan(-1);
+  });
+
+  it('is a CLASSIC inline script, not a module', () => {
+    // The whole guarantee rests on this: `type="module"` would make it
+    // deferred, and `src=` would make it a bundled chunk. Either turns the
+    // synchronous parse-time install into an install that happens too late.
+    const shim = scripts[shimIndex];
+    expect(shim?.attrs).not.toContain('type="module"');
+    expect(shim?.attrs).not.toContain('src=');
+  });
+
+  it('runs BEFORE the application entry', () => {
+    expect(entryIndex).toBeGreaterThan(-1);
+    expect(shimIndex).toBeLessThan(entryIndex);
+  });
+
+  it('runs before EVERY script that loads external code', () => {
+    // Stronger than the pairwise check: no `src`-carrying script — the entry
+    // today, anything added later — may be scheduled ahead of the shim.
+    scripts.forEach((script, index) => {
+      if (!script.attrs.includes('src=')) return;
+      expect(
+        index,
+        `script #${index} (${script.attrs.trim()}) is scheduled before the #4563 shim`
+      ).toBeGreaterThan(shimIndex);
+    });
+  });
+
+  it('is preceded only by inline classic scripts', () => {
+    // Everything before the shim (early branding, the `window.process`
+    // polyfill) must itself be inline and classic, so nothing can execute
+    // bundled code ahead of the install.
+    for (const script of scripts.slice(0, shimIndex)) {
+      expect(script.attrs).not.toContain('src=');
+      expect(script.attrs).not.toContain('type="module"');
+    }
+  });
+
+  it('keeps the application entry a module script', () => {
+    expect(scripts[entryIndex]?.attrs).toContain('type="module"');
+  });
+});
diff --git a/apps/console/src/__tests__/insecure-origin-crypto.test.ts b/apps/console/src/__tests__/insecure-origin-crypto.test.ts
new file mode 100644
index 000000000..b2e15636a
--- /dev/null
+++ b/apps/console/src/__tests__/insecure-origin-crypto.test.ts
@@ -0,0 +1,249 @@
+/**
+ * objectui#4563 — `crypto.randomUUID` on insecure origins.
+ *
+ * These tests grade THE SHIPPED ARTIFACT. The fix is an inline classic script
+ * in `apps/console/index.html` (it must run during parse, before any module
+ * chunk — see that file's comment for the measurement that ruled out a
+ * `type="module"` shim), so the tests extract that script's text and execute
+ * it. There is deliberately no second copy of the logic in TypeScript: a
+ * testable duplicate that can drift from the one that ships would be graded
+ * green while the real bootstrap rots.
+ *
+ * The red-first cases drive REAL in-repo consumers through
+ * `@object-ui/plugin-view`'s public API — `toFilterGroup` (which reaches
+ * `parseTriplet`'s unguarded `crypto.randomUUID()` on the list-view filter
+ * path, view-config-utils.ts:146) and `toSortItems` (which calls it directly,
+ * :294) — against a crypto object shaped exactly like an insecure origin's,
+ * and pin the resulting message verbatim against the string the report quotes.
+ */
+import indexHtml from '../../index.html?raw';
+import { toFilterGroup, toSortItems } from '@object-ui/plugin-view';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+
+/**
+ * The real entropy source, BOUND once at module load.
+ *
+ * Binding matters: a `(buffer) => globalThis.crypto.getRandomValues(buffer)`
+ * wrapper re-reads the global at call time, so the moment a test stubs
+ * `globalThis.crypto` with an object whose `getRandomValues` IS that wrapper it
+ * recurses into itself until the stack blows. Capturing the native function up
+ * front makes the helper immune to every stub below.
+ */
+const realGetRandomValues = globalThis.crypto.getRandomValues.bind(globalThis.crypto);
+
+/** Canonical RFC 4122 v4, lowercase: version nibble `4`, variant `8|9|a|b`. */
+const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+/**
+ * The shim exactly as it ships: the body of the one inline script in
+ * `index.html` that installs the fallback. Extraction is by the IIFE's name, so
+ * renaming or deleting the script fails here rather than silently testing
+ * nothing.
+ */
+function extractShimSource(html: string = indexHtml): string {
+  // Comments stripped first — prose describing a script tag parses as one.
+  const scripts = [
+    ...html
+      .replace(/<!--[\s\S]*?-->/g, '')
+      .matchAll(/<script(?![^>]*\bsrc=)[^>]*>([\s\S]*?)<\/script>/g),
+  ];
+  const shim = scripts.filter((match) =>
+    match[1]?.includes('installInsecureOriginRandomUuid')
+  );
+  if (shim.length !== 1) {
+    throw new Error(
+      `expected exactly 1 inline shim script in index.html, found ${shim.length}`
+    );
+  }
+  return shim[0]?.[1] ?? '';
+}
+
+/**
+ * Run the shipped shim against whatever `globalThis.crypto` currently is.
+ *
+ * Executing the extracted text is the point: it is the only way to grade the
+ * bootstrap that actually ships, and the input is this repository's own
+ * `index.html`, not anything a user or a request can reach.
+ */
+function runShim(): void {
+  new Function(extractShimSource())();
+}
+
+/** What a browser hands you on `http://LAN-IP`: getRandomValues, no randomUUID. */
+function insecureOriginCrypto(): { getRandomValues: typeof realGetRandomValues; randomUUID?: unknown } {
+  return { getRandomValues: realGetRandomValues };
+}
+
+/** The installed fallback, after running the shim on an insecure-origin crypto. */
+function installedRandomUUID(): () => string {
+  const cryptoLike = insecureOriginCrypto();
+  vi.stubGlobal('crypto', cryptoLike);
+  runShim();
+  expect(typeof cryptoLike.randomUUID).toBe('function');
+  return cryptoLike.randomUUID as () => string;
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe('the shipped shim is findable', () => {
+  it('is exactly one inline script in index.html', () => {
+    const source = extractShimSource();
+    expect(source).toContain('getRandomValues');
+    expect(source).toContain('randomUUID');
+  });
+
+  it('fails loudly if the script is gone rather than passing vacuously', () => {
+    expect(() => extractShimSource('<html></html>')).toThrow(/found 0/);
+  });
+});
+
+describe('the generator', () => {
+  it('renders the canonical 8-4-4-4-12 shape', () => {
+    expect(installedRandomUUID()()).toMatch(UUID_V4);
+  });
+
+  it('forces the version nibble and variant bits regardless of the entropy', () => {
+    // All-ones and all-zeros entropy pin the SIX fixed bits exactly: only the
+    // version nibble (octet 6 high half) and the variant (octet 8 top two bits)
+    // may differ from the raw bytes.
+    const ones = { getRandomValues: (b: Uint8Array<ArrayBuffer>) => b.fill(0xff) };
+    vi.stubGlobal('crypto', ones);
+    runShim();
+    expect((ones as { randomUUID?: () => string }).randomUUID?.()).toBe(
+      'ffffffff-ffff-4fff-bfff-ffffffffffff'
+    );
+
+    const zeros = { getRandomValues: (b: Uint8Array<ArrayBuffer>) => b.fill(0x00) };
+    vi.stubGlobal('crypto', zeros);
+    runShim();
+    expect((zeros as { randomUUID?: () => string }).randomUUID?.()).toBe(
+      '00000000-0000-4000-8000-000000000000'
+    );
+  });
+
+  it('always reports version 4 and the RFC 4122 variant', () => {
+    const randomUUID = installedRandomUUID();
+    for (let i = 0; i < 200; i++) {
+      const uuid = randomUUID();
+      expect(uuid).toMatch(UUID_V4);
+      expect(uuid[14]).toBe('4');
+      expect(['8', '9', 'a', 'b']).toContain(uuid[19]);
+    }
+  });
+
+  it('draws 16 bytes and does not repeat itself across a sample', () => {
+    const widths: number[] = [];
+    const spy = {
+      getRandomValues: (b: Uint8Array<ArrayBuffer>) => {
+        widths.push(b.length);
+        return realGetRandomValues(b);
+      },
+    };
+    vi.stubGlobal('crypto', spy);
+    runShim();
+    const randomUUID = (spy as { randomUUID?: () => string }).randomUUID as () => string;
+
+    const sample = new Set(Array.from({ length: 1000 }, () => randomUUID()));
+    expect(sample.size).toBe(1000);
+    expect(widths).toHaveLength(1000);
+    expect(new Set(widths)).toEqual(new Set([16]));
+  });
+});
+
+describe('the installer', () => {
+  it('installs onto an insecure-origin crypto that lacks randomUUID', () => {
+    const cryptoLike = insecureOriginCrypto();
+    expect('randomUUID' in cryptoLike).toBe(false);
+
+    vi.stubGlobal('crypto', cryptoLike);
+    runShim();
+
+    expect(typeof cryptoLike.randomUUID).toBe('function');
+    expect((cryptoLike.randomUUID as () => string)()).toMatch(UUID_V4);
+  });
+
+  it('MUST NOT touch a native implementation — identity is preserved', () => {
+    const native = (): string => '11111111-2222-4333-8444-555555555555';
+    const cryptoLike = { randomUUID: native, getRandomValues: realGetRandomValues };
+
+    vi.stubGlobal('crypto', cryptoLike);
+    runShim();
+
+    // Identity, not behaviour: the native function object itself is still there.
+    expect(cryptoLike.randomUUID).toBe(native);
+  });
+
+  it('is idempotent — a second run keeps the first fallback', () => {
+    const cryptoLike = insecureOriginCrypto();
+    vi.stubGlobal('crypto', cryptoLike);
+    runShim();
+    const first = cryptoLike.randomUUID;
+
+    runShim();
+
+    expect(cryptoLike.randomUUID).toBe(first);
+  });
+
+  it('refuses to install without an entropy source instead of degrading', () => {
+    // No getRandomValues => no cryptographic randomness available. We do NOT
+    // fall back to Math.random. Surfacing this state to the user is
+    // objectui#4570, deliberately not this shim's job.
+    const cryptoLike: { randomUUID?: unknown } = {};
+    vi.stubGlobal('crypto', cryptoLike);
+
+    expect(() => runShim()).not.toThrow();
+    expect('randomUUID' in cryptoLike).toBe(false);
+  });
+
+  it('does not throw when there is no crypto global at all', () => {
+    vi.stubGlobal('crypto', undefined);
+    expect(() => runShim()).not.toThrow();
+  });
+});
+
+describe('the real consumer path (objectui#4563 repro)', () => {
+  it('throws the card verbatim TypeError with no shim installed', () => {
+    vi.stubGlobal('crypto', insecureOriginCrypto());
+
+    let caught: unknown;
+    try {
+      toFilterGroup(['name', '=', 'x']);
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toBeInstanceOf(TypeError);
+    expect((caught as TypeError).message).toBe('crypto.randomUUID is not a function');
+  });
+
+  it('throws the same TypeError from the sort path with no shim installed', () => {
+    vi.stubGlobal('crypto', insecureOriginCrypto());
+
+    let caught: unknown;
+    try {
+      toSortItems([{ field: 'name', order: 'asc' }]);
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toBeInstanceOf(TypeError);
+    expect((caught as TypeError).message).toBe('crypto.randomUUID is not a function');
+  });
+
+  it('renders the same filter and sort normally once the shim has run', () => {
+    vi.stubGlobal('crypto', insecureOriginCrypto());
+    runShim();
+
+    const group = toFilterGroup(['name', '=', 'x']);
+    expect(group.conditions).toHaveLength(1);
+    expect(group.conditions[0]?.field).toBe('name');
+    expect(group.conditions[0]?.id).toMatch(UUID_V4);
+
+    const sorts = toSortItems([{ field: 'name', order: 'asc' }]);
+    expect(sorts).toHaveLength(1);
+    expect(sorts[0]?.field).toBe('name');
+    expect(sorts[0]?.id).toMatch(UUID_V4);
+  });
+});