@playfast/reform-proof 1.0.1 → 1.1.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@playfast/reform-proof",
   "playbook": "./playbook",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "type": "module",
   "description": "Headless testing toolkit for reform — drive a scene's compositions and assert on the props they compute, with no DOM, timers, or text matching.",
   "keywords": [

package/src/assertions.ts

@@ -0,0 +1,65 @@
+import { Array as Arr, Effect, Option, Record as Rec } from 'effect'
+import { AssertionFailed } from './errors'
+
+interface ComparePair {
+  readonly left: unknown
+  readonly right: unknown
+}
+
+// oxlint-disable-next-line reform-rules/no-json-parse-stringify -- arbitrary unknown assertion values, not Schema-typed data
+const show = (subject: unknown): string => JSON.stringify(subject)
+
+const deepEqual = ({ left, right }: ComparePair): boolean =>
+  Object.is(left, right) || show(left) === show(right)
+
+const fail = (message: string): Effect.Effect<never> =>
+  Effect.dieMessage(new AssertionFailed({ detail: message }).message)
+
+export const expect = <A>(actual: A) => ({
+  toBe: (expected: A): Effect.Effect<void> =>
+    Object.is(actual, expected)
+      ? Effect.void
+      : fail(`expected ${show(actual)} to be ${show(expected)}`),
+  toEqual: (expected: A): Effect.Effect<void> =>
+    deepEqual({ left: actual, right: expected })
+      ? Effect.void
+      : fail(`expected ${show(actual)} to equal ${show(expected)}`),
+  toContain: (expected: A extends ReadonlyArray<infer E> ? E : unknown): Effect.Effect<void> =>
+    Array.isArray(actual) && actual.some((element) => deepEqual({ left: element, right: expected }))
+      ? Effect.void
+      : fail(`expected ${show(actual)} to contain ${show(expected)}`),
+  toMatchObject: (expected: Partial<A>): Effect.Effect<void> => {
+    const mismatch = matchPartial({ actual, expected })
+    return mismatch === undefined ? Effect.void : fail(mismatch)
+  },
+})
+
+const isRecord = (candidate: unknown): candidate is Record<string, unknown> =>
+  typeof candidate === 'object' && candidate !== null
+
+interface MatchInput {
+  readonly actual: unknown
+  readonly expected: unknown
+}
+
+const matchPartial = ({ actual, expected }: MatchInput): string | undefined => {
+  if (!isRecord(expected)) {
+    return deepEqual({ left: actual, right: expected })
+      ? undefined
+      : `expected ${show(actual)} to match ${show(expected)}`
+  }
+  if (!isRecord(actual)) {
+    return `expected ${show(actual)} to be an object matching ${show(expected)}`
+  }
+  const mismatch = Arr.findFirst(
+    Rec.keys(expected),
+    (key) => !deepEqual({ left: actual[key], right: expected[key] }),
+  )
+  return Option.match(mismatch, {
+    onNone: () => undefined,
+    onSome: (key) =>
+      `expected key ${show(key)} to match ${show(expected[key])}, got ${show(actual[key])}`,
+  })
+}
+
+export const matchProps: (input: MatchInput) => string | undefined = matchPartial

package/src/driverTypes.ts

@@ -0,0 +1,19 @@
+import type { UiCapture } from '@playfast/reform'
+
+export interface StepFrame {
+  readonly index: number
+  readonly captures: ReadonlyArray<UiCapture>
+}
+
+export interface DriveResult {
+  readonly requirement: string
+  readonly frames: ReadonlyArray<StepFrame>
+  readonly ok: boolean
+  // oxlint-disable-next-line reform-rules/no-optional-fields -- serialized result DTO read as `error ?? …` by the editor timeline (external); optional kept for wire compat
+  readonly error?: string
+}
+
+export interface ProofDriver {
+  readonly requirement: string
+  readonly run: () => Promise<DriveResult>
+}