@openvulcan/dsh-vulcancode 0.0.0-stage → 0.4.0

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/markdown/snapshot.js

@@ -0,0 +1,171 @@
+/** Injection snapshot: full-text parts, catalogs and their budget usage (`snapshot.rs`). */
+import { BUDGET_WARNING_PERCENT } from './constants.js';
+import { lines, viewTitle } from './document.js';
+import { BASE_SECTION_KEY, hasBaseSection } from './scope.js';
+import { estimateTokens } from './tokens.js';
+const PART_LABELS = {
+    user: 'user profile',
+    spaceBase: 'space base',
+    projectBase: 'project base',
+    spaceCatalog: 'space catalog',
+    projectCatalog: 'project catalog',
+};
+/** Whether content needs more than the budget. */
+export function overBudget(usage) {
+    return usage.tokens > usage.budget;
+}
+/** Whether usage reached the warning ratio without exceeding the budget. */
+export function nearBudget(usage) {
+    return !overBudget(usage) && usage.budget > 0 && usage.tokens * 100 >= usage.budget * BUDGET_WARNING_PERCENT;
+}
+/** One usage line for a write receipt. */
+export function renderUsageLine(usage) {
+    const percent = usage.budget === 0 ? 0 : Math.floor(usage.tokens * 100 / usage.budget);
+    return `Injected ${PART_LABELS[usage.part]}: ${usage.tokens}/${usage.budget} tokens (${percent}%).`;
+}
+/** Usage of the full-text part of a scope, for write receipts. */
+export function baseUsage(scope, document, budget) {
+    return fitFullText(fullTextEntries(document.views(scope), scope), fullTextPart(scope), budget).usage;
+}
+/** The injection snapshot of every visible scope. */
+export function buildInjectionSnapshot(documents, budget) {
+    const sections = [];
+    const usage = [];
+    const scopes = [['user', documents.user, 'user'], ['space', documents.space, 'space']];
+    if (documents.project !== undefined)
+        scopes.push(['project', documents.project.document, `project ${documents.project.project.name}`]);
+    for (const [scope, document, label] of scopes) {
+        const views = document.views(scope);
+        const entries = fullTextEntries(views, scope);
+        if (entries.length > 0) {
+            const fitted = fitFullText(entries, fullTextPart(scope), budget);
+            sections.push(`${hasBaseSection(scope) ? `[${label} base]` : `[${label}]`}\n${fitted.text}`);
+            usage.push(fitted.usage);
+        }
+        if (hasBaseSection(scope)) {
+            const catalog = fitCatalog(views, scope === 'space' ? 'spaceCatalog' : 'projectCatalog', budget);
+            if (catalog !== undefined) {
+                const updated = latestUpdate(views);
+                sections.push(`[${label} catalog${updated === undefined ? '' : ` · updated ${updated}`}]\n${catalog.text}`);
+                usage.push(catalog.usage);
+            }
+        }
+    }
+    if (sections.length === 0)
+        return { content: '', usage };
+    return {
+        content: `On conflict, project memory overrides space memory, which overrides the user profile. Catalog lines list titles only; read a node with memory_search before relying on it.\n\n${sections.join('\n\n')}`,
+        usage,
+    };
+}
+function fullTextPart(scope) {
+    switch (scope) {
+        case 'user': return 'user';
+        case 'space': return 'spaceBase';
+        case 'project': return 'projectBase';
+    }
+}
+/** `[title path, rendered entry]` for every non-empty node injected in full. */
+function fullTextEntries(views, scope) {
+    const base = hasBaseSection(scope);
+    return views
+        .filter(view => view.body !== '')
+        .filter(view => !base || view.section === BASE_SECTION_KEY)
+        .map(view => {
+        const path = base ? view.path.slice(1).join(' › ') : view.path.join(' › ');
+        const label = path === '' ? view.path.join(' › ') : path;
+        const entry = view.body.includes('\n')
+            ? `- ${label}:\n${lines(view.body).map(line => line === '' ? '' : `  ${line}`).join('\n')}`
+            : `- ${label}: ${view.body}`;
+        return [label, entry];
+    });
+}
+/** Keep whole entries until the budget is reached and list the omitted titles. */
+function fitFullText(entries, part, budget) {
+    const limit = budget[part];
+    const total = estimateTokens(entries.map(([, entry]) => entry).join('\n'));
+    const kept = [];
+    const omitted = [];
+    let used = 0;
+    for (const [label, entry] of entries) {
+        const cost = estimateTokens(entry) + 1;
+        if (omitted.length === 0 && used + cost <= limit) {
+            used += cost;
+            kept.push(entry);
+        }
+        else {
+            omitted.push(label);
+        }
+    }
+    let text = kept.join('\n');
+    if (omitted.length > 0) {
+        if (text !== '')
+            text += '\n';
+        text += `(over budget; not shown, read with memory_search: ${omitted.join(' · ')})`;
+    }
+    return { text, usage: { part, tokens: total, budget: limit, omitted } };
+}
+/** The catalog at the deepest level that fits, degrading H3 → H2 → section counts. */
+function fitCatalog(views, part, budget) {
+    const roots = views
+        .filter(view => view.locator.length === 1)
+        .filter(view => view.section !== BASE_SECTION_KEY)
+        .filter(view => view.descendants > 0 || view.body !== '');
+    if (roots.length === 0)
+        return undefined;
+    const limit = budget[part];
+    const full = renderCatalog(views, roots, 3);
+    const tokens = estimateTokens(full);
+    for (const [depth, dropped] of [[3, undefined], [2, 'H3'], [1, 'H2 and H3']]) {
+        let text = depth === 3 ? full : renderCatalog(views, roots, depth);
+        if (estimateTokens(text) <= limit) {
+            if (dropped !== undefined)
+                text += '\n(catalog shortened; list it with memory_outline)';
+            return { text, usage: { part, tokens, budget: limit, omitted: dropped === undefined ? [] : [dropped] } };
+        }
+    }
+    const output = [];
+    let used = 0;
+    for (const root of roots) {
+        const line = catalogLine(views, root, 1);
+        const cost = estimateTokens(line) + 1;
+        if (used + cost > limit)
+            break;
+        used += cost;
+        output.push(line);
+    }
+    output.push(`(catalog shortened, ${roots.length - output.length} more section(s); list them with memory_outline)`);
+    return { text: output.join('\n'), usage: { part, tokens, budget: limit, omitted: ['sections'] } };
+}
+function renderCatalog(views, roots, depth) {
+    return roots.map(root => catalogLine(views, root, depth)).join('\n');
+}
+/** One catalog line: `Section(count) › child [grandchildren] · child`. */
+function catalogLine(views, root, depth) {
+    const line = `${viewTitle(root)}(${root.descendants})`;
+    if (depth < 2)
+        return line;
+    const children = directChildren(views, root);
+    if (children.length === 0)
+        return line;
+    const rendered = children.map(child => {
+        if (depth < 3)
+            return viewTitle(child);
+        const grandchildren = directChildren(views, child).map(viewTitle);
+        return grandchildren.length === 0 ? viewTitle(child) : `${viewTitle(child)} [${grandchildren.join(', ')}]`;
+    });
+    return `${line} › ${rendered.join(' · ')}`;
+}
+function directChildren(views, parent) {
+    return views.filter(view => view.locator.length === parent.locator.length + 1 && parent.locator.every((index, position) => view.locator[position] === index));
+}
+/** The date part of the newest update time in a scope. */
+function latestUpdate(views) {
+    let latest;
+    for (const view of views) {
+        const updated = view.meta?.updated;
+        if (updated !== undefined && (latest === undefined || updated > latest))
+            latest = updated;
+    }
+    return latest === undefined ? undefined : [...latest].slice(0, 10).join('');
+}

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/markdown/store.d.ts

