@ripplo/testing 0.6.1 → 0.7.0

package/dist/assert.d.ts

@@ -1,188 +0,0 @@
-import { O as ObserverHandle, a as ObserverInput, P as Primitive, b as ObserverBudgetTier } from './types-BzZrl65Z.js';
-import { Variable, StaticStringRef, VariableRef } from './control.js';
-import { U as UnlabeledStep } from './step-De52hTLd.js';
-import { CheckLocator, AnyLocator } from './locators.js';
-import '@ripplo/spec';
-
-type StringOrVariable = string | Variable<string>;
-declare const assert: {
-    not: {
-        checked(locator: CheckLocator): UnlabeledStep<{
-            locator: {
-                by: "testId";
-                value: string;
-            } | {
-                by: "role";
-                role: string;
-                name?: string | undefined;
-            };
-            type: "assertNotChecked";
-        }>;
-        enabled(locator: AnyLocator): UnlabeledStep<{
-            locator: {
-                by: "testId";
-                value: string;
-            } | {
-                by: "role";
-                role: string;
-                name?: string | undefined;
-            };
-            type: "assertDisabled";
-        }>;
-        focused(locator: AnyLocator): UnlabeledStep<{
-            locator: {
-                by: "testId";
-                value: string;
-            } | {
-                by: "role";
-                role: string;
-                name?: string | undefined;
-            };
-            type: "assertNotFocused";
-        }>;
-        visible(locator: AnyLocator): UnlabeledStep<{
-            locator: {
-                by: "testId";
-                value: string;
-            } | {
-                by: "role";
-                role: string;
-                name?: string | undefined;
-            };
-            type: "assertNotVisible";
-        }>;
-    };
-    attribute(locator: AnyLocator, attribute: string, expected: StringOrVariable): UnlabeledStep<{
-        attribute: string;
-        expected: StaticStringRef | VariableRef;
-        locator: {
-            by: "testId";
-            value: string;
-        } | {
-            by: "role";
-            role: string;
-            name?: string | undefined;
-        };
-        operator: "equals";
-        type: "assertAttribute";
-    }>;
-    /**
-     * Verify a backend side effect by polling an observer. The server-side
-     * observer impl returns `ctx.retry(reason)` for transient states (keep
-     * polling) and `ctx.fail(reason)` only for invariant violations (stop
-     * early). The observer's `.budget()` governs poll interval and timeout.
-     */
-    backend<THandle extends ObserverHandle>(observer: THandle, params: ObserverInput<THandle> & Record<string, Primitive>): UnlabeledStep<{
-        budget: ObserverBudgetTier;
-        observer: string;
-        params: Record<string, {
-            readonly type: "static";
-            readonly value: Primitive;
-        }>;
-        type: "assertObserver";
-    }>;
-    checked(locator: CheckLocator): UnlabeledStep<{
-        locator: {
-            by: "testId";
-            value: string;
-        } | {
-            by: "role";
-            role: string;
-            name?: string | undefined;
-        };
-        type: "assertChecked";
-    }>;
-    count(locator: AnyLocator, expected: number): UnlabeledStep<{
-        expected: {
-            type: "static";
-            value: number;
-        };
-        locator: {
-            by: "testId";
-            value: string;
-        } | {
-            by: "role";
-            role: string;
-            name?: string | undefined;
-        };
-        operator: "equals";
-        type: "assertCount";
-    }>;
-    disabled(locator: AnyLocator): UnlabeledStep<{
-        locator: {
-            by: "testId";
-            value: string;
-        } | {
-            by: "role";
-            role: string;
-            name?: string | undefined;
-        };
-        type: "assertDisabled";
-    }>;
-    enabled(locator: AnyLocator): UnlabeledStep<{
-        locator: {
-            by: "testId";
-            value: string;
-        } | {
-            by: "role";
-            role: string;
-            name?: string | undefined;
-        };
-        type: "assertEnabled";
-    }>;
-    focused(locator: AnyLocator): UnlabeledStep<{
-        locator: {
-            by: "testId";
-            value: string;
-        } | {
-            by: "role";
-            role: string;
-            name?: string | undefined;
-        };
-        type: "assertFocused";
-    }>;
-    text(locator: AnyLocator, expected: StringOrVariable): UnlabeledStep<{
-        expected: StaticStringRef | VariableRef;
-        locator: {
-            by: "testId";
-            value: string;
-        } | {
-            by: "role";
-            role: string;
-            name?: string | undefined;
-        };
-        operator: "equals";
-        type: "assertText";
-    }>;
-    url(expected: StringOrVariable): UnlabeledStep<{
-        expected: StaticStringRef | VariableRef;
-        operator: "contains";
-        type: "assertUrl";
-    }>;
-    value(locator: AnyLocator, expected: StringOrVariable): UnlabeledStep<{
-        expected: StaticStringRef | VariableRef;
-        locator: {
-            by: "testId";
-            value: string;
-        } | {
-            by: "role";
-            role: string;
-            name?: string | undefined;
-        };
-        operator: "equals";
-        type: "assertValue";
-    }>;
-    visible(locator: AnyLocator): UnlabeledStep<{
-        locator: {
-            by: "testId";
-            value: string;
-        } | {
-            by: "role";
-            role: string;
-            name?: string | undefined;
-        };
-        type: "assertVisible";
-    }>;
-};
-
-export { assert };

