@theaiplatform/miniapp-sdk 0.3.3 → 0.4.0

package/dist/testing/rstest-config.js

@@ -0,0 +1,59 @@
+const DEFAULT_INCLUDE = Object.freeze([
+    'tests/e2e/**/*.test.ts',
+    'tests/e2e/**/*.test.tsx'
+]);
+const MAX_TEST_TIMEOUT_MS = 600000;
+const LOCKED_CONFIG_ERROR_PREFIX = 'defineTapRstestConfig owns deterministic TAP runner setting';
+function configError(setting, expected) {
+    return new Error(`${LOCKED_CONFIG_ERROR_PREFIX} "${setting}"; use ${expected}.`);
+}
+function assertDataObject(value, label) {
+    if (null === value || 'object' != typeof value || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype) throw new TypeError(`${label} must be a plain object.`);
+    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value)))if (descriptor.get || descriptor.set) throw new TypeError(`${label}.${key} must be a data property.`);
+}
+function assertLockedValue(options, setting, expected, expectedDescription) {
+    const value = options[setting];
+    if (void 0 !== value && value !== expected) throw configError(setting, expectedDescription);
+}
+function validateInclude(value) {
+    if (void 0 === value) return [
+        ...DEFAULT_INCLUDE
+    ];
+    if (!Array.isArray(value) || 0 === value.length) throw new TypeError('defineTapRstestConfig "include" must be a non-empty array of project-relative globs.');
+    return value.map((entry, index)=>{
+        if ('string' != typeof entry || 0 === entry.length || entry.length > 512 || entry.includes('\0') || entry.includes('\\') || entry.startsWith('/') || /^[a-zA-Z]:/u.test(entry) || entry.split('/').includes('..')) throw new TypeError(`defineTapRstestConfig "include[${index}]" must be a bounded, project-relative POSIX glob.`);
+        return entry;
+    });
+}
+function validateTestTimeout(value) {
+    if (void 0 !== value && ('number' != typeof value || !Number.isSafeInteger(value) || value < 1 || value > MAX_TEST_TIMEOUT_MS)) throw new TypeError(`defineTapRstestConfig "testTimeout" must be an integer from 1 through ${MAX_TEST_TIMEOUT_MS} milliseconds.`);
+}
+function defineTapRstestConfig(options = {}) {
+    assertDataObject(options, 'defineTapRstestConfig options');
+    assertLockedValue(options, 'isolate', false, '`isolate: false`');
+    assertLockedValue(options, 'maxConcurrency', 1, '`maxConcurrency: 1`');
+    assertLockedValue(options, 'passWithNoTests', false, '`passWithNoTests: false`');
+    assertLockedValue(options, 'retry', 0, '`retry: 0`');
+    assertLockedValue(options, 'testEnvironment', 'node', '`testEnvironment: "node"`');
+    validateTestTimeout(options.testTimeout);
+    const pool = options.pool;
+    if (void 0 !== pool) {
+        assertDataObject(pool, 'defineTapRstestConfig pool');
+        assertLockedValue(pool, 'maxWorkers', 1, '`pool.maxWorkers: 1`');
+    }
+    return {
+        ...options,
+        include: validateInclude(options.include),
+        isolate: false,
+        maxConcurrency: 1,
+        passWithNoTests: false,
+        pool: {
+            ...pool,
+            maxWorkers: 1
+        },
+        retry: 0,
+        testEnvironment: 'node',
+        testTimeout: options.testTimeout ?? 30000
+    };
+}
+export { defineTapRstestConfig };

package/dist/testing/rstest.d.ts

@@ -10,7 +10,6 @@ import type { PlaywrightFixtures } from '@rstest/playwright';
 import type { PlaywrightTest } from '@rstest/playwright';
 import type { TestContext } from '@rstest/core';
 import type { TestOptions } from '@rstest/core';