@@ -0,0 +1,72 @@
+/**
+ * File layout, project resolution and atomic commits of the memory store (`store.rs`).
+ *
+ * Every function here is synchronous, so within one process two writes can never interleave and
+ * no lock object is needed; the commit still rechecks each file against the text it was read
+ * from, which catches edits made by other processes or by hand.
+ */
+import { MemoryDocument } from './document.js';
+import { MemoryRegistry, type MemoryProject } from './registry.js';
+import type { MemoryScope } from './scope.js';
+export declare const MARKDOWN_DIRECTORY = "markdown";
+/** The project a request runs in, as known to the host. */
+export interface ProjectContext {
+    /** Host project id derived from the project root. */
+    readonly hostProjectId?: string;
+    /** Project root path. */
+    readonly rootPath?: string;
+    /** Explicit memory project chosen in the memory page, overriding the host binding. */
+    readonly memoryProjectId?: string;
+}
+/** The memory project a context addresses: the explicit choice or the host binding. */
+export declare function boundProject(context: ProjectContext, registry: MemoryRegistry): MemoryProject | undefined;
+/** The documents of every scope visible to one request. */
+export interface ScopeDocuments {
+    readonly user: MemoryDocument;
+    readonly space: MemoryDocument;
+    /** Bound memory project and its document, when the host project is bound. */
+    readonly project?: {
+        readonly project: MemoryProject;
+        readonly document: MemoryDocument;
+    };
+}
+export declare function scopeDocument(documents: ScopeDocuments, scope: MemoryScope): MemoryDocument | undefined;
+/** One file change prepared for an atomic commit. */
+export interface PreparedFile {
+    readonly path: string;
+    /** Exact text read before the change; `undefined` when the file did not exist. */
+    readonly original: string | undefined;
+    readonly text: string;
+}
+/** Handle to the memory files under `<dshHome>/vulcan-memory`; nothing is created on disk until a write. */
+export declare class MarkdownMemoryStore {
+    readonly memoryDirectory: string;
+    constructor(memoryDirectory: string);
+    get markdownDirectory(): string;
+    /** The file path of a scope; the project scope needs a memory project id. */
+    scopePath(scope: MemoryScope, memoryProjectId: string | undefined): string;
+    /** The registry; a missing file is empty. */
+    registry(): MemoryRegistry;
+    /** Change the registry and save it when the change succeeds. */
+    updateRegistry<T>(change: (registry: MemoryRegistry) => T): T;
+    /** One scope document; a missing file is an empty document. */
+    load(scope: MemoryScope, memoryProjectId: string | undefined): MemoryDocument;
+    /** Every scope visible to a project context. */
+    loadScopes(context: ProjectContext): ScopeDocuments;
+    /** The exact text of one scope file for whole-file editing. */
+    readFileText(scope: MemoryScope, memoryProjectId: string | undefined): string;
+    /** Replace one whole scope file when it still holds the text the editor started from. */
+    replaceFileText(scope: MemoryScope, memoryProjectId: string | undefined, expected: string, text: string): void;
+}
+/** A file's exact text, or `undefined` when it does not exist. */
+export declare function readOptional(file: string): string | undefined;
+/** Write text through a sibling temporary file and an atomic rename. */
+export declare function writeAtomically(file: string, text: string): void;
+/** Retry `operation` only for transient Windows replacement failures. */
+export declare function retryFileMutation(operation: () => void): void;
+/** Atomically replace `destination` with `temporary`, retrying transient Windows sharing failures. */
+export declare function replaceFile(temporary: string, destination: string): void;
+/** Commit `files`; a failure restores completed replacements or reports preserved recovery copies. */
+export declare function commitFiles(files: readonly PreparedFile[]): void;
+/** The real commit and rollback algorithm, with a replacement operation tests can fault. */
+export declare function commitFilesWith(files: readonly PreparedFile[], replace: (temporary: string, destination: string) => void): void;

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/markdown/store.js

