Examiner verified API

Complete reference for the deep-inspection and state-tracking engine.

Core Inspection

Intelligent Dispatching

The Examiner automatically handles "noise" by batching identical reports that occur within a 0.1s window.

-- If 50 parts call this at once, only ONE report prints with a (x50) badge.
Examiner.Dispatch(myReport)

Snapshots & Diffing

Examine Context (Ctx Object)

Returned as the second value from Examine().

Informer Class

Require Watchers (Manual Instrumentation)

Reactive Tools

World & Logic Safety

Advanced Tools

TableDeepEqual

Performs a deep equality check between two tables, recursively comparing all nested values.

NilProtection

Toggles nil protection mode, which returns dummy objects instead of failing on nil access.

PermissionGuard

Enables checks for RBXScriptSecurity restricted properties to prevent crashes.

LintingEnforcer

Verifies that function arguments match intended Luau types when enabled.

MetatableLock

Alerts if a script's metatable has been modified at runtime when purity check is enabled.

CatchOrRetry

Runs a function with automatic retries on failure, snapshots state, and dispatches fatal reports when retry limit is exceeded.

SucceedUntil

Continuously runs a function while a condition remains true, catching state and dispatching diagnostics when the condition fails.

SearchFor

Searches a scope for instances matching a query, with optional auto-sanitization of illegal objects.

ValidateMetatable

Validates an object's metatable against a template, catching any drift or unauthorized modifications.

Sync

Maintains synchronization between two tables, catching and reporting sync errors.

Expect

Performs runtime type checking on values, dispatching errors for type mismatches.

TraceAttribute

Monitors Roblox instance attributes for changes, enforcing strict value patterns.

ExpectReturn

Wraps a function to validate its return type, dispatching errors for mismatches.

InterceptNil

Wraps a table or instance to return a fallback value on nil access, preventing crashes.

Gate

Logic bouncer that runs a function only if a condition is met, with else handling.

MemoizeWithVerify

Caches function results for performance but verifies periodically for data drift.

PollUntil

Runs a function repeatedly until a condition is met or timeout occurs.

ValidateMetatable

Checks for metatable shadowing where table keys override metatable entries.

Match

Pattern matching system with catch-all handler for resilient logic.

Modify

Fluent state editor that applies changes only if all checks pass.

WaitUntil

Smart wait with timeout, snapshot on failure, and promise-like chaining.

ObserveReturn

Wraps functions to log their return values for debugging and history.

WaitAndCompare

Waits for a specific value to match an expected state.

ModifyProperty

Safely sets Roblox instance properties with error handling.

Limit

Sets guardrails on tables or instances. Intercepts assignments and caps values at min/max, dispatches warnings, and takes snapshots on violations.

Extend

Allows registration of custom debug logic into Examiner, automatically inheriting reporting and snapshotting capabilities.

Throttle

Limits how many times a function can be called per second. Blocks excess calls, dispatches warnings, and snapshots the calling context.

SchemaAttribute

Reads Roblox Attributes for type definitions (e.g., TypeAnnotation="Number") and enforces them on attribute changes, reverting invalid types.

MustReturn

Wraps a function to ensure it returns within a timeout. Catches infinite loops or stuck waits, dispatches errors, and snapshots arguments.

Example: Usage Pattern

local Examiner = require(path.to.Examiner)

-- Track state over time
local snapshotId = Examiner.Snapshot(playerData)

-- Later, check for mutations
local report, ctx = Examiner.Examine(playerData, nil, { snapshotId = snapshotId })
print(report)

-- Export to external monitoring
local payload = ctx:toJSON()