-import { z } from 'zod';
 
 export { afterAll }
 
@@ -20,48 +19,313 @@ export { beforeAll }
 
 export declare const beforeEach: TapBeforeEachHook;
 
+declare type DeepReadonly<T> = T extends (...arguments_: never[]) => unknown ? T : T extends readonly (infer Entry)[] ? readonly DeepReadonly<Entry>[] : T extends object ? {
+    readonly [Key in keyof T]: DeepReadonly<T[Key]>;
+} : T;
+
 export { describe }
 
 export { expect }
 
+declare type GeneratedFixtureChannelSeed = GeneratedFixtureSeed['channels'][number];
+
+declare type GeneratedFixtureHttpHeaderInput = MiniappTestFixtureHttpHeaderInput;
+
+declare type GeneratedFixtureHttpRequest = GeneratedFixtureHttpScript['request'];
+
+declare type GeneratedFixtureHttpResponse = GeneratedFixtureHttpScript['response'];
+
+declare type GeneratedFixtureHttpScript = MiniappTestFixtureHttpScript;
+
+declare type GeneratedFixtureHttpScriptState = MiniappTestFixtureHttpScriptState;
+
+declare type GeneratedFixtureLedger = MiniappTestFixtureLedger;
+
+declare type GeneratedFixtureProjectSeed = GeneratedFixtureSeed['projects'][number];
+
+declare type GeneratedFixtureSeed = MiniappTestFixtureSeed;
+
+declare type GeneratedFixtureSnapshot = MiniappTestFixtureSnapshot;
+
+declare type GeneratedLifecycleReceipt = MiniappTestResetFixtureControlReceipt | MiniappTestRemountSurfaceControlReceipt;
+
+/** @capability miniapp-platform */
+/** Private SDK snapshot: keeps the public adapter independent of workspace packages. */
+declare type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+
 declare type MergeContext<ExtraContext, FixturesContext> = {
     [Key in keyof FixturesContext | keyof ExtraContext]: Key extends keyof FixturesContext ? FixturesContext[Key] : Key extends keyof ExtraContext ? ExtraContext[Key] : never;
 };
 
