npm - dominds - Versions diffs - 1.2.5 → 1.2.7 - Mend

dominds 1.2.5 → 1.2.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (149) hide show

package/dist/static/index.html CHANGED Viewed

@@ -52,7 +52,7 @@
         padding: 20px;
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-HWTRvE2k.js"></script>
+    <script type="module" crossorigin src="/assets/index-D3TQbAKh.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BiNcBn_U.css">
   </head>
   <body>

package/dist/team.js CHANGED Viewed

@@ -699,38 +699,14 @@ exports.Team = Team;
                 finalizeProblems();
                 return team;
             }
-            // Apps: merge enabled app teammate definitions (additive).
+            let appTeammates = [];
             try {
-                const appTeammates = await (0, teammates_1.loadEnabledAppTeammates)({ rtwsRootAbs: process.cwd() });
-                if (appTeammates.length > 0) {
-                    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-                        addIssue('apps/teammates/invalid_base', 'Failed to merge app teammates into .minds/team.yaml: base YAML is not an object.', `Expected .minds/team.yaml to parse into an object before applying app teammate merges.`);
-                    }
-                    else {
-                        const rec = parsed;
-                        const membersRaw = rec['members'];
-                        const members = typeof membersRaw === 'object' && membersRaw !== null && !Array.isArray(membersRaw)
-                            ? membersRaw
-                            : {};
-                        if (rec['members'] === undefined) {
-                            rec['members'] = members;
-                        }
-                        for (const snip of appTeammates) {
-                            for (const [id, member] of Object.entries(snip.members)) {
-                                if (Object.prototype.hasOwnProperty.call(members, id)) {
-                                    addIssue(`apps/teammates/duplicate_member/${sanitizeProblemIdSegment(id)}`, 'App teammate id collision while loading .minds/team.yaml.', `Enabled app '${snip.appId}' contributes member id '${id}', but it already exists in team.yaml (or another app). Disable/uninstall the conflicting app or rename the member id.`);
-                                    continue;
-                                }
-                                members[id] = member;
-                            }
-                        }
-                    }
-                }
+                appTeammates = await (0, teammates_1.loadEnabledAppTeammates)({ rtwsRootAbs: process.cwd() });
             }
             catch (err) {
                 addIssue('apps/teammates/load', 'Failed to load enabled app teammates.', err instanceof Error ? err.message : String(err));
             }
-            const parsedTeam = parseTeamYamlObject(parsed, md, { fuxi, pangu });
+            const parsedTeam = parseTeamYamlObject(parsed, md, { fuxi, pangu }, { appTeammates });
             for (const issue of parsedTeam.issues) {
                 addIssue(issue.id, issue.message, issue.errorText);
             }
@@ -1306,11 +1282,15 @@ exports.Team = Team;
         if (overrides.hidden !== undefined)
             member.setHidden(overrides.hidden);
     }
