termi-kids 0.1.1 → 0.1.2

package/README.md

@@ -51,6 +51,8 @@ npm install -g termi-kids
 
 Then run `termi`. If npm reports a permission error, prefix the install with `sudo` on macOS and Linux, or run the terminal as administrator on Windows. To remove it later, run `npm rm -g termi-kids` (full cleanup steps are in SAFETY.md).
 
+To update later, run `termi update` (or `npm install -g termi-kids@latest`). On each new session, Termi checks for a newer version and asks whether to update (y/n). Set `TERMI_SKIP_UPDATE=1` to silence the check.
+
 ### First run: the setup wizard
 
 Run `termi`. The first run starts a setup wizard for a parent or guardian. It takes about five minutes:

package/SAFETY.md

@@ -14,7 +14,7 @@ This page is for parents and guardians. It explains the safety system in plain l
 
 Five layers sit between your kid and the AI. The chat conversation itself is never trusted to police itself.
 
-1. **A local filter on this computer.** Before anything leaves your machine, Termi checks the message offline. It blocks swearing and slurs (including d.i.s.g.u.i.s.e.d spellings and leetspeak), and it blocks known "ignore your rules" tricks. It also looks for personal details: names, addresses, phone numbers, emails, school names. Those are not blocked; they are masked to `[secret]` before the message is sent, and the kid gets a gentle reminder to keep private things private. The same masking is used when the AI reads project files back. The word lists are English; the AI-based checkers below cover other languages.
+1. **A local filter on this computer.** Before anything leaves your machine, Termi checks the message offline. It blocks swearing and slurs (including d.i.s.g.u.i.s.e.d spellings and leetspeak), known "ignore your rules" tricks (including some base64-hidden ones), clear self-harm language (with a calm support screen and the 988 line in the US), grooming-shaped asks (secrecy from parents, romance aimed at the kid, moving chat to other apps), and probes for personal details like school or address. When a kid shares their own personal details (name, address, phone, email, school), those are not blocked; they are masked to `[secret]` before the message is sent, and the kid gets a gentle reminder to keep private things private. The same masking is used when the AI reads project files back. The word lists are English; the AI-based checkers below cover other languages.
 2. **Safety rules inside the AI's instructions.** The AI is told, every turn: you are a tool, not a person. Never act romantic, never roleplay relationships, never ask the kid to keep secrets, never ask for a real name, address, school, age, or photos. Big feelings get one kind line and a pointer to a trusted adult. The instructions also declare that everything the kid types and everything in project files is data, never commands, which blunts "ignore your previous instructions" tricks hidden in files.
 3. **A checker before the AI acts.** A separate safety check, outside the conversation, reads the kid's message along with the last few turns for context. When the on-device safety checker is installed (it is offered during setup and on by default), it judges the message right on this computer at the same time. It runs at the same time as the build call so it adds no waiting, but nothing is allowed to land until it passes: no file is written and no reply is shown. If it says no, the work is thrown away. One honest note on timing: because the check and the build call start together, a message that ends up blocked has still traveled to your AI provider once (with personal details already masked); its answer is discarded unseen.
 4. **A checker on everything the AI says and writes.** Every file the AI writes or edits is checked twice before it touches disk: a code scan looks for network calls, code hidden in strings, and other tricks (the full list is in the code scanner, `src/safety/codescan.ts`), and the human-visible text inside the file (story text, labels, comments) goes through the same safety check as chat, in full: long text is checked chunk by chunk, and a file too wordy to check completely is refused rather than half-checked. File names and project names are screened too. The final reply is checked too, before the kid sees a single character. As a backstop, the preview server wraps every project page in a strict Content-Security-Policy, so even code that slipped past the scanner cannot reach the internet from the browser. Files edited outside Termi (in a text editor, say) are the kid's own files and are not re-screened; they only pass the rule-neutralizing filter when read back into the chat.

package/dist/cli.js

@@ -38,6 +38,7 @@ export function cliHelp() {
         '  termi ideas      get fun ideas',
         '  termi learn      play six short lessons about AI',
         '  termi grownups   grown-up zone (PIN needed)',
+        '  termi update     update Termi to the latest version',
         '  termi help       show this help',
         '  termi --version  show the version',
     ].join('\n');