+declare type MiniappTestEmitHostEventControlReceipt = {
+    schemaVersion: 1;
+    requestId: string;
+    runId: string;
+    operation: 'emit-host-event';
+    delivered: number;
+};
+
+declare type MiniappTestFixtureChannelSeed = {
+    roomId: string;
+    title: string;
+    archived?: boolean | undefined;
+    createdAt?: number | undefined;
+    updatedAt?: number | undefined;
+    messages: JsonValue[];
+    specialistIds: string[];
+};
+
+declare type MiniappTestFixtureChannelState = {
+    roomId: string;
+    title: string;
+    archived: boolean;
+    createdAt: number;
+    updatedAt: number;
+    messages: JsonValue[];
+    specialistIds: string[];
+};
+
+declare type MiniappTestFixtureCheckpoint = {
+    installationId: string;
+    releaseId: string;
+    runtimeSlot: string;
+    checkpointReference: string;
+    value: JsonValue;
+};
+
+declare type MiniappTestFixtureHttpCapture = {
+    sequence: number;
+    matched: boolean;
+    request: MiniappTestFixtureHttpRequest;
+    credentialRef?: string | undefined;
+    auth?: 'github' | undefined;
+};
+
+declare type MiniappTestFixtureHttpCaptures = {
+    requests: MiniappTestFixtureHttpCapture[];
+    dropped: number;
+};
+
+declare type MiniappTestFixtureHttpHeader = {
+    name: string;
+    value: string;
+};
+
+declare type MiniappTestFixtureHttpHeaderInput = {
+    name: string;
+    value: string;
+    enabled?: boolean | undefined;
+};
+
+declare type MiniappTestFixtureHttpRequest = {
+    method: string;
+    url: string;
+    query: MiniappTestFixtureHttpHeaderInput[];
+    headers: MiniappTestFixtureHttpHeaderInput[];
+    body?: string | undefined;
+    timeoutMs?: number | undefined;
+    responseBodyLimitBytes?: number | undefined;
+    followRedirects?: boolean | undefined;
+};
+
+declare type MiniappTestFixtureHttpResponse = {
+    finalUrl: string;
+    status: number;
+    statusText: string;
+    headers: MiniappTestFixtureHttpHeader[];
+    bodyText?: string | undefined;
+    bodyBase64?: string | undefined;
+    bodyKind: 'text' | 'binary';
+    bodyTruncated: boolean;
+    sizeBytes: number;
+    elapsedMs: number;
+    contentType?: string | undefined;
+};
+
+declare type MiniappTestFixtureHttpScript = {
+    request: MiniappTestFixtureHttpRequest;
+    credentialRef?: string | undefined;
+    auth?: 'github' | undefined;
+    response: MiniappTestFixtureHttpResponse;
+    repeat?: number | undefined;
+};
+
+declare type MiniappTestFixtureHttpScriptState = {
+    request: MiniappTestFixtureHttpRequest;
+    credentialRef?: string | undefined;
+    auth?: 'github' | undefined;
+    response: MiniappTestFixtureHttpResponse;
+    repeat: number;
+};
+
+declare type MiniappTestFixtureLedger = {
+    entries: MiniappTestFixtureLedgerEntry[];
+    dropped: number;
+};
+
+declare type MiniappTestFixtureLedgerEntry = {
+    sequence: number;
+    fixtureGeneration: number;
+    timestampMs: number;
+    kind: 'event' | 'host-action' | 'native' | 'platform';
+    operation: string;
+    detail: JsonValue;
+};
+
+declare type MiniappTestFixturePresence = {
+    packageId: string;
+    namespace: string;
+    room: string;
+    selfParticipantId: string;
+    participants: MiniappTestFixturePresenceParticipant[];
+};
+
+declare type MiniappTestFixturePresenceParticipant = {
+    participantId: string;
+    displayName: string;
+    state: JsonValue;
+    updatedAtMs: number;
+};
+
+declare type MiniappTestFixtureProjectSeed = {
+    id: string;
+    name: string;
+    discoverable?: boolean | undefined;
+    channelIds: string[];
+    archivedChannelIds: string[];
+};
+
+declare type MiniappTestFixtureProjectState = {
+    id: string;
+    name: string;
+    discoverable: boolean;
+    channelIds: string[];
+    archivedChannelIds: string[];
+};
+
+declare type MiniappTestFixtureSeed = {
+    projects: MiniappTestFixtureProjectSeed[];
+    channels: MiniappTestFixtureChannelSeed[];
+    workflows: MiniappTestFixtureWorkflow[];
+    vfsFiles: MiniappTestFixtureVfsFile[];
+    vfsDirectories: MiniappTestFixtureVfsDirectory[];
+    storage: MiniappTestFixtureStorageEntry[];
+    presence: MiniappTestFixturePresence[];
+    checkpoints: MiniappTestFixtureCheckpoint[];
+    specialists: MiniappTestFixtureSpecialist[];
+    httpScripts: MiniappTestFixtureHttpScript[];
+};
+
+declare type MiniappTestFixtureSnapshot = {
+    schemaVersion: 1;
+    fixtureVersion: string;
+    workspaceId: string;
+    channelId: string;
+    fixtureGeneration: number;
+    fixtureDigest: string;
+    clockTick: number;
+    state: MiniappTestFixtureState;
+};
+
+declare type MiniappTestFixtureSpecialist = {
+    id: string;
+    value: JsonValue;
+};
+
+declare type MiniappTestFixtureState = {
+    projects: MiniappTestFixtureProjectState[];
+    channels: MiniappTestFixtureChannelState[];
+    workflows: MiniappTestFixtureWorkflow[];
+    vfsFiles: MiniappTestFixtureVfsFile[];
+    vfsDirectories: MiniappTestFixtureVfsDirectory[];
+    storage: MiniappTestFixtureStorageEntry[];
+    presence: MiniappTestFixturePresence[];
+    checkpoints: MiniappTestFixtureCheckpoint[];
+    specialists: MiniappTestFixtureSpecialist[];
+    httpScripts: MiniappTestFixtureHttpScriptState[];
+};
+
+declare type MiniappTestFixtureStorageEntry = {
+    workspaceId: string;
+    packageId: string;
+    namespace: string;
+    key: string;
+    revision: number;
+    value: JsonValue;
+};
+
+declare type MiniappTestFixtureVfsDirectory = {
+    conversationId: string;
+    path: string;
+};
+
+declare type MiniappTestFixtureVfsFile = {
+    conversationId: string;
+    path: string;
+    data: number[];
+};
+
+declare type MiniappTestFixtureWorkflow = {
+    workflowId: string;
+    name: string;
+    result: JsonValue;
+    type?: string | undefined;
+    createdAt?: number | undefined;
+    updatedAt?: number | undefined;
+};
+
+declare type MiniappTestRemountSurfaceControlReceipt = {
+    schemaVersion: 1;
+    requestId: string;
+    runId: string;
+    operation: 'remount-surface';
+    mode: 'MINIAPP_TEST_MODE_SURFACE' | 'MINIAPP_TEST_MODE_LIVE_TAP';
+    surfaceGeneration: number;
+    fixtureGeneration?: number | undefined;
+    fixtureDigest?: string | undefined;
+    instanceId: string;
+    documentId: string;
+};
+
+declare type MiniappTestResetFixtureControlReceipt = {
+    schemaVersion: 1;
+    requestId: string;
+    runId: string;
+    operation: 'reset-fixture';
+    mode: 'MINIAPP_TEST_MODE_SURFACE' | 'MINIAPP_TEST_MODE_LIVE_TAP';
+    surfaceGeneration: number;
+    fixtureGeneration?: number | undefined;
+    fixtureDigest?: string | undefined;
+    instanceId: string;
+    documentId: string;
+};
+
+declare type MiniappTestScriptHttpControlReceipt = {
+    schemaVersion: 1;
+    requestId: string;
+    runId: string;
+    operation: 'script-http';
+    fixtureGeneration: number;
+    scriptedRequests: number;
+};
+
+declare type MiniappTestSeedFixtureControlReceipt = {
+    schemaVersion: 1;
+    requestId: string;
+    runId: string;
+    operation: 'seed-fixture';
+    fixtureGeneration: number;
+    fixtureDigest: string;
+    surfaceGeneration: number;
+    instanceId: string;
+    documentId: string;
+};
+
 /** Validate a driver session before any endpoint or provenance field is used. */
 export declare function parseTapMiniappTestSession(value: unknown): TapMiniappTestSession;
 