-    function parseTeamYamlObject(obj, md, shadow) {
+    function parseTeamYamlObject(obj, md, shadow, deps) {
         const issues = [];
         const pushIssue = (id, message, errorText) => {
             issues.push({ id, message, errorText });
         };
+        const appMembersByAppId = new Map();
+        for (const snip of deps.appTeammates) {
+            appMembersByAppId.set(snip.appId, snip.members);
+        }
         const teamObj = (() => {
             if (isRecordValue(obj))
                 return obj;
@@ -1394,9 +1374,9 @@ exports.Team = Team;
                 pushIssue(`members/${idSeg}`, `Invalid .minds/team.yaml: ${memberAt} must be an object.`, `Invalid ${memberAt}: expected an object (got ${describeValueType(raw)})`);
                 continue;
             }
-            // Cross-app teammate reference (draft): members.<id>.from + (use|import).
-            // v0 behavior: fail-open, only surface Problems; runtime still treats the member as local.
-            {
+            // Cross-app teammate reference (v0): members.<id>.from + (use|import).
+            // Fail-open: surface Problems, but keep Team usable.
+            const effectiveRaw = (() => {
                 const memberObj = raw;
                 const hasFrom = hasOwnKey(memberObj, 'from');
                 const hasUse = hasOwnKey(memberObj, 'use');
@@ -1405,34 +1385,58 @@ exports.Team = Team;
                 const useRaw = hasUse ? memberObj['use'] : undefined;
                 const importRaw = hasImport ? memberObj['import'] : undefined;
                 // Problem id should stay short and stable: it is a UI address, not a stack trace.
-                // During the transition, team definitions can come from multiple scopes (rtws/kernel/apps).
-                // This validator currently runs on the effective rtws `.minds/team.yaml` object.
+                // This validator runs on the effective rtws `.minds/team.yaml` object.
                 const definingScopeSeg = 'rtws';
                 const memberPrefix = `members/${definingScopeSeg}/${idSeg}`;
                 if (hasUse && hasImport) {
                     pushIssue(`${memberPrefix}/use_and_import_conflict`, `Invalid .minds/team.yaml: ${memberAt} cannot specify both 'use' and 'import'.`, `Both ${memberAt}.use and ${memberAt}.import are present; remove one.`);
+                    return memberObj;
                 }
                 if ((hasUse || hasImport) && !hasFrom) {
                     pushIssue(`${memberPrefix}/from/missing`, `Invalid .minds/team.yaml: ${memberAt} uses cross-app member reference but is missing 'from'.`, `Either remove ${memberAt}.use/${memberAt}.import, or add ${memberAt}.from: <dep-app-id>.`);
+                    return memberObj;
                 }
-                if (hasFrom) {
-                    if (typeof fromRaw !== 'string' || fromRaw.trim() === '') {
-                        pushIssue(`${memberPrefix}/from/invalid`, `Invalid .minds/team.yaml: ${memberAt}.from must be a non-empty string.`, `Invalid ${memberAt}.from: expected non-empty string (got ${describeValueType(fromRaw)})`);
-                    }
+                if (!hasFrom)
+                    return memberObj;
+                if (typeof fromRaw !== 'string' || fromRaw.trim() === '') {
+                    pushIssue(`${memberPrefix}/from/invalid`, `Invalid .minds/team.yaml: ${memberAt}.from must be a non-empty string.`, `Invalid ${memberAt}.from: expected non-empty string (got ${describeValueType(fromRaw)})`);
+                    return memberObj;
                 }
-                if (hasUse) {
-                    if (typeof useRaw !== 'string' || useRaw.trim() === '') {
-                        pushIssue(`${memberPrefix}/use/invalid`, `Invalid .minds/team.yaml: ${memberAt}.use must be a non-empty string.`, `Invalid ${memberAt}.use: expected non-empty string (got ${describeValueType(useRaw)})`);
-                    }
+                // `from`-only is accepted (v0 no-op): treat it as a local member definition.
+                if (!hasUse && !hasImport)
+                    return memberObj;
+                const refKind = hasUse ? 'use' : 'import';
+                const refRaw = hasUse ? useRaw : importRaw;
+                if (typeof refRaw !== 'string' || refRaw.trim() === '') {
+                    pushIssue(`${memberPrefix}/${refKind}/invalid`, `Invalid .minds/team.yaml: ${memberAt}.${refKind} must be a non-empty string.`, `Invalid ${memberAt}.${refKind}: expected non-empty string (got ${describeValueType(refRaw)})`);
+                    return memberObj;
                 }
-                if (hasImport) {
-                    if (typeof importRaw !== 'string' || importRaw.trim() === '') {
-                        pushIssue(`${memberPrefix}/import/invalid`, `Invalid .minds/team.yaml: ${memberAt}.import must be a non-empty string.`, `Invalid ${memberAt}.import: expected non-empty string (got ${describeValueType(importRaw)})`);
-                    }
+                const fromAppId = fromRaw.trim();
+                const refMemberId = refRaw.trim();
+                const appMembers = appMembersByAppId.get(fromAppId);
+                if (!appMembers) {
+                    pushIssue(`${memberPrefix}/from/unresolved_app`, `Invalid .minds/team.yaml: ${memberAt}.from refers to an app that is not enabled.`, `App '${fromAppId}' is not enabled (or does not export teammates YAML).`);
+                    return memberObj;
                 }
-            }
-            validateCommonModelParamMisplacements(pushIssue, `members/${idSeg}`, memberAt, raw);
-            const parsedMember = parseMemberOverrides(raw, memberAt);
+                const sourceRaw = appMembers[refMemberId];
+                if (sourceRaw === undefined) {
+                    pushIssue(`${memberPrefix}/${refKind}/unresolved_member`, `Invalid .minds/team.yaml: ${memberAt}.${refKind} refers to a missing member in app '${fromAppId}'.`, `App '${fromAppId}' does not export member id '${refMemberId}'.`);
+                    return memberObj;
+                }
+                if (!isRecordValue(sourceRaw)) {
+                    pushIssue(`${memberPrefix}/${refKind}/invalid_member`, `Invalid app teammates YAML: member '${refMemberId}' must be an object (app '${fromAppId}').`, `Expected app member '${fromAppId}.${refMemberId}' to be an object (got ${describeValueType(sourceRaw)}).`);
+                    return memberObj;
+                }
+                const merged = { ...sourceRaw };
+                for (const [k, v] of Object.entries(memberObj)) {
+                    if (k === 'from' || k === 'use' || k === 'import')
+                        continue;
+                    merged[k] = v;
+                }
+                return merged;
+            })();
+            validateCommonModelParamMisplacements(pushIssue, `members/${idSeg}`, memberAt, effectiveRaw);
+            const parsedMember = parseMemberOverrides(effectiveRaw, memberAt);
             if (parsedMember.kind === 'error') {
                 pushIssue(`members/${idSeg}`, `Invalid .minds/team.yaml: ${memberAt} has invalid fields.`, parsedMember.errorTexts.join('\n'));
                 if (id === 'fuxi' || id === 'pangu') {

package/dist/tellask.js ADDED Viewed

@@ -0,0 +1,439 @@
+"use strict";
+/**
+ * # Tellask Grammar ("诉请")
+ *
+ * A primitive, line-based streaming call format designed to be robust under arbitrary
+ * upstream chunk boundaries (no backtick/markdown state machine required).
+ *
+ * ## Rules
+ *
+ * - Tellask call blocks consist of **lines**.
+ * - Any line starting with literal `!?` is a tellask line (prefix is not included in payload).
+ * - Any line(s) **without** `!?` prefix are treated as markdown, and also act as separators:
+ *   they terminate the current tellask call block (if any).
+ *
+ * Within a tellask call block:
+ * - The first tellask line is the start of the call headline.
+ * - The first line MUST start with `!?@<valid-mention-id>` to be considered valid.
+ *   Otherwise the block still parses, but is reported as malformed.
+ * - While still in headline phase, subsequent tellask lines starting with `!?@` extend
+ *   the headline (multiline headline).
+ * - Any other tellask lines (starting with `!?` but NOT `!?@`) start/continue the call body.
+ *
+ * All downstream chunks preserve upstream chunk boundaries unless correctness requires
+ * a split (e.g. line-start prefix disambiguation across chunks).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TellaskStreamParser = void 0;
+const id_1 = require("./utils/id");
+class TellaskStreamParser {
+    constructor(downstream) {
+        this.callCounter = 0;
+        this.collectedCalls = [];
+        this.markdownStarted = false;
+        this.markdownChunkBuffer = '';
+        this.activeCall = null;
+        this.headlineBuffer = '';
+        this.bodyBuffer = '';
+        this.isAtLineStart = true;
+        this.lineStartProbe = '';
+        this.currentLineKind = 'unknown';
+        this.pendingCallLineRole = false;
+        this.currentCallLineRole = null;
+        // Total raw upstream characters consumed so far.
+        this.upstreamPos = 0;
+        this.downstream = downstream;
+    }
+    async takeUpstreamChunk(chunk) {
+        let pos = 0;
+        while (pos < chunk.length) {
+            const char = chunk[pos] ?? '';
+            if (this.isAtLineStart && this.currentLineKind === 'unknown') {
+                const consumed = await this.processLineStartProbe(char);
+                if (consumed) {
+                    pos += 1;
+                    this.upstreamPos += 1;
+                    continue;
+                }
+                // Not consumed means we decided the line kind and need to re-process this char
+                // with the decided line kind.
+            }
+            if (this.currentLineKind === 'markdown') {
+                await this.processMarkdownChar(char);
+                pos += 1;
+                this.upstreamPos += 1;
+                continue;
+            }
+            if (this.currentLineKind === 'call') {
+                await this.processCallChar(char);
+                pos += 1;
+                this.upstreamPos += 1;
+                continue;
+            }
+            // Fallback: should be unreachable, but keep safe to avoid infinite loops.
+            await this.processMarkdownChar(char);
+            pos += 1;
+            this.upstreamPos += 1;
+        }
+        await this.flushAtUpstreamChunkEnd();
+    }
+    async finalize() {
+        // Resolve any pending single-char probe at start-of-line.
+        if (this.isAtLineStart && this.currentLineKind === 'unknown' && this.lineStartProbe === '!') {
+            // This is a markdown separator line starting with '!' but not enough chars to be `!?`.
+            await this.endActiveCallBlockIfAny();
+            this.markdownChunkBuffer += '!';
+            this.lineStartProbe = '';
+        }
+        // End-of-input can terminate a call without a trailing newline.
+        if (this.activeCall) {
+            await this.resolvePendingFirstLineMentionAtEofIfNeeded();
+            await this.endActiveCallBlockIfAny();
+        }
+        if (this.markdownChunkBuffer.length > 0) {
+            if (!this.markdownStarted) {
+                await this.downstream.markdownStart();
+                this.markdownStarted = true;
+            }
+            await this.downstream.markdownChunk(this.markdownChunkBuffer);
+            this.markdownChunkBuffer = '';
+        }
+        if (this.markdownStarted) {
+            await this.downstream.markdownFinish();
+            this.markdownStarted = false;
+        }
+    }
+    getCollectedCalls() {
+        return [...this.collectedCalls];
+    }
+    async processLineStartProbe(char) {
+        // Returns true if the character was consumed as part of probing decision.
+        if (this.lineStartProbe === '') {
+            if (char === '\n') {
+                // Empty line is markdown separator.
+                await this.endActiveCallBlockIfAny();
+                this.currentLineKind = 'markdown';
+                await this.processMarkdownChar(char);
+                this.resetLineStateAfterNewline();
+                return true;
+            }
+            this.lineStartProbe = '!';
+            if (char !== '!') {
+                // First char isn't '!' => markdown line.
+                this.lineStartProbe = '';
+                await this.endActiveCallBlockIfAny();
+                this.currentLineKind = 'markdown';
+                // Re-process this char as markdown.
+                return false;
+            }
+            // We saw '!' at column 0; need one more char to decide.
+            return true;
+        }
+        // lineStartProbe === '!' means we already consumed a '!' at strict column 0.
+        if (char === '\n') {
+            // Line length is 1 => markdown line containing '!\n'.
+            this.lineStartProbe = '';
+            await this.endActiveCallBlockIfAny();
+            this.currentLineKind = 'markdown';
+            this.markdownChunkBuffer += '!\n';
+            this.resetLineStateAfterNewline();
+            return true;
+        }
+        if (char === '?') {
+            // Confirmed call line prefix `!?` at column 0.
+            this.lineStartProbe = '';
+            await this.ensureCallLineModeStart();
+            return true;
+        }
+        // Not `!?` => markdown line starting with '!' then current char.
+        this.lineStartProbe = '';
+        await this.endActiveCallBlockIfAny();
+        this.currentLineKind = 'markdown';
+        this.markdownChunkBuffer += '!' + char;
+        this.isAtLineStart = false;
+        return true;
+    }
+    async ensureCallLineModeStart() {
+        // Transition from markdown to call line: finalize markdown fragment if active.
+        if (this.markdownChunkBuffer.length > 0) {
+            if (!this.markdownStarted) {
+                await this.downstream.markdownStart();
+                this.markdownStarted = true;
+            }
+            await this.downstream.markdownChunk(this.markdownChunkBuffer);
+            this.markdownChunkBuffer = '';
+        }
+        if (this.markdownStarted) {
+            await this.downstream.markdownFinish();
+            this.markdownStarted = false;
+        }
+        this.currentLineKind = 'call';
+        this.isAtLineStart = false;
+        this.pendingCallLineRole = true;
+        this.currentCallLineRole = null;
+        if (!this.activeCall) {
+            this.activeCall = {
+                kind: 'active',
+                validation: null,
+                firstLineMentionParse: { kind: 'pending_first_char' },
+                tellaskHead: '',
+                body: '',
+                callLineIndex: 0,
+                phase: 'headline',
+                tellaskHeadFinished: false,
+                bodyStarted: false,
+                callStartEmitted: false,
+            };
+        }
+        else {
+            this.activeCall.callLineIndex += 1;
+        }
+    }
+    async processMarkdownChar(char) {
+        // Markdown content includes all characters verbatim.
+        this.markdownChunkBuffer += char;
+        if (char === '\n') {
+            this.resetLineStateAfterNewline();
+        }
+        else {
+            this.isAtLineStart = false;
+        }
+    }
+    async processCallChar(char) {
+        const call = this.activeCall;
+        if (!call) {
+            // Should never happen: call line implies active call. Fall back to markdown.
+            await this.processMarkdownChar(char);
+            return;
+        }
+        if (this.pendingCallLineRole) {
+            const role = this.decideCallLineRole(call, char);
+            this.pendingCallLineRole = false;
+            this.currentCallLineRole = role;
+            if (role === 'body') {
+                if (call.phase === 'headline') {
+                    await this.finishHeadlineIfNeeded();
+                    await this.startBodyIfNeeded();
+                    call.phase = 'body';
+                }
+            }
+        }
+        // First line mention validation is based on the first tellask line only.
+        if (call.callLineIndex === 0 && call.phase === 'headline') {
+            await this.processFirstLineMentionParse(char);
+        }
+        if (this.currentCallLineRole === 'headline') {
+            this.headlineBuffer += char;
+        }
+        else {
+            this.bodyBuffer += char;
+        }
+        if (char === '\n') {
+            this.resetLineStateAfterNewline();
+        }
+        else {
+            this.isAtLineStart = false;
+        }
+    }
+    decideCallLineRole(call, firstCharAfterPrefix) {
+        if (call.phase === 'body')
+            return 'body';
+        if (call.callLineIndex === 0)
+            return 'headline';
+        return firstCharAfterPrefix === '@' ? 'headline' : 'body';
+    }
+    async processFirstLineMentionParse(char) {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        const parse = call.firstLineMentionParse;
+        if (parse.kind === 'resolved')
+            return;
+        if (parse.kind === 'pending_first_char') {
+            if (char === '\n') {
+                await this.resolveFirstLineMention({ kind: 'malformed', reason: 'missing_mention_prefix' });
+                return;
+            }
+            if (char !== '@') {
+                await this.resolveFirstLineMention({ kind: 'malformed', reason: 'missing_mention_prefix' });
+                return;
+            }
+            call.firstLineMentionParse = { kind: 'pending_mention_chars', raw: '' };
+            return;
+        }
+        if (parse.kind === 'pending_mention_chars') {
+            if (this.isValidMentionChar(char)) {
+                call.firstLineMentionParse = { kind: 'pending_mention_chars', raw: parse.raw + char };
+                return;
+            }
+            const trimmed = this.trimTrailingDots(parse.raw);
+            if (trimmed.length > 0) {
+                await this.resolveFirstLineMention({ kind: 'valid', firstMention: trimmed });
+            }
+            else {
+                await this.resolveFirstLineMention({ kind: 'malformed', reason: 'invalid_mention_id' });
+            }
+            return;
+        }
+    }
+    async resolveFirstLineMention(validation) {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        call.validation = validation;
+        call.firstLineMentionParse = { kind: 'resolved', validation };
+        if (!call.callStartEmitted) {
+            call.callStartEmitted = true;
+            await this.downstream.callStart(validation);
+        }
+        await this.flushHeadlineBuffer();
+    }
+    async resolvePendingFirstLineMentionAtEofIfNeeded() {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        if (call.callLineIndex !== 0)
+            return;
+        const parse = call.firstLineMentionParse;
+        if (parse.kind === 'resolved')
+            return;
+        if (parse.kind === 'pending_first_char') {
+            await this.resolveFirstLineMention({ kind: 'malformed', reason: 'missing_mention_prefix' });
+            return;
+        }
+        if (parse.kind === 'pending_mention_chars') {
+            const trimmed = this.trimTrailingDots(parse.raw);
+            if (trimmed.length > 0) {
+                await this.resolveFirstLineMention({ kind: 'valid', firstMention: trimmed });
+            }
+            else {
+                await this.resolveFirstLineMention({ kind: 'malformed', reason: 'invalid_mention_id' });
+            }
+        }
+    }
+    async finishHeadlineIfNeeded() {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        if (call.tellaskHeadFinished)
+            return;
+        if (!call.callStartEmitted) {
+            // If the first line did not contain a mention terminator, we resolve at boundary.
+            await this.resolvePendingFirstLineMentionAtEofIfNeeded();
+        }
+        await this.flushHeadlineBuffer();
+        await this.downstream.callHeadLineFinish();
+        call.tellaskHeadFinished = true;
+    }
+    async startBodyIfNeeded() {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        if (call.bodyStarted)
+            return;
+        await this.downstream.tellaskBodyStart();
+        call.bodyStarted = true;
+    }
+    async endActiveCallBlockIfAny() {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        const upstreamEndOffset = this.upstreamPos;
+        // If the first line never encountered an invalid mention delimiter, ensure we still resolve.
+        await this.resolvePendingFirstLineMentionAtEofIfNeeded();
+        await this.finishHeadlineIfNeeded();
+        if (call.bodyStarted) {
+            await this.flushBodyBuffer();
+            await this.downstream.tellaskBodyFinish();
+        }
+        const validation = call.validation ?? { kind: 'malformed', reason: 'missing_mention_prefix' };
+        const callId = (0, id_1.generateContentHash)(`tellask\n${validation.kind === 'valid' ? validation.firstMention : ''}\n${call.tellaskHead}\n${call.body}`, this.callCounter++);
+        const collected = {
+            validation,
+            tellaskHead: call.tellaskHead,
+            body: call.body,
+            callId,
+        };
+        this.collectedCalls.push(collected);
+        await this.downstream.callFinish(collected, upstreamEndOffset);
+        this.activeCall = null;
+        this.headlineBuffer = '';
+        this.bodyBuffer = '';
+        this.pendingCallLineRole = false;
+        this.currentCallLineRole = null;
+    }
+    resetLineStateAfterNewline() {
+        this.isAtLineStart = true;
+        this.lineStartProbe = '';
+        this.currentLineKind = 'unknown';
+        this.pendingCallLineRole = false;
+        this.currentCallLineRole = null;
+    }
+    async flushHeadlineBuffer() {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        if (!call.callStartEmitted)
+            return;
+        if (this.headlineBuffer.length === 0)
+            return;
+        call.tellaskHead += this.headlineBuffer;
+        await this.downstream.callHeadLineChunk(this.headlineBuffer);
+        this.headlineBuffer = '';
+    }
+    async flushBodyBuffer() {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        if (this.bodyBuffer.length === 0)
+            return;
+        call.body += this.bodyBuffer;
+        await this.downstream.tellaskBodyChunk(this.bodyBuffer);
+        this.bodyBuffer = '';
+    }
+    async flushAtUpstreamChunkEnd() {
+        if (this.markdownChunkBuffer.length > 0) {
+            if (!this.markdownStarted) {
+                await this.downstream.markdownStart();
+                this.markdownStarted = true;
+            }
+            await this.downstream.markdownChunk(this.markdownChunkBuffer);
+            this.markdownChunkBuffer = '';
+        }
+        const call = this.activeCall;
+        if (call) {
+            if (call.callLineIndex === 0) {
+                const parse = call.firstLineMentionParse;
+                if (parse.kind === 'pending_mention_chars' && parse.raw.length > 0) {
+                    // Do nothing: we cannot resolve until a delimiter/newline/EOF.
+                }
+            }
+            await this.flushHeadlineBuffer();
+            if (call.bodyStarted) {
+                await this.flushBodyBuffer();
+            }
+        }
+    }
+    isValidMentionChar(char) {
+        const charCode = char.charCodeAt(0);
+        return (
+        // ASCII alphanumeric: a-z, A-Z, 0-9
+        (charCode >= 48 && charCode <= 57) ||
+            (charCode >= 65 && charCode <= 90) ||
+            (charCode >= 97 && charCode <= 122) ||
+            // Special allowed characters
+            char === '_' ||
+            char === '-' ||
+            char === '.' ||
+            // Unicode letters and digits
+            /\p{L}/u.test(char) ||
+            /\p{N}/u.test(char));
+    }
+    trimTrailingDots(value) {
+        let out = value;
+        while (out.endsWith('.'))
+            out = out.slice(0, -1);
+        return out;
+    }
+}
+exports.TellaskStreamParser = TellaskStreamParser;