@@ -0,0 +1,250 @@
+/**
+ * File layout, project resolution and atomic commits of the memory store (`store.rs`).
+ *
+ * Every function here is synchronous, so within one process two writes can never interleave and
+ * no lock object is needed; the commit still rechecks each file against the text it was read
+ * from, which catches edits made by other processes or by hand.
+ */
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { MAX_FILE_BYTES, byteLength } from './constants.js';
+import { MemoryDocument } from './document.js';
+import { MemoryError } from './errors.js';
+import { MemoryRegistry, REGISTRY_FILE, randomHex } from './registry.js';
+/** Attempts allowed for Windows sharing violations during replacement or rollback. */
+const WINDOWS_MUTATION_ATTEMPTS = 5;
+/** Delay between Windows sharing-violation attempts; never applied to other errors or platforms. */
+const WINDOWS_MUTATION_RETRY_MS = 25;
+/** Node's codes for Windows os errors 5 (access denied), 32 (sharing) and 33 (lock violation). */
+const WINDOWS_TRANSIENT_CODES = new Set(['EPERM', 'EBUSY', 'EACCES']);
+export const MARKDOWN_DIRECTORY = 'markdown';
+/** The memory project a context addresses: the explicit choice or the host binding. */
+export function boundProject(context, registry) {
+    if (context.memoryProjectId !== undefined) {
+        const project = registry.project(context.memoryProjectId);
+        if (project === undefined)
+            throw new MemoryError('project_unavailable', `Memory project \`${context.memoryProjectId}\` does not exist.`);
+        return project;
+    }
+    return context.hostProjectId === undefined ? undefined : registry.projectForHost(context.hostProjectId);
+}
+export function scopeDocument(documents, scope) {
+    switch (scope) {
+        case 'user': return documents.user;
+        case 'space': return documents.space;
+        case 'project': return documents.project?.document;
+    }
+}
+/** Handle to the memory files under `<dshHome>/vulcan-memory`; nothing is created on disk until a write. */
+export class MarkdownMemoryStore {
+    memoryDirectory;
+    constructor(memoryDirectory) {
+        this.memoryDirectory = memoryDirectory;
+    }
+    get markdownDirectory() {
+        return path.join(this.memoryDirectory, MARKDOWN_DIRECTORY);
+    }
+    /** The file path of a scope; the project scope needs a memory project id. */
+    scopePath(scope, memoryProjectId) {
+        const directory = this.markdownDirectory;
+        switch (scope) {
+            case 'user': return path.join(directory, 'user.md');
+            case 'space': return path.join(directory, 'space.md');
+            case 'project': {
+                if (memoryProjectId === undefined) {
+                    throw new MemoryError('project_unavailable', 'This conversation has no project, so project memory is unavailable.');
+                }
+                if (!/^[A-Za-z0-9-]+$/.test(memoryProjectId))
+                    throw MemoryError.invalid(`\`${memoryProjectId}\` is not a memory project id.`);
+                return path.join(directory, 'projects', `${memoryProjectId}.md`);
+            }
+        }
+    }
+    /** The registry; a missing file is empty. */
+    registry() {
+        const file = path.join(this.markdownDirectory, REGISTRY_FILE);
+        const text = readOptional(file);
+        return text === undefined ? new MemoryRegistry() : MemoryRegistry.parse(text, file);
+    }
+    /** Change the registry and save it when the change succeeds. */
+    updateRegistry(change) {
+        const registry = this.registry();
+        const value = change(registry);
+        writeAtomically(path.join(this.markdownDirectory, REGISTRY_FILE), `${registry.toJson()}\n`);
+        return value;
+    }
+    /** One scope document; a missing file is an empty document. */
+    load(scope, memoryProjectId) {
+        const text = readOptional(this.scopePath(scope, memoryProjectId));
+        return text === undefined ? MemoryDocument.empty() : MemoryDocument.parse(text);
+    }
+    /** Every scope visible to a project context. */
+    loadScopes(context) {
+        const project = boundProject(context, this.registry());
+        return {
+            user: this.load('user', undefined),
+            space: this.load('space', undefined),
+            ...project === undefined ? {} : { project: { project, document: this.load('project', project.id) } },
+        };
+    }
+    /** The exact text of one scope file for whole-file editing. */
+    readFileText(scope, memoryProjectId) {
+        return readOptional(this.scopePath(scope, memoryProjectId)) ?? '';
+    }
+    /** Replace one whole scope file when it still holds the text the editor started from. */
+    replaceFileText(scope, memoryProjectId, expected, text) {
+        if (byteLength(text) > MAX_FILE_BYTES)
+            throw MemoryError.invalid(`A memory file can hold at most ${MAX_FILE_BYTES} bytes.`);
+        const file = this.scopePath(scope, memoryProjectId);
+        const original = readOptional(file);
+        if ((original ?? '') !== expected)
+            throw MemoryError.concurrent(file);
+        commitFiles([{ path: file, original, text }]);
+    }
+}
+/** A file's exact text, or `undefined` when it does not exist. */
+export function readOptional(file) {
+    try {
+        return readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw MemoryError.io(file, 'read', error);
+    }
+}
+/** Write text through a sibling temporary file and an atomic rename. */
+export function writeAtomically(file, text) {
+    const temporary = writeTemporary(file, text);
+    try {
+        replaceFile(temporary, file);
+    }
+    catch (error) {
+        rmSync(temporary, { force: true });
+        throw MemoryError.io(file, 'replaced', error);
+    }
+}
+function writeTemporary(file, text) {
+    const parent = path.dirname(file);
+    try {
+        mkdirSync(parent, { recursive: true });
+    }
+    catch (error) {
+        throw MemoryError.io(parent, 'created', error);
+    }
+    const temporary = path.join(parent, `.${path.basename(file)}.${randomHex(32)}.tmp`);
+    try {
+        writeFileSync(temporary, text, 'utf8');
+    }
+    catch (error) {
+        rmSync(temporary, { force: true });
+        throw MemoryError.io(temporary, 'written', error);
+    }
+    return temporary;
+}
+/** Retry `operation` only for transient Windows replacement failures. */
+export function retryFileMutation(operation) {
+    const windows = process.platform === 'win32';
+    const attempts = windows ? WINDOWS_MUTATION_ATTEMPTS : 1;
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            operation();
+            return;
+        }
+        catch (error) {
+            const code = error.code;
+            if (!windows || code === undefined || !WINDOWS_TRANSIENT_CODES.has(code) || attempt + 1 >= attempts)
+                throw error;
+            sleepSync(WINDOWS_MUTATION_RETRY_MS);
+        }
+    }
+}
+function sleepSync(milliseconds) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+/** Atomically replace `destination` with `temporary`, retrying transient Windows sharing failures. */
+export function replaceFile(temporary, destination) {
+    retryFileMutation(() => renameSync(temporary, destination));
+}
+/** Commit `files`; a failure restores completed replacements or reports preserved recovery copies. */
+export function commitFiles(files) {
+    commitFilesWith(files, replaceFile);
+}
+/** The real commit and rollback algorithm, with a replacement operation tests can fault. */
+export function commitFilesWith(files, replace) {
+    // Stage both directions before publishing anything, so rollback never needs to recreate original bytes.
+    const staged = [];
+    // Recovery copies handed to the user survive the final cleanup.
+    const detached = new Set();
+    try {
+        for (const file of files) {
+            if (readOptional(file.path) !== file.original)
+                throw MemoryError.concurrent(file.path);
+            const prepared = { replacement: writeTemporary(file.path, file.text), original: undefined };
+            staged.push(prepared);
+            if (file.original !== undefined)
+                prepared.original = writeTemporary(file.path, file.original);
+        }
+        files.forEach((file, index) => {
+            const stage = staged[index];
+            let failure;
+            try {
+                // Recheck immediately before replacement to detect external edits during staging.
+                if (readOptional(file.path) !== file.original)
+                    throw MemoryError.concurrent(file.path);
+                try {
+                    replace(stage.replacement, file.path);
+                }
+                catch (error) {
+                    throw MemoryError.io(file.path, 'replaced', error);
+                }
+            }
+            catch (error) {
+                failure = error instanceof MemoryError ? error : MemoryError.io(file.path, 'replaced', error);
+            }
+            if (failure === undefined)
+                return;
+            const inconsistent = [];
+            const recovery = [];
+            for (let completed = index - 1; completed >= 0; completed -= 1) {
+                // Never overwrite an unrelated external edit while undoing this transaction.
+                const previous = files[completed];
+                const previousStage = staged[completed];
+                let restored = false;
+                try {
+                    const current = readOptional(previous.path);
+                    if (current === previous.original) {
+                        restored = true;
+                    }
+                    else if (current === previous.text) {
+                        if (previousStage.original !== undefined)
+                            replace(previousStage.original, previous.path);
+                        else
+                            retryFileMutation(() => rmSync(previous.path));
+                        restored = true;
+                    }
+                }
+                catch {
+                    restored = false;
+                }
+                if (!restored) {
+                    inconsistent.push(previous.path);
+                    if (previousStage.original !== undefined) {
+                        recovery.push(previousStage.original);
+                        detached.add(previousStage.original);
+                    }
+                }
+            }
+            if (inconsistent.length === 0)
+                throw failure;
+            throw new MemoryError('rollback_incomplete', `Memory commit failed: ${failure.message}. Rollback is incomplete for ${JSON.stringify(inconsistent)}. Original recovery files: ${JSON.stringify(recovery)}. Restore these files before retrying.`);
+        });
+    }
+    finally {
+        for (const stage of staged) {
+            rmSync(stage.replacement, { force: true });
+            if (stage.original !== undefined && !detached.has(stage.original))
+                rmSync(stage.original, { force: true });
+        }
+    }
+}

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/markdown/timestamp.d.ts