-declare const sessionSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
-    runId: z.ZodString;
-    workspaceId: z.ZodString;
-    channelId: z.ZodString;
-    packageId: z.ZodString;
-    installationId: z.ZodString;
-    mode: z.ZodEnum<{
-        surface: "surface";
-        "live-tap": "live-tap";
-    }>;
-    dataScope: z.ZodEnum<{
-        fixture: "fixture";
-        "selected-channel": "selected-channel";
-    }>;
-    permissionScenario: z.ZodString;
-    surfaceId: z.ZodString;
-    surfaceSelector: z.ZodString;
-    surfaceAssetOrigin: z.ZodString;
-    pageUrlPrefix: z.ZodString;
-    cdpEndpoint: z.ZodString;
-    cdpAuthorization: z.ZodString;
-    artifactDirectory: z.ZodString;
-    allowedNetworkOrigins: z.ZodArray<z.ZodString>;
-    credentialAliases: z.ZodArray<z.ZodString>;
-    releaseDigest: z.ZodOptional<z.ZodString>;
-    localGeneration: z.ZodOptional<z.ZodNumber>;
-    sourceDigest: z.ZodString;
-    testBundleDigest: z.ZodString;
-}, z.core.$strip>;
-
 declare type TapAfterEachCallback<ExtraContext> = (context: TapHookContext<ExtraContext>) => void | Promise<void>;
 
 declare type TapAfterEachHook<ExtraContext = TapRstestFixtures> = (callback: TapAfterEachCallback<ExtraContext>, timeout?: number) => void;