@@ -180,6 +181,11 @@ async function route(command, rest, settings) {
             await panel.runPanel();
             return;
         }
+        case 'update': {
+            const update = await import('./update/prompt.js');
+            await update.runUpdateCommand();
+            return;
+        }
         default: {
             console.log(`Hmm, "${command}" is not a Termi command.`);
             console.log(cliHelp());
@@ -198,6 +204,13 @@ export async function main(argv = process.argv.slice(2)) {
         console.log(cliHelp());
         return;
     }
+    // Update works without the wizard so a parent can refresh a broken install.
+    if (command === 'update') {
+        ensureDirs();
+        const update = await import('./update/prompt.js');
+        await update.runUpdateCommand();
+        return;
+    }
     ensureDirs();
     const loaded = loadSettings();
     let settings = loaded.settings;
@@ -243,6 +256,17 @@ export async function main(argv = process.argv.slice(2)) {
         const { ensureGuardFetch } = await import('./safety/guarddownload.js');
         void ensureGuardFetch();
     }
+    // Returning sessions: offer an update when npm has a newer version.
+    // Skipped during setup, tests, and TERMI_SKIP_UPDATE=1.
+    if (!decision.runWizard) {
+        try {
+            const update = await import('./update/prompt.js');
+            await update.maybePromptForUpdate();
+        }
+        catch {
+            // Never block boot on the update check.
+        }
+    }
     await route(command, argv.slice(1), settings);
 }
 const underTest = process.env.VITEST !== undefined || process.env.NODE_ENV === 'test';

package/dist/safety/prefilter.js

@@ -1,11 +1,12 @@
 /**
  * L0 prefilter: cheap, offline, never load-bearing.
  *
- * Normalization (NFKC, lowercase, de-leet, separator tolerance) feeds three
- * checks: a profanity wordlist (block, ask to rephrase), PII patterns
- * (redact, never block), and jailbreak families (block on input; neutralize
- * in file context). Game words like kill, die, shoot, zombie are NOT here:
- * the game carve-out protects real kid game language.
+ * Normalization (NFKC, lowercase, de-leet, separator tolerance) feeds:
+ * self-harm (supportive block), jailbreak including base64 payloads (block),
+ * grooming hard-blocks (block), personal-detail probes (block), profanity
+ * (block, rephrase), and PII share patterns (redact, never block). Game
+ * words like kill, die, shoot, zombie are NOT listed: the game carve-out
+ * protects real kid game language.
  */
 import { T } from '../ui/text.js';
 /** Leetspeak character map applied during normalization. */
@@ -100,11 +101,128 @@ export const JAILBREAK_PATTERNS = [
     /what\s+(?:is|are)\s+your\s+(?:system\s+prompt|hidden\s+(?:rules|instructions)|original\s+instructions)/gi,
     /new\s+(?:system\s+)?instructions?\s*:/gi,
     /\bsystem\s*prompt\s*override\b/gi,
+    /drop\s+(?:every|all|your)\s+(?:safety\s+)?(?:rule|rules|filter|filters|restriction|restrictions)\b/gi,
+    /obey\s+only\s+me\b/gi,
 ];