@@ -0,0 +1,6 @@
+/** Minute-precision UTC timestamps written into node metadata (`timestamp.rs`). */
+/** `YYYY-MM-DDTHH:MMZ` for an instant. */
+export declare function formatUtcMinute(instant: Date): string;
+export declare function nowUtcMinute(): string;
+/** Whether text has the exact `YYYY-MM-DDTHH:MMZ` shape. */
+export declare function isUtcMinute(text: string): boolean;

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/markdown/timestamp.js

@@ -0,0 +1,12 @@
+/** Minute-precision UTC timestamps written into node metadata (`timestamp.rs`). */
+/** `YYYY-MM-DDTHH:MMZ` for an instant. */
+export function formatUtcMinute(instant) {
+    return `${instant.toISOString().slice(0, 16)}Z`;
+}
+export function nowUtcMinute() {
+    return formatUtcMinute(new Date());
+}
+/** Whether text has the exact `YYYY-MM-DDTHH:MMZ` shape. */
+export function isUtcMinute(text) {
+    return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z$/.test(text);
+}

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/markdown/tokens.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Mixed-language token estimate, the same as VulcanCode's
+ * `vulcan-context::estimate_mixed_language_text_tokens`: every ASCII run counts a quarter token per
+ * character rounded up, CJK characters one token each, other characters two.
+ */
+export declare function estimateTokens(text: string): number;
+/** Whether a code point belongs to the common CJK text ranges. */
+export declare function isCjkCharacter(code: number): boolean;

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/markdown/tokens.js

