chore: import upstream snapshot with attribution

apps/sim/blocks/visibility/context.ts

@@ -0,0 +1,73 @@
+import type { BlockVisibilityState } from '@/lib/core/config/block-visibility'
+import type { BlockConfig } from '@/blocks/types'
+
+/**
+ * Resolver for the per-viewer block-visibility projection, mirroring the
+ * custom-block overlay seam (`@/blocks/custom/overlay`) but deliberately
+ * independent of it: visibility is a discovery concern with its own lifecycle,
+ * and a separate AsyncLocalStorage composes with `withCustomBlockOverlay`
+ * without `store.run` clobbering.
+ *
+ * Two environment-specific resolvers register here:
+ *  - client: module state hydrated from `useBlockVisibility` (see `client.ts`)
+ *  - server: an AsyncLocalStorage scoped per request (see `server-context.ts`)
+ *
+ * This module is isomorphic (no `'use client'`, no `node:` imports) so
+ * `@/blocks/registry` stays importable on both sides. When NO resolver state is
+ * active, `preview` blocks are still hidden ({@link isHiddenUnder} treats a null
+ * state as "nothing revealed") — fail-closed is the default everywhere,
+ * including SSR and server paths outside `withBlockVisibility`.
+ */
+export interface BlockVisibilityResolver {
+  current(): BlockVisibilityState | null
+}
+
+let resolver: BlockVisibilityResolver | null = null
+
+/** Register (or clear with `null`) the active visibility resolver for this environment. */
+export function registerBlockVisibilityResolver(next: BlockVisibilityResolver | null): void {
+  resolver = next
+}
+
+/** The visibility state in scope, or `null` when none (= nothing revealed, nothing disabled). */
+export function overlayVisibility(): BlockVisibilityState | null {
+  return resolver?.current() ?? null
+}
+
+/**
+ * THE single hidden-predicate for block gating — every surface that hides
+ * blocks (registry projection, VFS stamp filter, exposed-integration-tools
+ * filter, `get_blocks_metadata`) calls this; never restate the rule inline.
+ *
+ * A block is hidden when it is an unrevealed `preview` block (fail-closed even
+ * with a null state) or when the kill switch (`disabled`) names it. Static
+ * `hideFromToolbar` is deliberately NOT part of this predicate — callers that
+ * need it check it separately.
+ */
+export function isHiddenUnder(
+  vis: BlockVisibilityState | null,
+  block: Pick<BlockConfig, 'type' | 'preview'>
+): boolean {
+  if (block.preview && !vis?.revealed.has(block.type)) return true
+  if (vis?.disabled.has(block.type)) return true
+  return false
+}
+
+/**
+ * Registry of non-React module-cache resets (e.g. the tool-operations search
+ * index, the integration matcher) fired when the client visibility state
+ * changes. Lives here — not in the `'use client'` module — so plain `lib/`
+ * modules can register at load time on either side of the server boundary.
+ */
+const cacheInvalidators = new Set<() => void>()
+
+/** Register a cache reset to run on visibility changes. Returns an unregister fn. */
+export function registerBlockCacheInvalidator(fn: () => void): () => void {
+  cacheInvalidators.add(fn)
+  return () => cacheInvalidators.delete(fn)
+}
+
+/** Fire every registered cache reset (called by the client hydrate path). */
+export function invalidateBlockCaches(): void {
+  for (const fn of cacheInvalidators) fn()
+}