@@ -70,23 +334,157 @@ declare type TapBeforeEachCallback<ExtraContext> = (context: TapHookContext<Extr
 
 declare type TapBeforeEachHook<ExtraContext = TapRstestFixtures> = (callback: TapBeforeEachCallback<ExtraContext>, timeout?: number) => void;
 
-declare type TapHookContext<ExtraContext> = TestContext & ExtraContext;
+declare type TapHookContext<ExtraContext> = TestContext & {
+    [Key in keyof TapRstestFixtures]: Key extends keyof ExtraContext ? ExtraContext[Key] : TapRstestFixtures[Key];
+} & Partial<Omit<ExtraContext, keyof TapRstestFixtures>>;
 
 export declare type TapMiniappTestControl = {
-    /** Restore the run's declared fixture and permission scenario. */
-    reset: () => Promise<void>;
-    /** Ask the TAP host to emit one versioned platform event through the normal frame bridge. */
-    emitHostEvent: (event: string, payload?: unknown) => Promise<void>;
+    /** Restore the declared fixture and permission scenario in Surface mode. */
+    reset: () => Promise<TapMiniappTestLifecycleReceipt>;
+    /** Remount the surface and await its exact ready handshake. */
+    remountSurface: () => Promise<TapMiniappTestLifecycleReceipt>;
+    /**
+     * Ask the TAP host to emit one versioned platform event through the normal
+     * frame bridge. Payloads must be canonical JSON no larger than 60 KiB.
+     */
+    emitHostEvent: (event: string, payload?: unknown) => Promise<TapMiniappTestEventReceipt>;
 };
 
-export declare type TapMiniappTestFixture = Readonly<Pick<TapMiniappTestSession, 'channelId' | 'dataScope' | 'installationId' | 'localGeneration' | 'mode' | 'packageId' | 'permissionScenario' | 'releaseDigest' | 'runId' | 'sourceDigest' | 'surfaceId' | 'surfaceAssetOrigin' | 'testBundleDigest' | 'workspaceId'> & {
+export declare type TapMiniappTestEventReceipt = TapMiniappTestEventReceipt_2;
+
+declare type TapMiniappTestEventReceipt_2 = DeepReadonly<MiniappTestEmitHostEventControlReceipt>;
+
+export declare type TapMiniappTestFixture = Readonly<Pick<TapMiniappTestSession, 'channelId' | 'dataScope' | 'descriptorDigest' | 'environment' | 'artifacts' | 'adapterVersion' | 'fixtureDigest' | 'hostContractVersion' | 'hostVersion' | 'installationId' | 'localGeneration' | 'matrixEntryId' | 'mode' | 'packageId' | 'permissionScenario' | 'policyDigest' | 'profileId' | 'releaseDigest' | 'runnerName' | 'runnerVersion' | 'runId' | 'seed' | 'sourceDigest' | 'surfaceId' | 'surfaceAssetOrigin' | 'testBundleDigest' | 'target' | 'workspaceId'> & {
     /** Origins authorized for host-mediated SDK HTTP, not browser-wide egress. */
     readonly allowedNetworkOrigins: readonly string[];
     readonly credentialAliases: readonly string[];
+    fixture: TapMiniappTestFixtureApi;
     control: TapMiniappTestControl;
 }>;
 
-export declare type TapMiniappTestSession = z.infer<typeof sessionSchema>;
+export declare type TapMiniappTestFixtureApi = Readonly<{
+    /** Public fixture-control contract version. */
+    schemaVersion: 1;
+    /** Restore the declared fixture and remount an exact ready Surface. */
+    reset: () => Promise<TapMiniappTestLifecycleReceipt>;
+    /** Replace all deterministic fixture realms with this strict JSON seed. */
+    seed: (seed: TapMiniappTestFixtureSeed) => Promise<TapMiniappTestFixtureSeedReceipt>;
+    /** Read a deterministic snapshot of every fixture realm. */
+    snapshot: () => Promise<TapMiniappTestFixtureSnapshot>;
+    /** Exact host-mediated SDK HTTP scripting and request capture. */
+    http: Readonly<{
+        script: (script: TapMiniappTestFixtureHttpScript) => Promise<TapMiniappTestFixtureScriptReceipt>;
+        requests: () => Promise<TapMiniappTestFixtureHttpCaptures>;
+    }>;
+    /** Ordered host-action, native, platform, and event evidence. */
+    ledger: Readonly<{
+        read: () => Promise<TapMiniappTestFixtureLedger>;
+    }>;
+}>;
+
+declare type TapMiniappTestFixtureChannelSeed = DeepReadonly<Omit<GeneratedFixtureChannelSeed, 'messages' | 'specialistIds'> & {
+    messages?: readonly GeneratedFixtureChannelSeed['messages'][number][];
+    specialistIds?: readonly string[];
+}>;
+
+export declare type TapMiniappTestFixtureHttpBodyKind = TapMiniappTestFixtureHttpBodyKind_2;
+
+declare type TapMiniappTestFixtureHttpBodyKind_2 = GeneratedFixtureHttpResponse['bodyKind'];
+
+export declare type TapMiniappTestFixtureHttpCaptures = TapMiniappTestFixtureHttpCaptures_2;
+
+declare type TapMiniappTestFixtureHttpCaptures_2 = DeepReadonly<MiniappTestFixtureHttpCaptures>;
+
+export declare type TapMiniappTestFixtureHttpHeaderInput = TapMiniappTestFixtureHttpHeaderInput_2;
+
+declare type TapMiniappTestFixtureHttpHeaderInput_2 = Omit<GeneratedFixtureHttpHeaderInput, 'enabled'> & {
+    enabled?: boolean | null;
+};
+
+export declare type TapMiniappTestFixtureHttpRequest = TapMiniappTestFixtureHttpRequest_2;
+
+declare type TapMiniappTestFixtureHttpRequest_2 = Omit<GeneratedFixtureHttpRequest, 'body' | 'followRedirects' | 'headers' | 'query' | 'responseBodyLimitBytes' | 'timeoutMs'> & {
+    query?: readonly TapMiniappTestFixtureHttpHeaderInput_2[];
+    headers?: readonly TapMiniappTestFixtureHttpHeaderInput_2[];
+    body?: string | null;
+    timeoutMs?: number | null;
+    responseBodyLimitBytes?: number | null;
+    followRedirects?: boolean | null;
+};
+
+export declare type TapMiniappTestFixtureHttpResponse = TapMiniappTestFixtureHttpResponse_2;
+
+declare type TapMiniappTestFixtureHttpResponse_2 = Omit<GeneratedFixtureHttpResponse, 'bodyBase64' | 'bodyKind' | 'bodyText' | 'contentType'> & {
+    bodyText: string | null;
+    bodyBase64: string | null;
+    bodyKind: TapMiniappTestFixtureHttpBodyKind_2;
+    contentType: string | null;
+};
+
+export declare type TapMiniappTestFixtureHttpScript = TapMiniappTestFixtureHttpScript_2;
+
+declare type TapMiniappTestFixtureHttpScript_2 = DeepReadonly<Omit<GeneratedFixtureHttpScript, 'request' | 'response'> & {
+    request: TapMiniappTestFixtureHttpRequest_2;
+    response: TapMiniappTestFixtureHttpResponse_2;
+}>;
+
+export declare type TapMiniappTestFixtureHttpScriptState = TapMiniappTestFixtureHttpScriptState_2;
+
+declare type TapMiniappTestFixtureHttpScriptState_2 = DeepReadonly<Omit<GeneratedFixtureHttpScriptState, 'request' | 'response'> & {
+    request: TapMiniappTestFixtureHttpRequest_2;
+    response: TapMiniappTestFixtureHttpResponse_2;
+}>;
+
+export declare type TapMiniappTestFixtureLedger = TapMiniappTestFixtureLedger_2;
+
+declare type TapMiniappTestFixtureLedger_2 = DeepReadonly<Omit<GeneratedFixtureLedger, 'entries'> & {
+    entries: readonly (Omit<GeneratedFixtureLedger['entries'][number], 'kind'> & {
+        kind: TapMiniappTestFixtureLedgerKind_2;
+    })[];
+}>;
+
+export declare type TapMiniappTestFixtureLedgerKind = TapMiniappTestFixtureLedgerKind_2;
+
+declare type TapMiniappTestFixtureLedgerKind_2 = GeneratedFixtureLedger['entries'][number]['kind'];
+
+declare type TapMiniappTestFixtureProjectSeed = DeepReadonly<Omit<GeneratedFixtureProjectSeed, 'archivedChannelIds' | 'channelIds'> & {
+    channelIds?: readonly string[];
+    archivedChannelIds?: readonly string[];
+}>;
+
+export declare type TapMiniappTestFixtureScriptReceipt = TapMiniappTestFixtureScriptReceipt_2;
+
+declare type TapMiniappTestFixtureScriptReceipt_2 = DeepReadonly<MiniappTestScriptHttpControlReceipt>;
+
+export declare type TapMiniappTestFixtureSeed = TapMiniappTestFixtureSeed_2;
+
+declare type TapMiniappTestFixtureSeed_2 = DeepReadonly<Partial<Omit<GeneratedFixtureSeed, 'channels' | 'httpScripts' | 'projects'>> & {
+    projects?: readonly TapMiniappTestFixtureProjectSeed[];
+    channels?: readonly TapMiniappTestFixtureChannelSeed[];
+    httpScripts?: readonly TapMiniappTestFixtureHttpScript_2[];
+}>;
+
+export declare type TapMiniappTestFixtureSeedReceipt = TapMiniappTestFixtureSeedReceipt_2;
+
+declare type TapMiniappTestFixtureSeedReceipt_2 = DeepReadonly<MiniappTestSeedFixtureControlReceipt>;
+
+export declare type TapMiniappTestFixtureSnapshot = TapMiniappTestFixtureSnapshot_2;
+
+declare type TapMiniappTestFixtureSnapshot_2 = DeepReadonly<Omit<GeneratedFixtureSnapshot, 'state'> & {
+    state: Omit<GeneratedFixtureSnapshot['state'], 'httpScripts'> & {
+        httpScripts: readonly TapMiniappTestFixtureHttpScriptState_2[];
+    };
+}>;
+
+export declare type TapMiniappTestLifecycleReceipt = TapMiniappTestLifecycleReceipt_2;
+
+declare type TapMiniappTestLifecycleReceipt_2 = DeepReadonly<Omit<GeneratedLifecycleReceipt, 'fixtureDigest' | 'fixtureGeneration' | 'mode'> & {
+    mode: 'live-tap' | 'surface';
+    fixtureGeneration: number | null;
+    fixtureDigest: string | null;
+}>;
+
+export declare type TapMiniappTestSession = ValidatedTapMiniappTestSession;
 
 export declare type TapRstestFixtures = {
     browser: Browser;
@@ -99,13 +497,15 @@ export declare type TapRstestFixtures = {
 };
 
 declare type TapRstestTest<ExtraContext = TapRstestFixtures> = Omit<PlaywrightTest<ExtraContext>, 'afterEach' | 'beforeEach' | 'extend'> & {
-    (description: string, callback?: (context: TapHookContext<ExtraContext>) => void | Promise<void>, timeout?: number): void;
-    (description: string, options: TestOptions, callback?: (context: TapHookContext<ExtraContext>) => void | Promise<void>): void;
+    (description: string, callback?: (context: TapTestCallbackContext<ExtraContext>) => void | Promise<void>, timeout?: number): void;
+    (description: string, options: TestOptions, callback?: (context: TapTestCallbackContext<ExtraContext>) => void | Promise<void>): void;
     afterEach: TapAfterEachHook<ExtraContext>;
     beforeEach: TapBeforeEachHook<ExtraContext>;
     extend: <FixturesContext extends Record<string, unknown> = Record<never, never>>(fixtures: PlaywrightFixtures<FixturesContext, ExtraContext>) => TapRstestTest<MergeContext<ExtraContext, FixturesContext>>;
 };
 
+declare type TapTestCallbackContext<ExtraContext> = TestContext & ExtraContext;
+
 /** Rstest's per-test context plus TAP's authorized browser and run fixtures. */
 export declare type TapTestContext = TestContext & TapRstestFixtures;
 
@@ -116,4 +516,76 @@ export declare type TapTestContext = TestContext & TapRstestFixtures;
  */
 export declare const test: TapRstestTest;
 
+declare type ValidatedTapMiniappTestSession = Readonly<{
+    protocolMajor: number;
+    protocolMinor: number;
+    features: readonly string[];
+    runId: string;
+    runNonce: string;
+    expiresAt: string;
+    workspaceId: string;
+    channelId: string;
+    packageId: string;
+    installationId: string;
+    bindingId: string;
+    releaseDigest?: string;
+    localGeneration?: number;
+    matrixEntryId: string;
+    profileId: string;
+    target: string;
+    /** @deprecated Use `target`. */
+    matrixTarget: string;
+    mode: 'surface' | 'live-tap';
+    presentation: 'headless' | 'visible';
+    dataScope: 'fixture' | 'selected-channel';
+    selectedChannelId?: string;
+    permissionScenario: string;
+    fixtureVersion?: string;
+    seed: number;
+    environment: Readonly<{
+        viewport: Readonly<{
+            width: number;
+            height: number;
+        }>;
+        locale: string;
+        timezone: string;
+        theme: 'dark' | 'light';
+        reducedMotion: boolean;
+        seed: number;
+        fixedNow?: string;
+    }>;
+    artifacts: Readonly<{
+        trace: 'always' | 'failure-only' | 'off';
+        screenshots: 'always' | 'failure-only' | 'off';
+        maxBytes?: number;
+    }>;
+    sourceDigest: string;
+    testBundleDigest: string;
+    descriptorDigest: string;
+    fixtureDigest?: string;
+    policyDigest: string;
+    adapterVersion: string;
+    hostVersion: string;
+    hostContractVersion: string;
+    runnerName: 'rstest';
+    runnerVersion: string;
+    nodeVersion: string;
+    playwrightVersion: string;
+    browserEngine: string;
+    browserVersion: string;
+    targetId: string;
+    browserContextId?: string;
+    targetType: 'page';
+    pageUrl: string;
+    surfaceId: string;
+    surfaceSelector: string;
+    surfaceAssetOrigin: string;
+    cdpEndpoint: string;
+    cdpAuthorization: string;
+    artifactDirectory: string;
+    allowedNetworkOrigins: readonly string[];
+    effectGrants: readonly string[];
+    credentialAliases: readonly string[];
+}>;
+
 export { }