@@ -0,0 +1,38 @@
+/**
+ * Mixed-language token estimate, the same as VulcanCode's
+ * `vulcan-context::estimate_mixed_language_text_tokens`: every ASCII run counts a quarter token per
+ * character rounded up, CJK characters one token each, other characters two.
+ */
+export function estimateTokens(text) {
+    let asciiRun = 0;
+    let tokens = 0;
+    for (const character of text) {
+        const code = character.codePointAt(0) ?? 0;
+        if (code < 0x80) {
+            asciiRun += 1;
+            continue;
+        }
+        if (asciiRun > 0) {
+            tokens += Math.ceil(asciiRun / 4);
+            asciiRun = 0;
+        }
+        tokens += isCjkCharacter(code) ? 1 : 2;
+    }
+    if (asciiRun > 0)
+        tokens += Math.ceil(asciiRun / 4);
+    return tokens;
+}
+/** Whether a code point belongs to the common CJK text ranges. */
+export function isCjkCharacter(code) {
+    return (code >= 0x3400 && code <= 0x4DBF)
+        || (code >= 0x4E00 && code <= 0x9FFF)
+        || (code >= 0xF900 && code <= 0xFAFF)
+        || (code >= 0x3040 && code <= 0x30FF)
+        || (code >= 0xAC00 && code <= 0xD7AF)
+        || (code >= 0x20000 && code <= 0x2A6DF)
+        || (code >= 0x2A700 && code <= 0x2B73F)
+        || (code >= 0x2B740 && code <= 0x2B81F)
+        || (code >= 0x2B820 && code <= 0x2CEAF)
+        || (code >= 0x2CEB0 && code <= 0x2EBEF)
+        || (code >= 0x30000 && code <= 0x3134F);
+}