package/dist/assert.js

@@ -1,111 +0,0 @@
-import {
-  readObserverBudget,
-  readObserverName
-} from "./chunk-YQAEOH5W.js";
-import {
-  toSpecLocator,
-  toStringValueRef
-} from "./chunk-2YLI7VD4.js";
-import "./chunk-DCJBLS2U.js";
-import {
-  createStep
-} from "./chunk-MGATMMCZ.js";
-import "./chunk-4MGIQFAJ.js";
-
-// src/steps/assert.ts
-var assert = {
-  not: {
-    checked(locator) {
-      return createStep({ locator: toSpecLocator(locator), type: "assertNotChecked" });
-    },
-    enabled(locator) {
-      return createStep({ locator: toSpecLocator(locator), type: "assertDisabled" });
-    },
-    focused(locator) {
-      return createStep({ locator: toSpecLocator(locator), type: "assertNotFocused" });
-    },
-    visible(locator) {
-      return createStep({ locator: toSpecLocator(locator), type: "assertNotVisible" });
-    }
-  },
-  attribute(locator, attribute, expected) {
-    return createStep({
-      attribute,
-      expected: toStringValueRef(expected),
-      locator: toSpecLocator(locator),
-      operator: "equals",
-      type: "assertAttribute"
-    });
-  },
-  // eslint-disable-next-line no-comments/disallowComments
-  /**
-   * Verify a backend side effect by polling an observer. The server-side
-   * observer impl returns `ctx.retry(reason)` for transient states (keep
-   * polling) and `ctx.fail(reason)` only for invariant violations (stop
-   * early). The observer's `.budget()` governs poll interval and timeout.
-   */
-  backend(observer, params) {
-    return createStep({
-      budget: readObserverBudget(observer),
-      observer: readObserverName(observer),
-      params: paramsToValueRefs(params),
-      type: "assertObserver"
-    });
-  },
-  checked(locator) {
-    return createStep({ locator: toSpecLocator(locator), type: "assertChecked" });
-  },
-  count(locator, expected) {
-    return createStep({
-      expected: { type: "static", value: expected },
-      locator: toSpecLocator(locator),
-      operator: "equals",
-      type: "assertCount"
-    });
-  },
-  disabled(locator) {
-    return createStep({ locator: toSpecLocator(locator), type: "assertDisabled" });
-  },
-  enabled(locator) {
-    return createStep({ locator: toSpecLocator(locator), type: "assertEnabled" });
-  },
-  focused(locator) {
-    return createStep({ locator: toSpecLocator(locator), type: "assertFocused" });
-  },
-  text(locator, expected) {
-    return createStep({
-      expected: toStringValueRef(expected),
-      locator: toSpecLocator(locator),
-      operator: "equals",
-      type: "assertText"
-    });
-  },
-  url(expected) {
-    return createStep({
-      expected: toStringValueRef(expected),
-      operator: "contains",
-      type: "assertUrl"
-    });
-  },
-  value(locator, expected) {
-    return createStep({
-      expected: toStringValueRef(expected),
-      locator: toSpecLocator(locator),
-      operator: "equals",
-      type: "assertValue"
-    });
-  },
-  visible(locator) {
-    return createStep({ locator: toSpecLocator(locator), type: "assertVisible" });
-  }
-};
-function paramsToValueRefs(params) {
-  const out = {};
-  Object.entries(params).forEach(([key, value]) => {
-    out[key] = { type: "static", value };
-  });
-  return out;
-}
-export {
-  assert
-};

