@tiangong-ai/cli 0.0.35 → 0.0.37

package/dist/research/workspace/projects.js

@@ -10,10 +10,11 @@ import { cloneProjectArtifactRecords } from "./artifacts.js";
 import { freezeEvidenceSnapshot, loadCurrentEvidenceSnapshot, loadImmutableEvidenceSnapshotChain, } from "./acquisition.js";
 import { projectInputsFromPlan, reverifyProjectInputPlan } from "./input-plan.js";
 import { evaluateProjectPreflight } from "./preflight.js";
-import { ensureDirectory, fileRecord, fileSize, isObject, readJsonFile, sha256File, workspacePaths, writeJsonAtomic, } from "./storage.js";
+import { evaluateScientificDesign, scientificDesignPolicyGaps, } from "./scientific-design.js";
+import { ensureDirectory, fileRecord, fileSize, isObject, readJsonFile, sha256File, sha256Text, workspacePaths, writeJsonAtomic, } from "./storage.js";
 import { loadWorkspaceConfig, withWorkspaceLock } from "./workspace.js";
 const PROJECT_ID_PATTERN = /^[a-z0-9][a-z0-9-]{2,63}$/;
-export async function initializeProject(root, projectId, question, evidenceRequirements, budgetConfirmed = false, inputPlan, publicationPolicy) {
+export async function initializeProject(root, projectId, question, evidenceRequirements, budgetConfirmed = false, inputPlan, publicationPolicy, scientificDesignInput) {
     validateProjectId(projectId);
     const normalizedQuestion = question.trim();
     if (normalizedQuestion.length < 8 || normalizedQuestion.length > 4000) {
@@ -53,9 +54,27 @@ export async function initializeProject(root, projectId, question, evidenceRequi
             });
         }
         const requirements = normalizeEvidenceRequirements(evidenceRequirements ?? defaultEvidenceRequirements(config));
+        if (publicationPolicy && !scientificDesignInput) {
+            throw new CliError("Top-journal research requires an explicit scientific design contract.", {
+                code: "RESEARCH_SCIENTIFIC_DESIGN_REQUIRED",
+                exitCode: 2,
+            });
+        }
+        if (!publicationPolicy && scientificDesignInput) {
+            throw new CliError("A scientific design contract requires an approved top-journal policy.", {
+                code: "RESEARCH_SCIENTIFIC_DESIGN_POLICY_REQUIRED",
+                exitCode: 2,
+            });
+        }
+        const scientificDesign = scientificDesignInput
+            ? prepareScientificDesignBinding(projectId, publicationPolicy, scientificDesignInput)
+            : null;
         const admittedInputPlan = inputPlan ? await reverifyProjectInputPlan(inputPlan) : undefined;
         if (config.mode === "production-research") {
-            const preflight = await evaluateProjectPreflight(root, normalizedQuestion, requirements, admittedInputPlan ?? null);
+            const preflight = await evaluateProjectPreflight(root, normalizedQuestion, requirements, admittedInputPlan ?? null, {
+                publicationPolicy: publicationPolicy ?? null,
+                scientificDesign: scientificDesignInput?.design ?? null,
+            });
             if (!preflight.readyToInitialize) {
                 throw new CliError("Production project initialization was blocked by preflight.", {
                     code: "RESEARCH_PREFLIGHT_BLOCKED",
@@ -76,6 +95,7 @@ export async function initializeProject(root, projectId, question, evidenceRequi
             inputs: admittedInputPlan ? projectInputsFromPlan(admittedInputPlan, now) : [],
             evidenceRequirements: requirements,
             publicationPolicy: publicationPolicy ?? null,
+            scientificDesign,
             packages: defaultWorkPackages(config),
             usage: {
                 tokens: 0,
@@ -94,6 +114,9 @@ export async function initializeProject(root, projectId, question, evidenceRequi
             ensureDirectory(join(projectRoot, "outputs")),
             ensureDirectory(join(projectRoot, "runs")),
         ]);
+        if (scientificDesign && scientificDesignInput) {
+            await writeJsonAtomic(join(paths.control, scientificDesign.objectLocator), scientificDesignInput.design.contract);
+        }
         await writeJsonAtomic(projectPath, project);
         await registerProjectInputCandidates(root, projectId, project.inputs);
         await appendJournalEvent(paths.journal, "project.initialized", projectId, {
@@ -101,6 +124,8 @@ export async function initializeProject(root, projectId, question, evidenceRequi
             questionSha256: await hashQuestion(normalizedQuestion),
             inputPlanSha256: admittedInputPlan?.sha256 ?? null,
             publicationPolicySha256: publicationPolicy?.resolvedPolicySha256 ?? null,
+            scientificDesignSha256: scientificDesign?.designSha256 ?? null,
+            scientificDesignProducerSessionSha256: scientificDesign?.producer.sessionSha256 ?? null,
             inputs: project.inputs.map((input) => ({
                 id: input.id,
                 role: input.role,
@@ -252,7 +277,7 @@ export async function retryProjectPackage(root, projectId, packageId) {
         return project;
     });
 }
-export async function forkProject(root, sourceProjectId, targetProjectId, resumeThrough) {
+export async function forkProject(root, sourceProjectId, targetProjectId, resumeThrough, scientificReapproval) {
     validateProjectId(sourceProjectId);
     validateProjectId(targetProjectId);
     if (sourceProjectId === targetProjectId) {
@@ -263,6 +288,16 @@ export async function forkProject(root, sourceProjectId, targetProjectId, resume
     }
     return withWorkspaceLock(root, "project.fork", async () => {
         const source = await loadProject(root, sourceProjectId);
+        const sourceRequiresScientificReapproval = Boolean(source.publicationPolicy || source.scientificDesign);
+        if (sourceRequiresScientificReapproval && !scientificReapproval) {
+            throw new CliError("A top-journal recovery fork requires a newly approved project-specific policy and scientific design.", { code: "RESEARCH_SCIENTIFIC_DESIGN_REAPPROVAL_REQUIRED", exitCode: 3 });
+        }
+        if (!sourceRequiresScientificReapproval && scientificReapproval) {
+            throw new CliError("Scientific reapproval is valid only for a top-journal source project.", {
+                code: "RESEARCH_SCIENTIFIC_DESIGN_REAPPROVAL_INVALID",
+                exitCode: 2,
+            });
+        }
         if (source.lineage.supersededBy) {
             throw new CliError(`Project ${sourceProjectId} is historical; fork the authoritative project ${source.lineage.supersededBy}.`, { code: "RESEARCH_PROJECT_NOT_AUTHORITATIVE", exitCode: 3 });
         }
@@ -283,6 +318,29 @@ export async function forkProject(root, sourceProjectId, targetProjectId, resume
             });
         }
         const config = await loadWorkspaceConfig(root);
+        const targetPolicy = scientificReapproval?.publicationPolicy ?? null;
+        if (targetPolicy && targetPolicy.projectId !== targetProjectId) {
+            throw new CliError("Recovery policy must be approved for the target project generation.", {
+                code: "RESEARCH_SCIENTIFIC_DESIGN_REAPPROVAL_INVALID",
+                exitCode: 2,
+            });
+        }
+        const targetScientificDesign = scientificReapproval
+            ? prepareScientificDesignBinding(targetProjectId, scientificReapproval.publicationPolicy, scientificReapproval.scientificDesign)
+            : null;
+        if (config.mode === "production-research") {
+            const preflight = await evaluateProjectPreflight(root, source.question, source.evidenceRequirements, null, {
+                publicationPolicy: targetPolicy,
+                scientificDesign: scientificReapproval?.scientificDesign.design ?? null,
+            });
+            if (!preflight.readyToInitialize) {
+                throw new CliError("Recovery generation was blocked by production preflight.", {
+                    code: "RESEARCH_PREFLIGHT_BLOCKED",
+                    exitCode: 3,
+                    details: { gaps: preflight.gaps, preflightSha256: preflight.preflightSha256 },
+                });
+            }
+        }
         const packages = defaultWorkPackages(config);
         const inheritedStages = resumeThrough
             ? ["discover", "acquire", "analyze", "synthesize"].slice(0, ["discover", "acquire", "analyze", "synthesize"].indexOf(resumeThrough) + 1)
@@ -320,9 +378,8 @@ export async function forkProject(root, sourceProjectId, targetProjectId, resume
                 requiredCompanionIds: [...(source.evidenceRequirements.requiredCompanionIds ?? [])],
                 requiredDiscoveryScopes: [...(source.evidenceRequirements.requiredDiscoveryScopes ?? [])],
             },
-            publicationPolicy: source.publicationPolicy
-                ? structuredClone(source.publicationPolicy)
-                : null,
+            publicationPolicy: targetPolicy,
+            scientificDesign: targetScientificDesign,
             packages,
             usage: {
                 tokens: 0,
@@ -345,6 +402,9 @@ export async function forkProject(root, sourceProjectId, targetProjectId, resume
             ensureDirectory(join(targetRoot, "outputs")),
             ensureDirectory(join(targetRoot, "runs")),
         ]);
+        if (targetScientificDesign && scientificReapproval) {
+            await writeJsonAtomic(join(workspacePaths(root).control, targetScientificDesign.objectLocator), scientificReapproval.scientificDesign.design.contract);
+        }
         const inheritedOutputs = [];
         const stageOutput = {
             discover: "outputs/evidence.json",
@@ -391,6 +451,9 @@ export async function forkProject(root, sourceProjectId, targetProjectId, resume
             inheritedOutputs,
             inheritedUsage: false,
             sourceSuperseded: true,
+            publicationPolicySha256: targetPolicy?.resolvedPolicySha256 ?? null,
+            scientificDesignSha256: targetScientificDesign?.designSha256 ?? null,
+            scientificDesignProducerSessionSha256: targetScientificDesign?.producer.sessionSha256 ?? null,
         });
         return project;
     });
@@ -437,7 +500,7 @@ export async function setProjectDisposition(root, projectId, disposition, reason
         return project;
     });
 }
-export async function createProjectAddendum(root, sourceProjectId, targetProjectId) {
+export async function createProjectAddendum(root, sourceProjectId, targetProjectId, scientificReapproval) {
     validateProjectId(sourceProjectId);
     validateProjectId(targetProjectId);
     if (sourceProjectId === targetProjectId) {
@@ -448,6 +511,16 @@ export async function createProjectAddendum(root, sourceProjectId, targetProject
     }
     return withWorkspaceLock(root, "project.addendum", async () => {
         const source = refreshProject(await loadProject(root, sourceProjectId));
+        const sourceRequiresScientificReapproval = Boolean(source.publicationPolicy || source.scientificDesign);
+        if (sourceRequiresScientificReapproval && !scientificReapproval) {
+            throw new CliError("A top-journal addendum requires a newly approved project-specific policy and scientific design.", { code: "RESEARCH_SCIENTIFIC_DESIGN_REAPPROVAL_REQUIRED", exitCode: 3 });
+        }
+        if (!sourceRequiresScientificReapproval && scientificReapproval) {
+            throw new CliError("Scientific reapproval is valid only for a top-journal source project.", {
+                code: "RESEARCH_SCIENTIFIC_DESIGN_REAPPROVAL_INVALID",
+                exitCode: 2,
+            });
+        }
         if (source.status !== "complete" || source.packages.at(-1)?.stage !== "close") {
             throw new CliError("An addendum requires a mechanically closed source project.", {
                 code: "RESEARCH_PROJECT_ADDENDUM_INVALID",
@@ -484,6 +557,29 @@ export async function createProjectAddendum(root, sourceProjectId, targetProject
             });
         }
         const config = await loadWorkspaceConfig(root);
+        const targetPolicy = scientificReapproval?.publicationPolicy ?? null;
+        if (targetPolicy && targetPolicy.projectId !== targetProjectId) {
+            throw new CliError("Addendum policy must be approved for the target project generation.", {
+                code: "RESEARCH_SCIENTIFIC_DESIGN_REAPPROVAL_INVALID",
+                exitCode: 2,
+            });
+        }
+        const targetScientificDesign = scientificReapproval
+            ? prepareScientificDesignBinding(targetProjectId, scientificReapproval.publicationPolicy, scientificReapproval.scientificDesign)
+            : null;
+        if (config.mode === "production-research") {
+            const preflight = await evaluateProjectPreflight(root, source.question, source.evidenceRequirements, null, {
+                publicationPolicy: targetPolicy,
+                scientificDesign: scientificReapproval?.scientificDesign.design ?? null,
+            });
+            if (!preflight.readyToInitialize) {
+                throw new CliError("Addendum generation was blocked by production preflight.", {
+                    code: "RESEARCH_PREFLIGHT_BLOCKED",
+                    exitCode: 3,
+                    details: { gaps: preflight.gaps, preflightSha256: preflight.preflightSha256 },
+                });
+            }
+        }
         const now = new Date().toISOString();
         const target = {
             schemaVersion: 1,
@@ -502,9 +598,8 @@ export async function createProjectAddendum(root, sourceProjectId, targetProject
                 requiredCompanionIds: [...(source.evidenceRequirements.requiredCompanionIds ?? [])],
                 requiredDiscoveryScopes: [...(source.evidenceRequirements.requiredDiscoveryScopes ?? [])],
             },
-            publicationPolicy: source.publicationPolicy
-                ? structuredClone(source.publicationPolicy)
-                : null,
+            publicationPolicy: targetPolicy,
+            scientificDesign: targetScientificDesign,
             packages: defaultWorkPackages(config),
             usage: {
                 tokens: 0,
@@ -531,6 +626,9 @@ export async function createProjectAddendum(root, sourceProjectId, targetProject
             ensureDirectory(join(targetRoot, "runs")),
             ensureDirectory(join(targetRoot, "evidence", "snapshots")),
         ]);
+        if (targetScientificDesign && scientificReapproval) {
+            await writeJsonAtomic(join(workspacePaths(root).control, targetScientificDesign.objectLocator), scientificReapproval.scientificDesign.design.contract);
+        }
         const inheritedOutputs = [];
         for (const logicalPath of ["outputs/evidence.json", "outputs/acquisition.json"]) {
             const sourcePath = join(workspacePaths(root).projects, sourceProjectId, logicalPath);
@@ -576,6 +674,9 @@ export async function createProjectAddendum(root, sourceProjectId, targetProject
             baseSnapshotSha256: snapshot.snapshotSha256,
             inheritedOutputs,
             originalClosurePreserved: true,
+            publicationPolicySha256: targetPolicy?.resolvedPolicySha256 ?? null,
+            scientificDesignSha256: targetScientificDesign?.designSha256 ?? null,
+            scientificDesignProducerSessionSha256: targetScientificDesign?.producer.sessionSha256 ?? null,
         });
         return target;
     });
@@ -617,7 +718,32 @@ export function nextReadyPackage(project) {
     refreshProject(project);
     if (project.handoff.state !== "agent-actionable")
         return undefined;
-    return project.packages.find((workPackage) => workPackage.status === "ready");
+    const candidate = project.packages.find((workPackage) => workPackage.status === "ready");
+    if (!candidate)
+        return undefined;
+    const gate = nextScientificGate(project);
+    if (gate && gate.status !== "passed") {
+        const packageOrder = ["discover", "acquire", "analyze", "synthesize", "review", "close"];
+        if (packageOrder.indexOf(candidate.id) >= packageOrder.indexOf(gate.blocksPackage)) {
+            return undefined;
+        }
+    }
+    return candidate;
+}
+export function nextScientificGate(project) {
+    if (!project.scientificDesign)
+        return null;
+    const ordered = [
+        { role: "research-design", blocksPackage: "discover" },
+        { role: "evidence-construct", blocksPackage: "acquire" },
+        { role: "pilot-methods", blocksPackage: "analyze" },
+    ];
+    for (const item of ordered) {
+        const status = project.scientificDesign.gates[item.role].status;
+        if (status !== "passed")
+            return { ...item, status };
+    }
+    return null;
 }
 export function packageById(project, packageId) {
     const workPackage = project.packages.find((candidate) => candidate.id === packageId);
@@ -677,6 +803,8 @@ function validateProjectShape(project, expectedId) {
         (project.budgetConfirmedAt !== null && typeof project.budgetConfirmedAt !== "string") ||
         !Array.isArray(project.inputs) ||
         !isEvidenceRequirements(project.evidenceRequirements) ||
+        !isScientificDesignBinding(project.scientificDesign, expectedId) ||
+        (Boolean(project.publicationPolicy) && project.scientificDesign === null) ||
         !Array.isArray(project.packages) ||
         !project.usage ||
         typeof project.usage.tokens !== "number" ||
@@ -726,15 +854,127 @@ function initialEvidenceState() {
 function initialHandoffState() {
     return {
         state: "agent-actionable",
+        kind: null,
         reasonCode: null,
         summary: null,
         requestedActions: [],
         evidenceGaps: [],
+        exhaustion: null,
+        accessRequests: [],
         requestedAt: null,
         resolvedAt: null,
         resolutionNote: null,
     };
 }
+function prepareScientificDesignBinding(projectId, policy, input) {
+    const contract = input.design.contract;
+    const normalized = `${JSON.stringify(contract, null, 2)}\n`;
+    if (contract.projectId !== projectId ||
+        input.design.sha256 !== sha256Text(normalized) ||
+        input.design.bytes !== Buffer.byteLength(normalized, "utf8")) {
+        throw new CliError("Scientific design does not match its verified project and hash binding.", {
+            code: "RESEARCH_SCIENTIFIC_DESIGN_PROJECT_MISMATCH",
+            exitCode: 2,
+        });
+    }
+    if (!input.producerSessionId.trim()) {
+        throw new CliError("Scientific design requires an opaque native producer session identifier.", {
+            code: "RESEARCH_SCIENTIFIC_DESIGN_PRODUCER_INVALID",
+            exitCode: 2,
+        });
+    }
+    if (policy.targetJournal &&
+        policy.targetJournal.trim().toLocaleLowerCase("en-US") !==
+            contract.identity.targetJournals.primary.trim().toLocaleLowerCase("en-US")) {
+        throw new CliError("Scientific design primary journal does not match Research Policy.", {
+            code: "RESEARCH_SCIENTIFIC_DESIGN_POLICY_MISMATCH",
+            exitCode: 2,
+        });
+    }
+    const expectedJournalApprovalStatus = policy.targetJournal ? "policy-approved" : "candidate-only";
+    if (contract.identity.targetJournals.approvalStatus !== expectedJournalApprovalStatus) {
+        throw new CliError(policy.targetJournal
+            ? "An exact-journal Research Policy requires a policy-approved scientific design target."
+            : "A generic Research Policy may list exact journals only as candidates.", {
+            code: "RESEARCH_SCIENTIFIC_DESIGN_POLICY_MISMATCH",
+            exitCode: 2,
+            details: {
+                expectedApprovalStatus: expectedJournalApprovalStatus,
+                actualApprovalStatus: contract.identity.targetJournals.approvalStatus,
+            },
+        });
+    }
+    const evaluation = evaluateScientificDesign(contract);
+    if (!evaluation.readyForDesignReview) {
+        throw new CliError("Scientific design has blocking mechanical issues.", {
+            code: "RESEARCH_SCIENTIFIC_DESIGN_BLOCKED",
+            exitCode: 3,
+            details: { issueCodes: evaluation.issueCodes },
+        });
+    }
+    const policyGaps = scientificDesignPolicyGaps(contract, policy);
+    if (policyGaps.length) {
+        throw new CliError("Scientific design does not discharge the approved Research Policy.", {
+            code: "RESEARCH_SCIENTIFIC_DESIGN_POLICY_MISMATCH",
+            exitCode: 3,
+            details: { gaps: policyGaps },
+        });
+    }
+    const pendingGate = () => ({
+        status: "pending",
+        packetSha256: null,
+        assessmentSha256: null,
+        reviewSha256: null,
+        reviewerSessionSha256: null,
+    });
+    return {
+        schemaVersion: 1,
+        designSha256: input.design.sha256,
+        objectLocator: `projects/${projectId}/scientific/design/objects/${input.design.sha256}.json`,
+        centralStudyKind: contract.identity.centralStudyKind,
+        producer: {
+            agent: input.producerAgent,
+            sessionSha256: sha256Text(input.producerSessionId),
+        },
+        mechanicalIssueCodes: evaluation.issueCodes,
+        gates: {
+            "research-design": pendingGate(),
+            "evidence-construct": pendingGate(),
+            "pilot-methods": pendingGate(),
+        },
+    };
+}
+function isScientificDesignBinding(value, projectId) {
+    if (value === null)
+        return true;
+    if (!isObject(value) || value.schemaVersion !== 1)
+        return false;
+    if (typeof value.designSha256 !== "string" ||
+        !/^[a-f0-9]{64}$/.test(value.designSha256) ||
+        value.objectLocator !==
+            `projects/${projectId}/scientific/design/objects/${value.designSha256}.json` ||
+        typeof value.centralStudyKind !== "string" ||
+        !isObject(value.producer) ||
+        !["codex", "claude"].includes(String(value.producer.agent)) ||
+        typeof value.producer.sessionSha256 !== "string" ||
+        !/^[a-f0-9]{64}$/.test(value.producer.sessionSha256) ||
+        !Array.isArray(value.mechanicalIssueCodes) ||
+        value.mechanicalIssueCodes.some((item) => typeof item !== "string") ||
+        !isObject(value.gates)) {
+        return false;
+    }
+    const roles = ["research-design", "evidence-construct", "pilot-methods"];
+    const gates = value.gates;
+    return roles.every((role) => isScientificGateBinding(gates[role]));
+}
+function isScientificGateBinding(value) {
+    return (isObject(value) &&
+        ["pending", "prepared", "passed", "revision-required", "stopped"].includes(String(value.status)) &&
+        nullableSha256(value.packetSha256) &&
+        nullableSha256(value.assessmentSha256) &&
+        nullableSha256(value.reviewSha256) &&
+        nullableSha256(value.reviewerSessionSha256));
+}
 function isProjectLineage(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
@@ -759,16 +999,65 @@ function isProjectHandoff(value) {
     if (!isObject(value))
         return false;
     return (["agent-actionable", "user-action-required", "external-response-required"].includes(String(value.state)) &&
+        (value.kind === null ||
+            ["interactive-challenge", "external-wait", "evidence-exhausted"].includes(String(value.kind))) &&
         nullableString(value.reasonCode) &&
         nullableString(value.summary) &&
         Array.isArray(value.requestedActions) &&
         value.requestedActions.every((item) => typeof item === "string") &&
         Array.isArray(value.evidenceGaps) &&
         value.evidenceGaps.every((item) => typeof item === "string") &&
+        isEvidenceExhaustion(value.exhaustion) &&
+        Array.isArray(value.accessRequests) &&
+        value.accessRequests.every(isAccessRequest) &&
         nullableString(value.requestedAt) &&
         nullableString(value.resolvedAt) &&
         nullableString(value.resolutionNote));
 }
+function isEvidenceExhaustion(value) {
+    if (value === null)
+        return true;
+    if (!isObject(value))
+        return false;
+    return (Array.isArray(value.missingEvidenceRoleIds) &&
+        value.missingEvidenceRoleIds.every(isIdentifier) &&
+        Array.isArray(value.routeAttempts) &&
+        value.routeAttempts.every((attempt) => isObject(attempt) &&
+            isIdentifier(attempt.routeId) &&
+            Array.isArray(attempt.terminalEventHashes) &&
+            attempt.terminalEventHashes.every((hash) => typeof hash === "string" && /^[a-f0-9]{64}$/.test(hash)) &&
+            ["completed-insufficient", "access-blocked", "deterministic-unavailable"].includes(String(attempt.outcome))) &&
+        Array.isArray(value.remainingRouteIds) &&
+        value.remainingRouteIds.every(isIdentifier));
+}
+function isAccessRequest(value) {
+    if (!isObject(value))
+        return false;
+    return (isIdentifier(value.id) &&
+        isIdentifier(value.routeId) &&
+        [
+            "database-subscription",
+            "article-purchase",
+            "institutional-access",
+            "licensed-dataset",
+            "owner-provided-material",
+            "external-data-request",
+            "field-data-collection",
+        ].includes(String(value.resourceType)) &&
+        typeof value.resourceName === "string" &&
+        nullableString(value.officialLocator) &&
+        Array.isArray(value.evidenceRoleIds) &&
+        value.evidenceRoleIds.every(isIdentifier) &&
+        typeof value.rationale === "string" &&
+        Array.isArray(value.alternativesTriedRouteIds) &&
+        value.alternativesTriedRouteIds.every(isIdentifier) &&
+        typeof value.requestedAction === "string" &&
+        typeof value.resumeCriteria === "string" &&
+        ["unknown", "provider-quote-required"].includes(String(value.costStatus)));
+}
+function isIdentifier(value) {
+    return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value);
+}
 function nullableString(value) {
     return value === null || typeof value === "string";
 }