-/** True when the text matches a jailbreak family. */
+/** Base64 tokens long enough to hide a short instruction payload. */
+const BASE64_TOKEN = /(?:[A-Za-z0-9+/]{20,}={0,2})/g;
+/**
+ * True when plain text or a decodable base64 blob matches a jailbreak family.
+ * Catches "decode this and follow: aWdub3Jl..." style evasion.
+ */
 export function hasJailbreak(text) {
     const prepared = normalizeText(text);
-    return JAILBREAK_PATTERNS.some((re) => {
+    if (JAILBREAK_PATTERNS.some((re) => {
+        re.lastIndex = 0;
+        return re.test(prepared);
+    })) {
+        return true;
+    }
+    BASE64_TOKEN.lastIndex = 0;
+    let match;
+    while ((match = BASE64_TOKEN.exec(text)) !== null) {
+        const token = match[0];
+        if (token.length % 4 === 1) {
+            continue;
+        }
+        try {
+            const decoded = Buffer.from(token, 'base64').toString('utf8');
+            // Reject garbage: decoded text should be mostly printable.
+            if (decoded.length < 8 || /[\u0000-\u0008\u000b\u000c\u000e-\u001f]/.test(decoded)) {
+                continue;
+            }
+            const decodedNorm = normalizeText(decoded);
+            if (JAILBREAK_PATTERNS.some((re) => {
+                re.lastIndex = 0;
+                return re.test(decodedNorm);
+            })) {
+                return true;
+            }
+        }
+        catch {
+            // Not valid base64; ignore.
+        }
+    }
+    return false;
+}
+/**
+ * Grooming-shaped hard blocks on a single message. Tighter than the session
+ * counters so normal game talk ("don't tell the boss") still passes.
+ */
+export const GROOMING_PATTERNS = [
+    /don'?t\s+tell\s+(?:your|my|our|his|her|their)\s+(?:parents?|parent|mom|dad|mother|father|grown-?ups?|guardian)/gi,
+    /do\s+not\s+tell\s+(?:your|my|our)\s+(?:parents?|parent|mom|dad|mother|father|grown-?ups?)/gi,
+    /keep\s+(?:this|it|our\s+chats?)\s+(?:a\s+)?secret\s+from\s+(?:your|my|our)\s+(?:parents?|mom|dad)/gi,
+    /without\s+(?:your|my|our)\s+(?:parents?|mom|dad|mother|father)\s+(?:seeing|knowing|finding)/gi,
+    /our\s+little\s+secret\b/gi,
+    /this\s+is\s+our\s+secret\b/gi,
+    /just\s+between\s+us\b/gi,
+    /secret\s+between\s+(?:us|you\s+and\s+me)\b/gi,
+    /no\s+one\s+(?:has\s+to|needs\s+to|will)\s+know\b/gi,
+    /add\s+me\s+on\s+(?:snapchat|instagram|whatsapp|telegram|discord|tiktok|kik|signal)\b/gi,
+    /(?:message|dm)\s+me\s+on\s+(?:snapchat|instagram|whatsapp|telegram|discord|tiktok|kik|signal)\b/gi,
+    /text\s+me\s+at\b/gi,
+    /\bdm\s+me\b/gi,
+    /let'?s\s+(?:chat|talk)\s+on\s+(?:snapchat|instagram|whatsapp|telegram|discord|tiktok)\b/gi,
+    // "special/only friend" + love probes; bare "i love you" stays allowed for stories.
+    /you'?re\s+my\s+(?:special|only)\s+friend\b/gi,
+    /do\s+you\s+love\s+me\b/gi,
+    /love\s+me\s+more\s+than\s+anyone\b/gi,
+];
+/** True when the text matches a grooming hard-block family. */
+export function hasGrooming(text) {
+    const prepared = normalizeText(text);
+    return GROOMING_PATTERNS.some((re) => {
+        re.lastIndex = 0;
+        return re.test(prepared);
+    });
+}
+/**
+ * Self-harm intent and soft ideation. Routes to the supportive screen.
+ * Game words (die, kill boss) are not listed here.
+ */
+export const SELF_HARM_PATTERNS = [
+    /\b(?:i\s+)?want\s+to\s+hurt\s+myself\b/gi,
+    /\b(?:i\s+)?want\s+to\s+kill\s+myself\b/gi,
+    /\bkill\s+myself\b/gi,
+    /\bend\s+my\s+life\b/gi,
+    /\bsuicide\b/gi,
+    /\bself[-\s]?harm\b/gi,
+    /\bbetter\s+off\s+without\s+me\b/gi,
+    /\bno\s+reason\s+to\s+live\b/gi,
+    /\bwish\s+i\s+(?:was|were)\s+dead\b/gi,
+    /\bi\s+(?:want|wanna)\s+to\s+die\b/gi,
+    /\bhow\s+(?:can|do)\s+i\s+(?:kill|hurt)\s+myself\b/gi,
+    /\beasiest\s+way\s+to\s+(?:kill|hurt)\s+myself\b/gi,
+];
+/** True when the text shows self-harm intent or ideation. */
+export function hasSelfHarm(text) {
+    const prepared = normalizeText(text);
+    return SELF_HARM_PATTERNS.some((re) => {
+        re.lastIndex = 0;
+        return re.test(prepared);
+    });
+}
+/**
+ * Probes for personal details aimed at a child (or role-played as such).
+ * Sharing your own details is handled by redactPii; these block the ask.
+ */
+export const PII_PROBE_PATTERNS = [
+    /what(?:'s|\s+is)\s+your\s+real\s+(?:name|address|phone|number)\b/gi,
+    /what\s+school\s+do\s+you\b/gi,
+    /which\s+school\s+do\s+you\b/gi,
+    /what\s+school\s+do\s+you\s+go\s+to\b/gi,
+    /when\s+does\s+(?:school|it)\s+end\b/gi,
+    /where\s+do\s+you\s+live\b/gi,
+    /send\s+(?:me\s+)?(?:a\s+)?(?:photo|picture|pic|selfie)\b/gi,
+    /how\s+old\s+are\s+you\s+really\b/gi,
+    /your\s+(?:home\s+)?address\b/gi,
+    /your\s+phone\s+number\b/gi,
+];
+/** True when the text probes for personal details. */
+export function hasPiiProbe(text) {
+    const prepared = normalizeText(text);
+    return PII_PROBE_PATTERNS.some((re) => {
         re.lastIndex = 0;
         return re.test(prepared);
     });
@@ -160,23 +278,39 @@ export function redactPii(text) {
     return { redacted, found };
 }
 function blockVerdict(category) {
+    const selfHarmConcern = category === 'self_harm';
+    // L0 always hard-blocks when it fires. Severity is for the audit trail:
+    // self-harm is marked serious (2); everything else is mild (1), matching
+    // the prior prefilter behavior for profanity and jailbreak.
+    const severity = category === 'self_harm' ? 2 : 1;
     return {
         allowed: false,
         categories: [category],
-        severity: 1,
-        selfHarmConcern: false,
+        severity,
+        selfHarmConcern,
         failClosed: false,
-        kidMessage: T.blocks.byCategory[category],
+        kidMessage: selfHarmConcern ? T.selfHarmSupport.message : T.blocks.byCategory[category],
     };
 }
 /**
- * L0 check for kid input. Jailbreak and profanity block (kindly).
- * PII redacts with a gentle reminder, never blocks.
+ * L0 check for kid input. Jailbreak, profanity, grooming, self-harm, and
+ * personal-detail probes block (kindly). Shared personal details redact
+ * with a gentle reminder and never block on their own.
  */
 export function prefilterInput(text) {
+    // Self-harm first so the supportive screen wins over other matches.
+    if (hasSelfHarm(text)) {
+        return { ok: false, redacted: text, notice: null, block: blockVerdict('self_harm') };
+    }
     if (hasJailbreak(text)) {
         return { ok: false, redacted: text, notice: null, block: blockVerdict('jailbreak') };
     }
+    if (hasGrooming(text)) {
+        return { ok: false, redacted: text, notice: null, block: blockVerdict('grooming') };
+    }
+    if (hasPiiProbe(text)) {
+        return { ok: false, redacted: text, notice: null, block: blockVerdict('pii') };
+    }
     if (hasProfanity(text)) {
         return { ok: false, redacted: text, notice: null, block: blockVerdict('profanity') };
     }

package/dist/update/check.js

@@ -0,0 +1,104 @@
+/**
+ * npm registry version check with a short disk cache so session start stays
+ * snappy. Fail-open: network errors never block Termi from starting.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { atomicWriteFileSync, termiHome } from '../config/paths.js';
+import { isNewerVersion, NPM_PACKAGE, readLocalVersion } from './version.js';
+/** How long a successful registry answer is reused. */
+export const VERSION_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
+/** Hard cap on the registry round-trip so boot never hangs. */
+export const VERSION_FETCH_TIMEOUT_MS = 2500;
+export function versionCachePath() {
+    return path.join(termiHome(), 'version-check.json');
+}
+function readCache() {
+    try {
+        const raw = fs.readFileSync(versionCachePath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.fetchedAt === 'string' &&
+            typeof parsed.latest === 'string' &&
+            typeof parsed.currentAtFetch === 'string') {
+            return {
+                fetchedAt: parsed.fetchedAt,
+                latest: parsed.latest,
+                currentAtFetch: parsed.currentAtFetch,
+            };
+        }
+    }
+    catch {
+        // Missing or corrupt cache is fine.
+    }
+    return null;
+}
+function writeCache(cache) {
+    try {
+        atomicWriteFileSync(versionCachePath(), `${JSON.stringify(cache, null, 2)}\n`);
+    }
+    catch {
+        // Cache is best-effort.
+    }
+}
+/**
+ * Returns the latest published version from the npm registry, or null on
+ * any failure. Uses a 6-hour on-disk cache.
+ */
+export async function fetchLatestVersion(opts = {}) {
+    const now = opts.now ?? Date.now();
+    if (!opts.force) {
+        const cached = readCache();
+        if (cached !== null) {
+            const age = now - Date.parse(cached.fetchedAt);
+            if (Number.isFinite(age) && age >= 0 && age < VERSION_CACHE_TTL_MS && cached.latest.length > 0) {
+                return cached.latest;
+            }
+        }
+    }
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const timeoutMs = opts.timeoutMs ?? VERSION_FETCH_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetchImpl(`https://registry.npmjs.org/${NPM_PACKAGE}/latest`, {
+            signal: controller.signal,
+            headers: { accept: 'application/json' },
+        });
+        if (!res.ok) {
+            return null;
+        }
+        const body = (await res.json());
+        if (typeof body.version !== 'string' || body.version.length === 0) {
+            return null;
+        }
+        writeCache({
+            fetchedAt: new Date(now).toISOString(),
+            latest: body.version,
+            currentAtFetch: readLocalVersion(),
+        });
+        return body.version;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Compares the running install to the latest npm version.
+ * Never throws. Offline or timeout => skipped, updateAvailable false.
+ */
+export async function checkForUpdate(opts = {}) {
+    const current = readLocalVersion();
+    const latest = await fetchLatestVersion(opts);
+    if (latest === null) {
+        return { current, latest: null, updateAvailable: false, skipped: true, reason: 'registry-unavailable' };
+    }
+    return {
+        current,
+        latest,
+        updateAvailable: isNewerVersion(latest, current),
+        skipped: false,
+    };
+}

package/dist/update/install.js

@@ -0,0 +1,29 @@
+/**
+ * Installs the latest termi-kids from npm into the global prefix.
+ */
+import { spawn } from 'node:child_process';
+import { NPM_PACKAGE } from './version.js';
+/**
+ * Runs `npm install -g termi-kids@latest` and waits for exit.
+ * Streams npm output to the parent so parents can see progress.
+ */
+export function installLatestUpdate(opts = {}) {
+    const spawnImpl = opts.spawnImpl ?? spawn;
+    return new Promise((resolve) => {
+        const child = spawnImpl('npm', ['install', '-g', `${NPM_PACKAGE}@latest`], {
+            stdio: 'inherit',
+            env: opts.env ?? process.env,
+            shell: process.platform === 'win32',
+        });
+        child.on('error', (err) => {
+            resolve({ ok: false, code: null, detail: err.message });
+        });
+        child.on('close', (code) => {
+            resolve({
+                ok: code === 0,
+                code,
+                detail: code === 0 ? 'updated' : `npm exited with code ${code ?? 'unknown'}`,
+            });
+        });
+    });
+}

package/dist/update/prompt.js

@@ -0,0 +1,78 @@
+/**
+ * Session-start update prompt and the `termi update` command body.
+ */
+import * as p from '@clack/prompts';
+import { style } from '../ui/theme.js';
+import { checkForUpdate } from './check.js';
+import { installLatestUpdate } from './install.js';
+import { NPM_PACKAGE, readLocalVersion } from './version.js';
+/** Env flag tests (and power users) use to skip the network check. */
+export const SKIP_UPDATE_ENV = 'TERMI_SKIP_UPDATE';
+export function shouldSkipUpdateCheck() {
+    if (process.env.VITEST !== undefined || process.env.NODE_ENV === 'test') {
+        return true;
+    }
+    const flag = process.env[SKIP_UPDATE_ENV];
+    return flag === '1' || flag === 'true' || flag === 'yes';
+}
+/**
+ * Quiet check used on every normal session start. Asks y/n when a newer
+ * version is on npm. Fail-open: errors and skips never interrupt the kid.
+ */
+export async function maybePromptForUpdate() {
+    if (shouldSkipUpdateCheck()) {
+        return;
+    }
+    let result;
+    try {
+        result = await checkForUpdate();
+    }
+    catch {
+        return;
+    }
+    if (!result.updateAvailable || result.latest === null) {
+        return;
+    }
+    console.log('');
+    console.log(style.title(`A new Termi is ready: v${result.latest}`) +
+        style.dim(` (you have v${result.current})`));
+    const answer = await p.confirm({
+        message: 'Update Termi now?',
+        initialValue: true,
+    });
+    if (p.isCancel(answer) || answer !== true) {
+        console.log(style.dim('Okay. You can run "termi update" later.'));
+        console.log('');
+        return;
+    }
+    await runUpdateCommand({ quietCheck: true });
+}
+/**
+ * `termi update`: always checks npm and installs when newer (or forced).
+ */
+export async function runUpdateCommand(opts = {}) {
+    const current = readLocalVersion();
+    if (!opts.quietCheck) {
+        console.log(`Termi v${current} (${NPM_PACKAGE})`);
+        console.log('Checking for a newer version...');
+    }
+    const result = await checkForUpdate({ force: true });
+    if (result.skipped || result.latest === null) {
+        console.log('Could not reach npm right now. Try again later.');
+        return;
+    }
+    if (!result.updateAvailable) {
+        console.log(`You already have the latest version (v${result.current}).`);
+        return;
+    }
+    console.log(`Updating ${NPM_PACKAGE} from v${result.current} to v${result.latest}...`);
+    const install = await installLatestUpdate();
+    if (!install.ok) {
+        console.log('The update did not finish.');
+        console.log(style.dim(install.detail));
+        console.log(style.dim(`You can also run: npm install -g ${NPM_PACKAGE}@latest`));
+        return;
+    }
+    console.log(`Updated to v${result.latest}.`);
+    console.log('Quit and run termi again to use the new version.');
+}

package/dist/update/version.js

@@ -0,0 +1,42 @@
+/**
+ * Local version helpers and semver compare for the update checker.
+ */
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+/** npm package name. The CLI bin is still `termi`. */
+export const NPM_PACKAGE = 'termi-kids';
+/** Reads the version embedded next to the built dist (package.json). */
+export function readLocalVersion() {
+    try {
+        // dist/update/version.js -> package.json at package root
+        const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../package.json');
+        const raw = fs.readFileSync(pkgPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === 'string' ? parsed.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** Parse a simple x.y.z (or vX.Y.Z) version; non-numeric parts become 0. */
+export function parseSemver(version) {
+    const cleaned = version.trim().replace(/^v/i, '');
+    const parts = cleaned.split(/[.+-]/).slice(0, 3).map((p) => {
+        const n = Number.parseInt(p, 10);
+        return Number.isFinite(n) && n >= 0 ? n : 0;
+    });
+    return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+}
+/** True when latest is strictly newer than current. */
+export function isNewerVersion(latest, current) {
+    const a = parseSemver(latest);
+    const b = parseSemver(current);
+    for (let i = 0; i < 3; i++) {
+        if (a[i] > b[i])
+            return true;
+        if (a[i] < b[i])
+            return false;
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termi-kids",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Termi is a friendly coding buddy for kids. Build games, art, stories, and websites right from your computer, with a grown-up approved AI helper and strong safety rails.",
   "keywords": [
     "kids",