package/dist/builder-SsgqYqSC.d.ts

@@ -1,156 +0,0 @@
-import { P as Primitive, O as ObserverHandle, h as Precondition, m as PreconditionData, j as TestDefinition, f as ObserverDefinition, l as PreconditionDefinition, U as UnimplementedItems, e as ObserverContext, g as ObserverOutcome, S as SetupContext, k as TestValue, T as TeardownContext } from './types-BzZrl65Z.js';
-import { ObserverBudget } from '@ripplo/spec';
-import { S as Step } from './step-De52hTLd.js';
-
-interface ObserverNeedsDescription {
-    readonly description: (text: string) => ObserverNeedsBudget;
-}
-interface ObserverNeedsBudget {
-    /**
-     * Polling envelope: interval + total timeout the runner uses when calling
-     * `assert.backend()`. Pick by where the side effect lands — fast for
-     * same-request DB reads, slow for job-queue settle, async for
-     * webhook/email delivery. Too tight = flaky; too loose = slow suite.
-     */
-    readonly budget: (tier: ObserverBudget) => ObserverNeedsInput;
-}
-interface ObserverNeedsInput {
-    readonly input: <TInput extends Record<string, Primitive>>() => ObserverReady<TInput>;
-}
-interface ObserverReady<TInput extends Record<string, Primitive>> {
-    readonly contract: () => ObserverHandle<TInput>;
-}
-
-interface CoverageRegistry {
-}
-type RegistryKeys = keyof CoverageRegistry;
-type CoverageStatementId = [RegistryKeys] extends [never] ? string : Extract<RegistryKeys, string>;
-
-type PreconditionRecord = Record<string, Precondition>;
-type ResolveDeps<TDeps extends PreconditionRecord> = {
-    readonly [K in keyof TDeps]: PreconditionData<TDeps[K]>;
-};
-interface PreconditionNeedsSetup {
-    readonly contract: <TData extends Record<string, Primitive>>() => Precondition<TData>;
-    readonly description: (text: string) => PreconditionNeedsSetup;
-    readonly requires: <TDeps extends PreconditionRecord>(deps: TDeps) => PreconditionNeedsSetupWithDeps<TDeps>;
-}
-interface PreconditionNeedsSetupWithDeps<TDeps extends PreconditionRecord> {
-    readonly contract: <TData extends Record<string, Primitive>>() => Precondition<TData, ResolveDeps<TDeps>>;
-}
-interface TestNeedsName {
-    readonly name: (displayName: string) => TestNeedsRequires;
-}
-interface TestNeedsRequires {
-    readonly description: (text: string) => TestNeedsRequires;
-    /**
-     * Declare the preconditions this test needs. The object keys become the
-     * destructured parameter in `.startsAt` / `.steps`, and each precondition's
-     * return data flows through as a typed proxy — interpolate proxy fields
-     * directly (e.g. `` `/workspaces/${workspace.id}` ``); never hand-write
-     * `{{namespace.key}}` template strings (lint blocks this).
-     */
-    readonly requires: <TReqs extends PreconditionRecord>(reqs: TReqs) => TestNeedsOutcome<ResolveDeps<TReqs>>;
-}
-interface TestNeedsOutcome<TVars extends Record<string, Record<string, Primitive>>> {
-    readonly expectedOutcome: (text: string) => TestNeedsStartsAt<TVars>;
-}
-
-interface TestNeedsStartsAt<TVars extends Record<string, Record<string, Primitive>>> {
-    /**
-     * Skip implementation — compiles as a planning stub and is reported in
-     * `getUnimplemented()`. The test appears in the lockfile but is not run.
-     */
-    readonly notImplemented: () => TestDefinition;
-    /**
-     * Starting URL for the test, derived from precondition data. The function
-     * receives the `.requires()` object destructured as typed proxies; it runs
-     * at compile time, not at test-author time.
-     */
-    readonly startsAt: (fn: (vars: TVars) => string) => TestNeedsSteps<TVars>;
-}
-interface TestNeedsSteps<TVars extends Record<string, Record<string, Primitive>>> {
-    /**
-     * Declare the ordered step list. Receives destructured precondition data as
-     * typed proxies (same as `.startsAt`). Every step must be labeled with
-     * `.as("…")` — lint enforces it.
-     */
-    readonly steps: (fn: (vars: TVars) => ReadonlyArray<Step>) => TestNeedsCoverage;
-}
-interface TestNeedsCoverage {
-    /**
-     * Finalize the test and declare which mutation/AST branches it covers.
-     * Coverage IDs feed LLM-driven test scoping on diffs so only relevant tests
-     * run for a change. `.coverage()` (or `.notImplemented()`) is the only way
-     * to terminate the chain into a runnable `TestDefinition`.
-     */
-    readonly coverage: (...ids: ReadonlyArray<CoverageStatementId>) => TestDefinition;
-}
-
-type PreconditionSetupResult<TData extends Record<string, Primitive>> = {
-    readonly [K in keyof TData]: TestValue<TData[K]>;
-};
-interface PreconditionSetupItem<TDeps extends Record<string, Record<string, Primitive>>> {
-    readonly ctx: SetupContext;
-    readonly deps: TDeps;
-}
-interface PreconditionTeardownItem<TData extends Record<string, Primitive>> {
-    readonly ctx: TeardownContext<TData>;
-}
-interface PreconditionImpl<TData extends Record<string, Primitive>, TDeps extends Record<string, Record<string, Primitive>>> {
-    readonly setup: (items: ReadonlyArray<PreconditionSetupItem<TDeps>>) => Promise<ReadonlyArray<PreconditionSetupResult<TData>>>;
-    readonly teardown: (items: ReadonlyArray<PreconditionTeardownItem<TData>>) => Promise<void>;
-}
-type ObserverImplFn<TInput extends Record<string, Primitive>> = (ctx: ObserverContext, params: TInput) => Promise<ObserverOutcome>;
-interface TestOptions {
-    readonly uiOnly?: boolean;
-}
-type PreconditionRegistry = Record<string, Precondition>;
-type ObserverRegistry = Record<string, ObserverHandle<Record<string, Primitive>>>;
-interface RipploRegistries<P extends PreconditionRegistry, O extends ObserverRegistry> {
-    readonly observers: O;
-    readonly preconditions: P;
-    readonly tests: ReadonlyArray<TestDefinition>;
-}
-interface RipploInstance<P extends PreconditionRegistry = PreconditionRegistry, O extends ObserverRegistry = ObserverRegistry> {
-    readonly observers: O;
-    readonly preconditions: P;
-    readonly tests: ReadonlyArray<TestDefinition>;
-    readonly getObservers: () => ReadonlyArray<ObserverDefinition>;
-    readonly getPreconditions: () => ReadonlyArray<PreconditionDefinition>;
-    readonly getTests: () => ReadonlyArray<TestDefinition>;
-    readonly getUnimplemented: () => UnimplementedItems;
-}
-type RipploBuilder = RipploInstance;
-/**
- * Declare a precondition — a named, reusable piece of test data setup. Returns
- * a pure handle (no side effects at definition time); the setup/teardown impl
- * is wired once in `createEngine`. Depend on other preconditions via
- * `.requires()` so the DAG can resolve independents in parallel, giving every
- * test a clean, isolated slate.
- */
-declare function precondition(name: string): PreconditionNeedsSetup;
-/**
- * Declare a backend assertion — checked from tests via `assert.backend()`.
- * The impl runs on your server (where DB/queue access lives) and is polled
- * until pass/fail; `.budget()` picks the polling envelope. Use this instead
- * of sleeps when verifying async side effects (jobs, webhooks, emails, DB rows).
- */
-declare function observer(name: string): ObserverNeedsDescription;
-/**
- * Start a test definition. `id` is a stable kebab-case key persisted in the
- * lockfile and used for run history — changing it renames the test and loses
- * history. Set `options.uiOnly` only for genuinely read-only flows (no
- * mutations); do not use it to silence observer lint on flows that mutate
- * state — wire the observer instead.
- */
-declare function test(id: string, options?: TestOptions): TestNeedsName;
-/**
- * The single registration point for the DSL graph. Collects the three
- * registries into an instance consumed both by `ripplo compile` (to write
- * `.ripplo/ripplo.lock`) and by `createEngine` on the server, where
- * TypeScript exhaustiveness-checks that every handle has exactly one impl.
- */
-declare function createRipplo<P extends PreconditionRegistry, O extends ObserverRegistry>(registries: RipploRegistries<P, O>): RipploInstance<P, O>;
-
-export { type CoverageRegistry as C, type ObserverImplFn as O, type PreconditionImpl as P, type ResolveDeps as R, type ObserverRegistry as a, type PreconditionRecord as b, type PreconditionRegistry as c, type PreconditionSetupItem as d, type PreconditionTeardownItem as e, type RipploBuilder as f, type RipploInstance as g, type RipploRegistries as h, createRipplo as i, observer as o, precondition as p, test as t };

