humanish 0.15.0 → 0.15.2

package/dist/scripted-browser-actor.d.ts

@@ -1,4 +1,5 @@
 import { type ActorCompletionReason, type ActorPersonaRef, type ActorStatus, type ActorTrace } from "./actor-contract.js";
+import { type PreparedOutputDirectory } from "./selected-output-paths.js";
 export interface ScriptedLocatorLike {
     first(): ScriptedLocatorLike;
     fill(value: string, options?: {
@@ -137,7 +138,7 @@ export interface BrowserPersonaJourney {
 }
 export declare const browserSurfaces: BrowserSurface[];
 export declare function captureBrowserSurface(args: {
-    absoluteArtifactRoot: string;
+    absoluteArtifactRoot: PreparedOutputDirectory;
     appUrl: string;
     browserCommand: string;
     browserJourney: BrowserPersonaJourney;
@@ -145,7 +146,7 @@ export declare function captureBrowserSurface(args: {
     timeoutMs: number;
 }): Promise<BrowserSurfaceCapture>;
 export declare function captureBrowserSurfaceFixture(args: {
-    absoluteArtifactRoot: string;
+    absoluteArtifactRoot: PreparedOutputDirectory;
     appUrl: string;
     browserCommand: string;
     browserJourney: BrowserPersonaJourney;
@@ -153,7 +154,7 @@ export declare function captureBrowserSurfaceFixture(args: {
     timeoutMs: number;
 }): Promise<BrowserSurfaceCapture>;
 export declare function captureBrowserSurfaceWithPlaywright(args: {
-    absoluteArtifactRoot: string;
+    absoluteArtifactRoot: PreparedOutputDirectory;
     appUrl: string;
     browserCommand: string;
     browserJourney: BrowserPersonaJourney;
@@ -161,7 +162,7 @@ export declare function captureBrowserSurfaceWithPlaywright(args: {
     timeoutMs: number;
 }): Promise<BrowserSurfaceCapture>;
 export declare function executeBrowserPersonaStep(args: {
-    absoluteArtifactRoot: string;
+    absoluteArtifactRoot: PreparedOutputDirectory;
     appUrl: string;
     browserJourney: BrowserPersonaJourney;
     page: ScriptedPageLike;
@@ -292,3 +293,5 @@ export interface ScriptedBrowserSessionResult {
  *   approvals exist on a deterministic replay) — asserted in tests.
  */
 export declare function runScriptedBrowserSession(options: ScriptedBrowserSessionOptions): Promise<ScriptedBrowserSessionResult>;
+/** Internal lab seam: the run root is already prepared and must stay bound to that identity. */
+export declare function runScriptedBrowserSessionInPreparedRoot(options: ScriptedBrowserSessionOptions, preparedArtifactRoot: PreparedOutputDirectory): Promise<ScriptedBrowserSessionResult>;

package/dist/scripted-browser-actor.js

@@ -18,13 +18,15 @@
 // importable from this code path. tokenUsage on every projected trace records zeros as an
 // affirmative $0 declaration that is TRUE by mechanism.
 import { execFile, spawn } from "node:child_process";
-import { mkdir, mkdtemp, rm, stat, writeFile } from "node:fs/promises";
+import { mkdtemp, rm, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
 import { ACTOR_TRACE_SCHEMA, SCRIPTED_BROWSER_CAPABILITIES } from "./actor-contract.js";
 import { CHROMIUM_EVIDENCE_HYGIENE_FLAGS } from "./browser-evidence-hygiene.js";
+import { assertScreenshotEvidence } from "./image-evidence.js";
 import { digestText, redactText, redactToSecretLabel } from "./redaction.js";
+import { assertPreparedSelectedOutputDirectory, assertSafeOutputPathSegment, prepareContainedOutputDirectory, prepareContainedOutputFile, prepareSelectedOutputDirectory, readContainedRegularFile, writeContainedOutputFile } from "./selected-output-paths.js";
 const execFileAsync = promisify(execFile);
 const LOOPBACK_EVIDENCE_URL_POLICY = { kind: "loopback" };
 /** Production default: lazy playwright-core import + chromium.launch, exactly as the driver
@@ -80,7 +82,7 @@ export async function captureBrowserSurface(args) {
 export async function captureBrowserSurfaceFixture(args) {
     const started = Date.now();
     const tracePath = path.join("traces", `${args.surface.id}.json`);
-    const absoluteTracePath = path.join(args.absoluteArtifactRoot, tracePath);
+    await assertScriptedOutputRoot(args.absoluteArtifactRoot);
     const httpProbe = await probeAppUrl(args.appUrl, Math.min(args.timeoutMs, 15_000));
     const capturedAt = new Date().toISOString();
     const profileDir = await mkdtemp(path.join(os.tmpdir(), "humanish-browser-profile-"));
@@ -93,18 +95,16 @@ export async function captureBrowserSurfaceFixture(args) {
             }
             const stepStarted = Date.now();
             const screenshotPath = screenshotPathForBrowserStep(args.surface, step);
-            const absoluteScreenshotPath = path.join(args.absoluteArtifactRoot, screenshotPath);
-            await captureScreenshotWithBrowser({
-                args: browserScreenshotArgs({
-                    appUrl: currentUrl,
-                    profileDir,
-                    screenshotPath: absoluteScreenshotPath,
-                    surface: args.surface
-                }),
+            await prepareContainedOutputFile(args.absoluteArtifactRoot, screenshotPath);
+            const screenshotBytes = await captureBrowserCommandScreenshot({
+                appUrl: currentUrl,
                 browserCommand: args.browserCommand,
-                screenshotPath: absoluteScreenshotPath,
+                profileDir,
+                surface: args.surface,
                 timeoutMs: args.timeoutMs
             });
+            assertScreenshotEvidence(screenshotPath, screenshotBytes);
+            await writeContainedOutputFile(args.absoluteArtifactRoot, screenshotPath, screenshotBytes);
             const assertions = fixtureAssertionsForBrowserStep(step, httpProbe.ok);
             steps.push({
                 action: step.action,
@@ -132,7 +132,7 @@ export async function captureBrowserSurfaceFixture(args) {
             timestamp: capturedAt
         });
         const blockedScreenshotPath = surfaceScreenshotPath(blockedSteps);
-        await writeJson(absoluteTracePath, buildBrowserTrace({
+        await writeContainedOutputFile(args.absoluteArtifactRoot, tracePath, `${JSON.stringify(buildBrowserTrace({
             appUrl: args.appUrl,
             browserCommand: path.basename(args.browserCommand),
             browserJourney: args.browserJourney,
@@ -144,7 +144,7 @@ export async function captureBrowserSurfaceFixture(args) {
             ...(blockedScreenshotPath === undefined ? {} : { screenshotPath: blockedScreenshotPath }),
             steps: blockedSteps,
             surface: args.surface
-        }));
+        }), null, 2)}\n`, "utf8");
         return {
             capturedAt,
             durationMs: Date.now() - started,
@@ -163,7 +163,12 @@ export async function captureBrowserSurfaceFixture(args) {
     // Every step in the success path attempts a screenshot, so each carries a
     // screenshotPath. A step claiming success whose screenshot is missing or empty
     // must still drag the capture out of `ok` — the strict verifier then catches it.
-    const screenshotStats = await Promise.all(steps.map((step) => (step.screenshotPath ? stat(path.join(args.absoluteArtifactRoot, step.screenshotPath)) : Promise.resolve(null)).catch(() => null)));
+    const screenshotStats = await Promise.all(steps.map(async (step) => {
+        if (!step.screenshotPath)
+            return null;
+        const screenshotFile = await prepareContainedOutputFile(args.absoluteArtifactRoot, step.screenshotPath);
+        return stat(screenshotFile);
+    }).map((result) => result.catch(() => null)));
     const screenshotsOk = screenshotStats.every((stats) => stats?.isFile() && stats.size > 0);
     const ok = Boolean(screenshotsOk && httpProbe.ok && steps.every((step) => step.status === "passed"));
     const reason = ok
@@ -174,7 +179,7 @@ export async function captureBrowserSurfaceFixture(args) {
     const completedAt = new Date().toISOString();
     const durationMs = Date.now() - started;
     const fixtureScreenshotPath = surfaceScreenshotPath(steps);
-    await writeJson(absoluteTracePath, buildBrowserTrace({
+    await writeContainedOutputFile(args.absoluteArtifactRoot, tracePath, `${JSON.stringify(buildBrowserTrace({
         appUrl: args.appUrl,
         browserCommand: path.basename(args.browserCommand),
         browserJourney: args.browserJourney,
@@ -186,7 +191,7 @@ export async function captureBrowserSurfaceFixture(args) {
         ...(fixtureScreenshotPath === undefined ? {} : { screenshotPath: fixtureScreenshotPath }),
         steps,
         surface: args.surface
-    }));
+    }), null, 2)}\n`, "utf8");
     return {
         capturedAt: completedAt,
         durationMs,
@@ -202,7 +207,7 @@ export async function captureBrowserSurfaceFixture(args) {
 export async function captureBrowserSurfaceWithPlaywright(args) {
     const started = Date.now();
     const tracePath = path.join("traces", `${args.surface.id}.json`);
-    const absoluteTracePath = path.join(args.absoluteArtifactRoot, tracePath);
+    await assertScriptedOutputRoot(args.absoluteArtifactRoot);
     const httpProbe = await probeAppUrl(args.appUrl, Math.min(args.timeoutMs, 15_000));
     let browser = null;
     let page = null;
@@ -273,7 +278,7 @@ export async function captureBrowserSurfaceWithPlaywright(args) {
         ? `${args.surface.label} completed ${steps.length}/${steps.length} browser persona steps from ${args.appUrl}${httpProbe.status === undefined ? "" : ` with HTTP ${httpProbe.status}`}.`
         : `${args.surface.label} browser persona journey blocked: ${steps.find((step) => step.status !== "passed")?.reason ?? httpProbe.reason}`;
     const playwrightScreenshotPath = surfaceScreenshotPath(steps);
-    await writeJson(absoluteTracePath, buildBrowserTrace({
+    await writeContainedOutputFile(args.absoluteArtifactRoot, tracePath, `${JSON.stringify(buildBrowserTrace({
         appUrl: args.appUrl,
         browserCommand: path.basename(args.browserCommand),
         browserJourney: args.browserJourney,
@@ -285,7 +290,7 @@ export async function captureBrowserSurfaceWithPlaywright(args) {
         ...(playwrightScreenshotPath === undefined ? {} : { screenshotPath: playwrightScreenshotPath }),
         steps,
         surface: args.surface
-    }));
+    }), null, 2)}\n`, "utf8");
     return {
         capturedAt: completedAt,
         durationMs,
@@ -352,10 +357,10 @@ export async function executeBrowserPersonaStep(args) {
     }
     const afterState = await browserPersonaPageState(args.page, urlPolicy);
     const screenshotPath = screenshotPathForBrowserStep(args.surface, args.step);
-    await args.page.screenshot({
-        path: path.join(args.absoluteArtifactRoot, screenshotPath),
-        fullPage: true
-    });
+    await prepareContainedOutputFile(args.absoluteArtifactRoot, screenshotPath);
+    const screenshotBytes = await captureScriptedPageScreenshot(args.page);
+    assertScreenshotEvidence(screenshotPath, screenshotBytes);
+    await writeContainedOutputFile(args.absoluteArtifactRoot, screenshotPath, screenshotBytes);
     const assertions = await evaluateBrowserStepExpectations({
         afterState,
         beforeState,
@@ -478,8 +483,22 @@ function fixtureAssertionsForBrowserStep(step, httpOk) {
     }));
 }
 export function screenshotPathForBrowserStep(surface, step) {
+    assertSafeOutputPathSegment(surface.id, "Browser surface id");
+    if (step) {
+        assertSafeOutputPathSegment(step.id, "Browser journey step id");
+    }
     return path.join("screenshots", `${surface.id}-${step?.id ?? "step"}.png`);
 }
+function tracePathForBrowserSurface(surface) {
+    assertSafeOutputPathSegment(surface.id, "Browser surface id");
+    return path.join("traces", `${surface.id}.json`);
+}
+function assertScriptedSessionPathIds(options) {
+    assertSafeOutputPathSegment(options.surface.id, "Browser surface id");
+    for (const step of options.journey.steps) {
+        assertSafeOutputPathSegment(step.id, "Browser journey step id");
+    }
+}
 /**
  * Best-effort screenshot of a blocked step. The step is blocked, so its failure is
  * the evidence; the shot is a bonus. Returns the relative path plus whether the
@@ -489,9 +508,19 @@ export function screenshotPathForBrowserStep(surface, step) {
  */
 async function captureBlockedStepScreenshot(page, artifactRoot, surface, step) {
     const screenshotPath = screenshotPathForBrowserStep(surface, step);
-    await page?.screenshot({ path: path.join(artifactRoot, screenshotPath), fullPage: true }).catch(() => undefined);
-    const stats = await stat(path.join(artifactRoot, screenshotPath)).catch(() => null);
-    return { screenshotPath, written: Boolean(stats?.isFile() && stats.size > 0) };
+    await prepareContainedOutputFile(artifactRoot, screenshotPath);
+    if (!page) {
+        return { screenshotPath, written: false };
+    }
+    try {
+        const screenshotBytes = await captureScriptedPageScreenshot(page);
+        assertScreenshotEvidence(screenshotPath, screenshotBytes);
+        await writeContainedOutputFile(artifactRoot, screenshotPath, screenshotBytes);
+        return { screenshotPath, written: true };
+    }
+    catch {
+        return { screenshotPath, written: false };
+    }
 }
 /**
  * Surface-level screenshot path = the last step that actually wrote one. Returns
@@ -619,6 +648,34 @@ export async function captureScreenshotWithBrowser(args) {
         ? `browser exited before screenshot was written (exit=${exitCode ?? "null"} signal=${signal ?? "null"})`
         : `timed out after ${args.timeoutMs}ms waiting for screenshot`);
 }
+async function captureBrowserCommandScreenshot(args) {
+    const stagingPath = await mkdtemp(path.join(os.tmpdir(), "humanish-browser-command-shot-"));
+    const stagingRoot = await prepareSelectedOutputDirectory(path.dirname(stagingPath), stagingPath);
+    try {
+        const screenshotPath = path.join(stagingRoot.physicalPath, "capture.png");
+        await captureScreenshotWithBrowser({
+            args: browserScreenshotArgs({
+                appUrl: args.appUrl,
+                profileDir: args.profileDir,
+                screenshotPath,
+                surface: args.surface
+            }),
+            browserCommand: args.browserCommand,
+            screenshotPath,
+            timeoutMs: args.timeoutMs
+        });
+        const bytes = await readContainedRegularFile(stagingRoot, "capture.png");
+        if (!bytes) {
+            throw new Error("Browser screenshot command did not write a single-link staging file.");
+        }
+        return bytes;
+    }
+    finally {
+        await assertPreparedSelectedOutputDirectory(stagingRoot)
+            .then(() => rm(stagingRoot.physicalPath, { force: true, recursive: true }))
+            .catch(() => undefined);
+    }
+}
 function terminateProcessGroup(pid, force = false) {
     if (!pid) {
         return;
@@ -925,6 +982,18 @@ class ScriptedJourneyTimeoutError extends Error {
  *   approvals exist on a deterministic replay) — asserted in tests.
  */
 export async function runScriptedBrowserSession(options) {
+    assertScriptedSessionPathIds(options);
+    const preparedArtifactRoot = await prepareSelectedOutputDirectory(process.cwd(), options.artifactRoot);
+    return runScriptedBrowserSessionInPreparedRoot(options, preparedArtifactRoot);
+}
+/** Internal lab seam: the run root is already prepared and must stay bound to that identity. */
+export async function runScriptedBrowserSessionInPreparedRoot(options, preparedArtifactRoot) {
+    assertScriptedSessionPathIds(options);
+    await prepareContainedOutputDirectory(preparedArtifactRoot, "screenshots");
+    await prepareContainedOutputDirectory(preparedArtifactRoot, "traces");
+    await prepareContainedOutputFile(preparedArtifactRoot, tracePathForBrowserSurface(options.surface));
+    await Promise.all(options.journey.steps.map((step) => prepareContainedOutputFile(preparedArtifactRoot, screenshotPathForBrowserStep(options.surface, step))));
+    await assertScriptedOutputRoot(preparedArtifactRoot);
     const now = options.now ?? (() => Date.now());
     const startedAtMs = now();
     const startedAt = new Date(startedAtMs).toISOString();
@@ -932,12 +1001,10 @@ export async function runScriptedBrowserSession(options) {
     const browserCommand = options.browserCommand ?? (options.launchBrowser ? "injected-browser" : "");
     const evidenceAppUrl = options.evidenceAppUrl ?? options.appUrl;
     const urlPolicy = options.urlPolicy ?? LOOPBACK_EVIDENCE_URL_POLICY;
-    await mkdir(path.join(options.artifactRoot, "screenshots"), { recursive: true });
-    await mkdir(path.join(options.artifactRoot, "traces"), { recursive: true });
     const finish = async (args) => {
         const completedAtMs = now();
         const trace = await projectScriptedActorTrace({
-            artifactRoot: options.artifactRoot,
+            artifactRoot: preparedArtifactRoot,
             capture: args.capture,
             completedAt: new Date(completedAtMs).toISOString(),
             completionReason: args.completionReason,
@@ -966,7 +1033,7 @@ export async function runScriptedBrowserSession(options) {
         const reason = `Scripted browser launch failed: ${compactBrowserError(error)}`;
         const capture = await persistScriptedFailureCapture({
             appUrl: options.appUrl,
-            artifactRoot: options.artifactRoot,
+            artifactRoot: preparedArtifactRoot,
             browserCommand,
             evidenceAppUrl,
             journey: options.journey,
@@ -976,9 +1043,16 @@ export async function runScriptedBrowserSession(options) {
         });
         return finish({ capture, executedSteps: 0, status: "failed", completionReason: "harness_error", reason });
     }
+    try {
+        await assertScriptedOutputRoot(preparedArtifactRoot);
+    }
+    catch (error) {
+        await browser.close().catch(() => undefined);
+        throw error;
+    }
     const journeyRun = await runScriptedJourney({
         appUrl: options.appUrl,
-        artifactRoot: options.artifactRoot,
+        artifactRoot: preparedArtifactRoot,
         browser,
         browserCommand,
         evidenceAppUrl,
@@ -1019,8 +1093,7 @@ export async function runScriptedBrowserSession(options) {
 async function runScriptedJourney(args) {
     const started = Date.now();
     const deadline = started + args.timeoutMs;
-    const tracePath = path.join("traces", `${args.surface.id}.json`);
-    const absoluteTracePath = path.join(args.artifactRoot, tracePath);
+    const tracePath = tracePathForBrowserSurface(args.surface);
     const httpProbe = await probeAppUrl(args.appUrl, Math.min(args.timeoutMs, 15_000));
     let page = null;
     const steps = [];
@@ -1037,6 +1110,7 @@ async function runScriptedJourney(args) {
         });
         page = await context.newPage();
         for (const step of args.journey.steps) {
+            await assertScriptedOutputRoot(args.artifactRoot);
             executedSteps += 1;
             steps.push(await withJourneyDeadline(executeBrowserPersonaStep({
                 absoluteArtifactRoot: args.artifactRoot,
@@ -1051,6 +1125,7 @@ async function runScriptedJourney(args) {
         }
     }
     catch (error) {
+        await assertScriptedOutputRoot(args.artifactRoot);
         timedOut = error instanceof ScriptedJourneyTimeoutError;
         const now = new Date().toISOString();
         const reason = compactBrowserError(error);
@@ -1092,7 +1167,7 @@ async function runScriptedJourney(args) {
         ? `${args.surface.label} completed ${steps.length}/${steps.length} scripted browser steps from ${args.evidenceAppUrl}${httpProbe.status === undefined ? "" : ` with HTTP ${httpProbe.status}`}.`
         : `${args.surface.label} scripted browser journey blocked: ${steps.find((step) => step.status !== "passed")?.reason ?? httpProbe.reason}`;
     const scriptedScreenshotPath = surfaceScreenshotPath(steps);
-    await writeJson(absoluteTracePath, buildBrowserTrace({
+    await writeContainedOutputFile(args.artifactRoot, tracePath, `${JSON.stringify(buildBrowserTrace({
         appUrl: args.evidenceAppUrl,
         browserCommand: path.basename(args.browserCommand || "injected-browser"),
         browserJourney: args.journey,
@@ -1104,7 +1179,7 @@ async function runScriptedJourney(args) {
         ...(scriptedScreenshotPath === undefined ? {} : { screenshotPath: scriptedScreenshotPath }),
         steps,
         surface: args.surface
-    }));
+    }), null, 2)}\n`, "utf8");
     return {
         capture: {
             capturedAt: completedAt,
@@ -1150,7 +1225,7 @@ async function withJourneyDeadline(promise, deadline, timeoutMs) {
  *  journey actuation (browser launch crash). Mirrors the driver's failure shape. */
 async function persistScriptedFailureCapture(args) {
     const capturedAt = new Date().toISOString();
-    const tracePath = path.join("traces", `${args.surface.id}.json`);
+    const tracePath = tracePathForBrowserSurface(args.surface);
     const blockedSteps = buildBlockedBrowserPersonaSteps({
         browserJourney: args.journey,
         currentUrl: args.appUrl,
@@ -1162,7 +1237,7 @@ async function persistScriptedFailureCapture(args) {
     // Pre-actuation failure: no screenshots were written, so the surface omits the
     // screenshot reference and the failure itself stands as the evidence.
     const screenshotPath = surfaceScreenshotPath(blockedSteps);
-    await writeJson(path.join(args.artifactRoot, tracePath), buildBrowserTrace({
+    await writeContainedOutputFile(args.artifactRoot, tracePath, `${JSON.stringify(buildBrowserTrace({
         appUrl: args.evidenceAppUrl,
         browserCommand: path.basename(args.browserCommand || "injected-browser"),
         browserJourney: args.journey,
@@ -1173,7 +1248,7 @@ async function persistScriptedFailureCapture(args) {
         ...(screenshotPath === undefined ? {} : { screenshotPath }),
         steps: blockedSteps,
         surface: args.surface
-    }));
+    }), null, 2)}\n`, "utf8");
     return {
         capturedAt,
         durationMs: 0,
@@ -1194,7 +1269,8 @@ async function projectScriptedActorTrace(args) {
         if (!step.screenshotPath) {
             continue;
         }
-        const stats = await stat(path.join(args.artifactRoot, step.screenshotPath)).catch(() => null);
+        const screenshotFile = await prepareContainedOutputFile(args.artifactRoot, step.screenshotPath).catch(() => null);
+        const stats = screenshotFile ? await stat(screenshotFile).catch(() => null) : null;
         if (stats?.isFile() && stats.size > 0) {
             writtenScreenshots.add(step.screenshotPath);
         }
@@ -1254,8 +1330,45 @@ async function projectScriptedActorTrace(args) {
 // Small private helpers (moved with the driver; run.ts keeps its own copies for
 // the code that stayed behind — this module must remain a leaf).
 // ---------------------------------------------------------------------------
-async function writeJson(filePath, value) {
-    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+async function assertScriptedOutputRoot(root) {
+    if ("physicalRunRoot" in root) {
+        await prepareContainedOutputDirectory(root, "");
+        return root.physicalRunRoot;
+    }
+    await assertPreparedSelectedOutputDirectory(root);
+    return root.physicalPath;
+}
+function browserScreenshotBytes(value) {
+    if (Buffer.isBuffer(value)) {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return Buffer.from(value);
+    }
+    throw new Error("Browser screenshot did not return image bytes.");
+}
+async function captureScriptedPageScreenshot(page) {
+    const stagingPath = await mkdtemp(path.join(os.tmpdir(), "humanish-browser-shot-"));
+    const stagingRoot = await prepareSelectedOutputDirectory(path.dirname(stagingPath), stagingPath);
+    try {
+        const returned = await page.screenshot({
+            path: path.join(stagingRoot.physicalPath, "capture.png"),
+            fullPage: true
+        });
+        if (Buffer.isBuffer(returned) || returned instanceof Uint8Array) {
+            return browserScreenshotBytes(returned);
+        }
+        const stagedBytes = await readContainedRegularFile(stagingRoot, "capture.png");
+        if (!stagedBytes) {
+            throw new Error("Browser screenshot did not return bytes or write a single-link staging file.");
+        }
+        return stagedBytes;
+    }
+    finally {
+        await assertPreparedSelectedOutputDirectory(stagingRoot)
+            .then(() => rm(stagingRoot.physicalPath, { force: true, recursive: true }))
+            .catch(() => undefined);
+    }
 }
 function shellQuote(value) {
     if (/^[A-Za-z0-9_/:=.,@%+-]+$/.test(value)) {