@theaiplatform/miniapp-sdk 0.3.2 → 0.4.0

package/dist/surface.d.ts

@@ -4,6 +4,19 @@
  */
 export declare function resolvePackageAssetUrl(context: Pick<TapFederatedSurfaceMountContext, 'packageAssetBaseUrl'>, relativePath: string): URL;
 
+/**
+ * Host-owned entropy for release-scoped identifiers.
+ *
+ * Ordinary TAP surfaces use the browser's cryptographically strong UUID
+ * source. Test Lab mounts derive a deterministic stream from the selected
+ * profile seed and exact frame identity, then reset it before each mount so
+ * app-owned state is reproducible without weakening production identifiers,
+ * colliding across retained remounts, or relying on ambient test globals.
+ */
+export declare interface TapFederatedSurfaceEntropy {
+    randomUUID(): string;
+}
+
 /**
  * Read-only authority projected by TAP for the exact package release/frame.
  * A candidate frame starts without authority and may only perform host-backed
@@ -34,6 +47,7 @@ export declare interface TapFederatedSurfaceMountContext {
     readonly channelId?: string;
     readonly conversationId?: string;
     readonly events: TapPackageEventPublisher;
+    readonly entropy: TapFederatedSurfaceEntropy;
     readonly hostAuthority: TapFederatedSurfaceHostAuthority;
 }
 

package/dist/testing/rstest-config.d.ts

@@ -0,0 +1,38 @@
+import type { RstestConfig } from '@rstest/core';
+
+/**
+ * Define an Rstest suite with TAP's exact, deterministic Test Lab policy.
+ *
+ * User configuration remains composable, but isolation, worker count,
+ * concurrency, retries, environment, and empty-suite behavior fail closed.
+ */
+export declare function defineTapRstestConfig(options?: TapRstestConfigOptions): RstestConfig;
+
+/**
+ * Rstest configuration accepted by TAP's deterministic miniapp runner.
+ *
+ * The literal fields document runner invariants for JavaScript callers while
+ * preventing TypeScript callers from selecting incompatible values.
+ */
+export declare type TapRstestConfigOptions = Omit<RstestConfig, 'include' | 'isolate' | 'maxConcurrency' | 'passWithNoTests' | 'pool' | 'retry' | 'testEnvironment'> & {
+    /** Test files owned by the Test Lab suite. */
+    include?: string[];
+    /** TAP cases share one exact host session and therefore cannot be isolated. */
+    isolate?: false;
+    /** TAP serializes cases against one deterministic fixture realm. */
+    maxConcurrency?: 1;
+    /** An empty Test Lab suite is an error. */
+    passWithNoTests?: false;
+    /** Additional pool options; worker count is fixed at one. */
+    pool?: TapRstestPoolConfig & {
+        maxWorkers?: 1;
+    };
+    /** Assertion retries would hide fixture or lifecycle nondeterminism. */
+    retry?: 0;
+    /** The TAP adapter controls Chromium through a Node runner. */
+    testEnvironment?: 'node';
+};
+
+declare type TapRstestPoolConfig = Exclude<Extract<RstestConfig['pool'], object>, readonly unknown[]>;
+
+export { }

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 };