package/dist/chunk-2YLI7VD4.js

@@ -1,65 +0,0 @@
-import {
-  readLocator
-} from "./chunk-DCJBLS2U.js";
-import {
-  createStep
-} from "./chunk-MGATMMCZ.js";
-
-// src/steps/to-spec-locator.ts
-function toSpecLocator(loc) {
-  const spec = readLocator(loc);
-  switch (spec.by) {
-    case "role": {
-      return { by: "role", name: spec.name, role: spec.role };
-    }
-    case "testId": {
-      return { by: "testId", value: spec.value };
-    }
-  }
-}
-
-// src/steps/control.ts
-function variable(name) {
-  return { name };
-}
-function readVariable(v) {
-  return v.name;
-}
-function isVariable(v) {
-  if (typeof v !== "object" || v == null) {
-    return false;
-  }
-  if (!("name" in v)) {
-    return false;
-  }
-  return typeof v.name === "string";
-}
-function toStringValueRef(value) {
-  if (typeof value === "string") {
-    return { type: "static", value };
-  }
-  if (!isVariable(value)) {
-    const raw = value;
-    const got = raw == null ? String(raw) : typeof raw;
-    throw new TypeError(
-      `Expected a string or variable() \u2014 got ${got}. Wrap dynamic values with variable("name") and pair them with extract().`
-    );
-  }
-  return { name: readVariable(value), type: "variable" };
-}
-function extract(locator, target) {
-  return createStep({
-    locator: toSpecLocator(locator),
-    type: "extractText",
-    variable: readVariable(target)
-  });
-}
-
-export {
-  toSpecLocator,
-  variable,
-  readVariable,
-  isVariable,
-  toStringValueRef,
-  extract
-};

package/dist/chunk-4MGIQFAJ.js

@@ -1,16 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
-
-export {
-  __decorateClass,
-  __decorateParam
-};

package/dist/chunk-DCJBLS2U.js

@@ -1,26 +0,0 @@
-// src/locators.ts
-function readLocator(loc) {
-  return loc.spec;
-}
-function makeLocator(spec) {
-  return { spec };
-}
-function role(ariaRole, name) {
-  return makeLocator({
-    by: "role",
-    name: name ?? void 0,
-    role: ariaRole
-  });
-}
-function testId(id) {
-  return makeLocator({
-    by: "testId",
-    value: id
-  });
-}
-
-export {
-  readLocator,
-  role,
-  testId
-};

package/dist/chunk-MGATMMCZ.js

@@ -1,16 +0,0 @@
-// src/steps/step.ts
-function readStep(step) {
-  return step.data;
-}
-function createStep(node) {
-  return {
-    as(label) {
-      return { data: { label, node } };
-    }
-  };
-}
-
-export {
-  readStep,
-  createStep
-};

package/dist/chunk-XO36IU66.js

@@ -1,88 +0,0 @@
-// src/adapters/shared.ts
-import { Webhook, WebhookVerificationError } from "standardwebhooks";
-import { z } from "zod";
-function readAdapterWebhookSecret() {
-  const value = process.env.RIPPLO_WEBHOOK_SECRET;
-  if (value == null || value.length === 0) {
-    throw new Error(
-      "ripplo: RIPPLO_WEBHOOK_SECRET is not set. The adapter needs it to verify precondition calls. Run `ripplo init` to generate one, or unset `enabled` to disable the adapter."
-    );
-  }
-  return value;
-}
-var primitiveSchema = z.union([z.string(), z.number(), z.boolean()]);
-var dataSchema = z.record(z.string(), z.record(z.string(), primitiveSchema));
-var batchRequestSchema = z.object({
-  batch: z.array(
-    z.object({
-      preconditions: z.array(z.string().min(1)),
-      runId: z.string().min(1)
-    })
-  ).min(1)
-});
-var teardownRequestSchema = z.object({
-  batch: z.array(
-    z.object({
-      data: dataSchema,
-      preconditions: z.array(z.string().min(1)),
-      runId: z.string().min(1)
-    })
-  ).min(1)
-});
-var observerRequestSchema = z.object({
-  observer: z.string().min(1).max(200),
-  params: z.record(z.string().max(200), primitiveSchema)
-});
-function verifyWebhookSignature(payload, headers, secret) {
-  try {
-    const wh = new Webhook(secret);
-    wh.verify(payload, {
-      "webhook-id": headers["webhook-id"] ?? "",
-      "webhook-signature": headers["webhook-signature"] ?? "",
-      "webhook-timestamp": headers["webhook-timestamp"] ?? ""
-    });
-    return true;
-  } catch (error) {
-    if (error instanceof WebhookVerificationError) {
-      return false;
-    }
-    throw error;
-  }
-}
-function serializeCookie(cookie) {
-  return {
-    domain: cookie.options?.domain,
-    expires: cookie.options?.expires,
-    httpOnly: cookie.options?.httpOnly,
-    name: cookie.name,
-    path: cookie.options?.path,
-    sameSite: cookie.options?.sameSite,
-    secure: cookie.options?.secure,
-    value: cookie.value
-  };
-}
-function toBatchRunResults(results) {
-  return results.map(
-    (r) => r.success ? {
-      cookies: r.cookies.map((c) => serializeCookie(c)),
-      data: r.data,
-      executed: [...r.executed],
-      ok: true,
-      runId: r.runId
-    } : { error: r.error ?? "unknown error", ok: false, runId: r.runId }
-  );
-}
-function toTeardownResults(results) {
-  return results.map((r) => ({ error: r.error, ok: r.success, runId: r.runId }));
-}
-
-export {
-  readAdapterWebhookSecret,
-  batchRequestSchema,
-  teardownRequestSchema,
-  observerRequestSchema,
-  verifyWebhookSignature,
-  serializeCookie,
-  toBatchRunResults,
-  toTeardownResults
-};