maka-agent 0.2.0-dev.22.20260905 → 0.2.0-dev.23.20260906

package/node_modules/@maka/core/dist/bot-events.js

@@ -22,6 +22,7 @@
  * different copy without diluting the core message. Exported so the
  * handler can use it AND a contract test can pin it.
  */
+// bot-channel notices follow the bot audience language; localization tracked under #2672
 export function nonTextMessageAck(kind) {
     switch (kind) {
         case 'photo':
@@ -139,74 +140,28 @@ function sanitizeBotUserName(value) {
         .trim() || 'unknown');
 }
 /**
- * PR-BOT-LASTERROR-FROM-SEND-0 (external bot research): translate the bridge's
- * machine-readable `BotStatus.reason` into a short user-readable string
- * suitable for persistence in `BotChannelSettings.lastError`. The Settings
- * page reads `lastError` from persisted settings (not live status), so
- * without this persistence step the user sees stale connection-test
- * errors instead of the actual send-path failure that happened minutes
- * ago.
- *
- * Returns `undefined` for non-error reasons (disabled/stopped/missing
- * credentials — those have their own UI surface) and for unrecognized
- * inputs whose pass-through risks leaking unredacted payloads.
- *
- * Length-capped at 200 chars defensively; a real Telegram error
- * description is typically well under 80 chars.
+ * Non-error `BotStatus.reason` values. These states have their own UI surface,
+ * so an error readout must not repeat them as failures.
  */
-const BOT_REASON_HUMANIZE = {
-    'rate-limited': '发送被节流（429）；上一条回复可能截断，可以请用户再发一次',
-    'polling-timeout': '事件轮询超时；可能是网络抖动或代理失效',
-    'send-failed': '上一次发送失败，详细原因 Telegram 没有返回',
-    'get-me-failed': '凭据探测失败；请检查 Bot Token',
-    // Non-error states surface elsewhere in the UI — return undefined so
-    // we do not overwrite a real lastError with a benign status change.
-    disabled: undefined,
-    stopped: undefined,
-    'no-token': undefined,
-    'missing-feishu-credentials': undefined,
-    'feishu-domain-required': undefined,
-    'feishu-events-not-connected': undefined,
-    'scaffold-only': undefined,
-    unimplemented: undefined,
-};
+const BOT_BENIGN_STATUS_REASONS = new Set([
+    'disabled',
+    'stopped',
+    'token_missing',
+    'feishu_credentials_missing',
+    'feishu-domain-required',
+    'feishu-events-not-connected',
+    'scaffold-only',
+    'unimplemented',
+]);
 /**
- * PR-BOT-RUNTIME-REASON-HUMANIZE-0: Discord / DingTalk / QQ bridges
- * emit parameterized reason strings like `gateway-closed-4004` and
- * `connections-open-500`. Without these patterns the user sees the
- * raw machine code in `lastError`; with them they get a translated
- * description plus the diagnostic code preserved in parentheses.
- *
- * Each entry is a regex with one numeric capture group; the matched
- * code is preserved verbatim so support diagnostics still survive.
+ * `BotStatus.reason` stays a stable code; presenters own the copy. Benign
+ * states yield `undefined` so they never overwrite a real error readout.
  */
-const BOT_REASON_HUMANIZE_PATTERNS = [
-    { pattern: /^gateway-bot-(\d+)$/, format: (code) => `获取 Gateway 失败（HTTP ${code}）` },
-    { pattern: /^gateway-closed-(\d+)$/, format: (code) => `Gateway 连接关闭（${code}）；正在重连` },
-    { pattern: /^connections-open-(\d+)$/, format: (code) => `Stream 订阅打开失败（HTTP ${code}）` },
-    { pattern: /^stream-closed-(\d+)$/, format: (code) => `Stream 连接关闭（${code}）；正在重连` },
-    { pattern: /^send-failed-(\d+)$/, format: (code) => `发送失败（HTTP ${code}）` },
-    {
-        pattern: /^getAppAccessToken-(\d+)$/,
-        format: (code) => `获取 access_token 失败（HTTP ${code}）`,
-    },
-];
-export function humanizeBotStatusReason(reason) {
-    if (typeof reason !== 'string' || reason.length === 0)
+export function botStatusErrorReason(reason) {
+    if (typeof reason !== 'string')
         return undefined;
-    if (reason in BOT_REASON_HUMANIZE) {
-        return BOT_REASON_HUMANIZE[reason];
-    }
-    for (const { pattern, format } of BOT_REASON_HUMANIZE_PATTERNS) {
-        const match = pattern.exec(reason);
-        if (match)
-            return format(match[1]);
-    }
-    // Pass-through for platform-supplied descriptions ("Bad Request:
-    // chat not found", etc.). Trim + length-cap to keep `lastError`
-    // bounded.
     const trimmed = reason.trim();
-    if (trimmed.length === 0)
+    if (trimmed.length === 0 || BOT_BENIGN_STATUS_REASONS.has(trimmed))
         return undefined;
     return trimmed.length > 200 ? trimmed.slice(0, 200) : trimmed;
 }

package/node_modules/@maka/core/dist/model-call-attempt.js

@@ -349,15 +349,6 @@ export function decodeModelCallAttempt(value) {
     }
     return value;
 }
-export function isModelCallAttempt(value) {
-    try {
-        decodeModelCallAttempt(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 /**
  * Collapses re-appended records by `attemptId`, keeping the last occurrence.
  *
@@ -389,76 +380,3 @@ export function groupModelCallAttempts(attempts) {
     }
     return [...groups.values()];
 }
-/**
- * The attempt that settled a logical call: the highest `attempt` ordinal that
- * reached a provider outcome. Terminality is a projection concern, not a stored
- * field, so it is derived rather than recorded.
- */
-export function settledAttempt(group) {
-    let settled;
-    for (const attempt of group.attempts) {
-        if (!settled || attempt.attempt > settled.attempt)
-            settled = attempt;
-    }
-    return settled;
-}
-/**
- * Extracts the canonical attempts a run committed, from that run's AgentRun
- * events. This is the projection the Usage read model is rebuilt through, so it
- * has to be total: an event that cannot be decoded is counted, not thrown, or
- * one bad record would block every later one in the same run from ever being
- * projected.
- */
-export function modelCallAttemptsFromRunEvents(events) {
-    const attempts = [];
-    let unreadableEvents = 0;
-    for (const event of events) {
-        if (event.type !== MODEL_CALL_ATTEMPT_EVENT_TYPE)
-            continue;
-        try {
-            attempts.push(decodeModelCallAttempt(event.data));
-        }
-        catch {
-            unreadableEvents += 1;
-        }
-    }
-    return { attempts, unreadableEvents };
-}
-export function summarizeModelCallCoverage(attempts) {
-    const unique = dedupeModelCallAttempts(attempts);
-    const coverage = {
-        attempts: unique.length,
-        pricedAttempts: 0,
-        unpricedAttempts: 0,
-        usageReportedAttempts: 0,
-        usagePartialAttempts: 0,
-        usageMissingAttempts: 0,
-    };
-    for (const attempt of unique) {
-        if (attempt.costBasis === 'priced')
-            coverage.pricedAttempts += 1;
-        else
-            coverage.unpricedAttempts += 1;
-        if (attempt.usageBasis === 'reported')
-            coverage.usageReportedAttempts += 1;
-        else if (attempt.usageBasis === 'partial')
-            coverage.usagePartialAttempts += 1;
-        else
-            coverage.usageMissingAttempts += 1;
-    }
-    return coverage;
-}
-/**
- * Sums cost across attempts. Returns the total alongside the coverage that
- * qualifies it, because a bare number cannot express "plus an unknown amount
- * from unpriced calls".
- */
-export function sumModelCallCostUsd(attempts) {
-    const unique = dedupeModelCallAttempts(attempts);
-    let costUsd = 0;
-    for (const attempt of unique) {
-        if (attempt.costBasis === 'priced' && attempt.costUsd !== undefined)
-            costUsd += attempt.costUsd;
-    }
-    return { costUsd, coverage: summarizeModelCallCoverage(unique) };
-}

package/node_modules/@maka/core/dist/model-call-usage-projection.js

@@ -16,8 +16,6 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { dedupeModelCallAttempts, summarizeModelCallCoverage, } from './model-call-attempt.js';
-import { usageBucketKey } from './usage-stats/bucket-key.js';
 const DAY_MS = 86_400_000;
 export function resolveUsageRange(range, now) {
     if (typeof range === 'object')
@@ -44,190 +42,6 @@ export function usageStatusForAttempt(status) {
         return 'error';
     return 'aborted';
 }
-function matchesQuery(attempt, query, range) {
-    if (attempt.completedAt < range.from || attempt.completedAt > range.to)
-        return false;
-    if (query.sessionId !== undefined && attempt.sessionId !== query.sessionId)
-        return false;
-    if (query.providerId !== undefined && attempt.providerId !== query.providerId)
-        return false;
-    if (query.modelId !== undefined && attempt.modelId !== query.modelId)
-        return false;
-    if (query.connectionSlug !== undefined && attempt.connectionSlug !== query.connectionSlug) {
-        return false;
-    }
-    if (query.status !== undefined && query.status !== 'all') {
-        if (usageStatusForAttempt(attempt.status) !== query.status)
-            return false;
-    }
-    return true;
-}
-/**
- * Selects the attempts a query addresses, in append order, deduped by
- * `attemptId` so a re-appended settlement counts once.
- */
-export function selectModelCallAttempts(attempts, query, now) {
-    const range = resolveUsageRange(query.range, now);
-    const rows = dedupeModelCallAttempts(attempts).filter((a) => matchesQuery(a, query, range));
-    return { rows, range };
-}
-function tokens(attempt) {
-    const reportedCacheRead = attempt.cacheReadInputTokens ?? 0;
-    const input = attempt.inputTokens ?? 0;
-    const output = attempt.outputTokens ?? 0;
-    const cacheMiss = attempt.cacheMissInputTokens ?? 0;
-    // With no reported prompt total there is no denominator to validate against,
-    // but the provider's cache evidence remains authoritative. Presentation code
-    // must leave ratios unavailable while Usage coverage is partial.
-    const cacheRead = attempt.inputTokens === undefined
-        ? reportedCacheRead
-        : clampCacheReadTokens(input, reportedCacheRead);
-    const cacheWrite = attempt.cacheWriteInputTokens ?? 0;
-    const reasoning = attempt.reasoningTokens ?? 0;
-    return { input, output, cacheMiss, cacheRead, cacheWrite, reasoning, total: input + output };
-}
 export function clampCacheReadTokens(inputTokens, cacheReadTokens) {
     return Math.min(cacheReadTokens, inputTokens);
 }
-/** Cost contributed by an attempt. Unpriced records contribute nothing to the
- * sum and are surfaced through coverage instead of being counted as zero. */
-function pricedCost(attempt) {
-    return attempt.costBasis === 'priced' ? (attempt.costUsd ?? 0) : 0;
-}
-export function projectModelCallUsageSummary(attempts, query, now) {
-    const { rows, range } = selectModelCallAttempts(attempts, query, now);
-    const totals = {
-        input: 0,
-        output: 0,
-        cacheMiss: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        reasoning: 0,
-        total: 0,
-    };
-    let totalCostUsd = 0;
-    let totalDurationMs = 0;
-    let cacheHitRequests = 0;
-    let cacheCreateRequests = 0;
-    let errorRequests = 0;
-    for (const attempt of rows) {
-        const t = tokens(attempt);
-        totals.input += t.input;
-        totals.output += t.output;
-        totals.cacheMiss += t.cacheMiss;
-        totals.cacheRead += t.cacheRead;
-        totals.cacheWrite += t.cacheWrite;
-        totals.reasoning += t.reasoning;
-        totals.total += t.total;
-        totalCostUsd += pricedCost(attempt);
-        totalDurationMs += attempt.latencyMs;
-        if (t.cacheRead > 0)
-            cacheHitRequests += 1;
-        if (t.cacheWrite > 0)
-            cacheCreateRequests += 1;
-        if (usageStatusForAttempt(attempt.status) === 'error')
-            errorRequests += 1;
-    }
-    return {
-        range,
-        totalRequests: rows.length,
-        totalCostUsd,
-        totalDurationMs,
-        totalTokens: totals,
-        cacheHitRequests,
-        cacheCreateRequests,
-        errorRequests,
-        coverage: summarizeModelCallCoverage(rows),
-    };
-}
-export function projectModelCallUsageBuckets(attempts, query, groupBy, now) {
-    const { rows } = selectModelCallAttempts(attempts, query, now);
-    const groups = new Map();
-    for (const attempt of rows) {
-        const key = usageBucketKey({ providerId: attempt.providerId, modelId: attempt.modelId, ts: attempt.completedAt }, groupBy);
-        const group = groups.get(key);
-        if (group)
-            group.push(attempt);
-        else
-            groups.set(key, [attempt]);
-    }
-    return [...groups.entries()]
-        .map(([key, group]) => {
-        const agg = {
-            input: 0,
-            output: 0,
-            cacheMiss: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            reasoning: 0,
-            total: 0,
-        };
-        let costUsd = 0;
-        let latency = 0;
-        let errors = 0;
-        for (const attempt of group) {
-            const t = tokens(attempt);
-            agg.input += t.input;
-            agg.output += t.output;
-            agg.cacheMiss += t.cacheMiss;
-            agg.cacheRead += t.cacheRead;
-            agg.cacheWrite += t.cacheWrite;
-            agg.reasoning += t.reasoning;
-            agg.total += t.total;
-            costUsd += pricedCost(attempt);
-            latency += attempt.latencyMs;
-            if (usageStatusForAttempt(attempt.status) === 'error')
-                errors += 1;
-        }
-        return {
-            key,
-            label: key,
-            requests: group.length,
-            inputTokens: agg.input,
-            outputTokens: agg.output,
-            cacheMissTokens: agg.cacheMiss,
-            cacheReadTokens: agg.cacheRead,
-            cacheWriteTokens: agg.cacheWrite,
-            reasoningTokens: agg.reasoning,
-            totalTokens: agg.total,
-            costUsd,
-            avgLatencyMs: group.length === 0 ? 0 : latency / group.length,
-            errorRate: group.length === 0 ? 0 : errors / group.length,
-        };
-    })
-        .sort((left, right) => right.requests - left.requests);
-}
-export function projectModelCallUsageLogs(attempts, query, now, offset = 0, limit = 100) {
-    const { rows } = selectModelCallAttempts(attempts, query, now);
-    const ordered = [...rows].sort((left, right) => right.completedAt - left.completedAt);
-    const page = ordered.slice(offset, offset + limit).map((attempt) => {
-        const t = tokens(attempt);
-        return {
-            id: attempt.attemptId,
-            ts: attempt.completedAt,
-            callKind: attempt.callKind,
-            callId: attempt.logicalCallId,
-            ...(attempt.connectionSlug !== undefined ? { connectionSlug: attempt.connectionSlug } : {}),
-            providerId: attempt.providerId,
-            modelId: attempt.modelId,
-            inputTokens: t.input,
-            outputTokens: t.output,
-            cacheMissTokens: t.cacheMiss,
-            cacheReadTokens: t.cacheRead,
-            cacheWriteTokens: t.cacheWrite,
-            reasoningTokens: t.reasoning,
-            totalTokens: t.total,
-            // A row keeps its basis, not just its number. Collapsing an unpriced call
-            // to 0 here would reproduce, per row, exactly the ambiguity the coverage
-            // breakdown removes from the totals.
-            ...(attempt.costBasis === 'priced' ? { costUsd: attempt.costUsd ?? 0 } : {}),
-            costBasis: attempt.costBasis,
-            latencyMs: attempt.latencyMs,
-            status: usageStatusForAttempt(attempt.status),
-            ...(attempt.errorClass !== undefined ? { errorClass: attempt.errorClass } : {}),
-            sessionId: attempt.sessionId,
-            turnId: attempt.turnId,
-        };
-    });
-    return { rows: page, total: ordered.length, coverage: summarizeModelCallCoverage(rows) };
-}

package/node_modules/@maka/core/dist/record-schema.js

@@ -33,6 +33,19 @@ export function hasExactShape(value, shape) {
     return (shape.required.every((key) => Object.hasOwn(value, key)) &&
         Object.keys(value).every((key) => shape.allowed.has(key)));
 }
+/**
+ * Narrows a record to the keys a shape allows. `undefined` entries are dropped
+ * so the result serializes the way {@link hasExactShape} reads it back.
+ */
+export function pickShape(value, shape) {
+    const picked = {};
+    for (const key of shape.allowed) {
+        const entry = value[key];
+        if (entry !== undefined)
+            picked[key] = entry;
+    }
+    return picked;
+}
 export function isFiniteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value);
 }

package/node_modules/@maka/core/dist/redaction.js

@@ -174,76 +174,59 @@ function isAssignmentSensitiveKey(key) {
     const suffix = sensitiveKeySegments(key).at(-1);
     return suffix !== 'auth' && suffix !== 'authorization';
 }
-const GENERALIZED_ERROR_COPY = {
-    'zh-CN': {
-        timeout: '请求超时',
-        rateLimit: '触发模型速率限制',
-        authentication: '鉴权失败',
-        provider: '模型服务返回错误',
-        network: '网络错误',
-    },
-    'zh-TW': {
-        timeout: '請求逾時',
-        rateLimit: '已達模型速率限制',
-        authentication: '驗證失敗',
-        provider: '模型服務傳回錯誤',
-        network: '網路錯誤',
-    },
-    en: {
-        timeout: 'Request timed out',
-        rateLimit: 'Rate limit exceeded',
-        authentication: 'Authentication failed',
-        provider: 'Provider returned an error',
-        network: 'Network error',
-    },
-};
-function classifyGeneralizedError(error) {
+/**
+ * Keyword classification shared by the localized message helpers and by
+ * producers that emit a stable machine code instead of prose.
+ */
+export function classifyGeneralizedError(error) {
     const message = error instanceof Error ? error.message : String(error);
-    const redacted = redactSecrets(message);
-    const lower = redacted.toLowerCase();
+    const lower = redactSecrets(message).toLowerCase();
     if (lower.includes('timeout'))
         return 'timeout';
     if (lower.includes('429') || lower.includes('rate'))
-        return 'rateLimit';
+        return 'rate_limited';
     if (lower.includes('401') || lower.includes('403') || isAuthenticationErrorText(lower))
-        return 'authentication';
-    if (lower.includes('5') && /\b5\d\d\b/.test(lower))
-        return 'provider';
+        return 'auth_failed';
+    if (/\b5\d\d\b/.test(lower))
+        return 'provider_error';
     if (lower.includes('network') ||
         lower.includes('fetch') ||
         lower.includes('econn') ||
         lower.includes('enotfound'))
-        return 'network';
-    return null;
+        return 'network_error';
+    return undefined;
 }
-function localizedGeneralizedErrorMessage(error, fallback, locale) {
-    const category = classifyGeneralizedError(error);
-    return category ? GENERALIZED_ERROR_COPY[locale][category] : fallback;
+/** Locale copy for each {@link GeneralizedErrorClass}; catalog authors spread
+ * this per-locale block instead of restating the sentences. */
+export const GENERALIZED_ERROR_COPY = {
+    'zh-CN': {
+        timeout: '请求超时',
+        rate_limited: '触发模型速率限制',
+        auth_failed: '鉴权失败',
+        provider_error: '模型服务返回错误',
+        network_error: '网络错误',
+    },
+    'zh-TW': {
+        timeout: '請求逾時',
+        rate_limited: '已達模型速率限制',
+        auth_failed: '驗證失敗',
+        provider_error: '模型服務傳回錯誤',
+        network_error: '網路錯誤',
+    },
+    en: {
+        timeout: 'Request timed out',
+        rate_limited: 'Rate limit exceeded',
+        auth_failed: 'Authentication failed',
+        provider_error: 'Provider returned an error',
+        network_error: 'Network error',
+    },
+};
+export function generalizedErrorMessageForLocale(error, fallback, locale) {
+    const classified = classifyGeneralizedError(error);
+    return classified ? GENERALIZED_ERROR_COPY[locale][classified] : fallback;
 }
 export function generalizedErrorMessage(error, fallback = 'Operation failed') {
-    return localizedGeneralizedErrorMessage(error, fallback, 'en');
-}
-/**
- * Chinese-locale companion to `generalizedErrorMessage()` (PR110b
- * follow-up). Same classification rules; returns Chinese phrasing
- * instead of English. Used by surfaces that must enforce a
- * Chinese-only error copy contract (session start, onboarding setup
- * banners, etc.) — the English version would have leaked through any
- * matched category, breaking the gate.
- *
- * The fallback default is also Chinese so callers that don't supply
- * one still produce a Chinese-only result. Pass a more specific
- * Chinese fallback (e.g. "会话已创建但发送失败，请重试。") for better
- * UX when the classifier can't categorize.
- */
-export function generalizedErrorMessageChinese(error, fallback = '操作失败') {
-    return localizedGeneralizedErrorMessage(error, fallback, 'zh-CN');
-}
-export function generalizedErrorMessageTraditionalChinese(error, fallback = '操作失敗') {
-    return localizedGeneralizedErrorMessage(error, fallback, 'zh-TW');
-}
-export function generalizedErrorMessageForLocale(error, fallback, locale) {
-    return localizedGeneralizedErrorMessage(error, fallback, locale);
+    return generalizedErrorMessageForLocale(error, fallback, 'en');
 }
 export function isAuthenticationErrorText(message) {
     return message.replace(/\bauthorit\w*/g, '').includes('auth');

package/node_modules/@maka/core/dist/session-trace.js

@@ -65,7 +65,11 @@ const MODEL_CALL_STEP_SHAPE = defineObjectShape()([
     'attempts',
     'status',
 ], ['connectionSlug', 'historyCompactRoute', 'costUsd']);
-const MODEL_ATTEMPT_SHAPE = defineObjectShape()([
+/**
+ * The Inspector's own view of an attempt. Exported so the projection narrows an
+ * authority record through this list rather than restating it by hand.
+ */
+export const MODEL_ATTEMPT_SHAPE = defineObjectShape()([
     'attemptId',
     'attempt',
     'status',

package/node_modules/@maka/core/dist/usage-ledger-merge.js

@@ -16,7 +16,6 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { projectModelCallUsageBuckets, projectModelCallUsageLogs, projectModelCallUsageSummary, } from './model-call-usage-projection.js';
 /**
  * The cost to present for a usage total, or `undefined` when it cannot be shown
  * honestly. Trust the total only when at least one canonical attempt was priced;
@@ -66,8 +65,8 @@ export function legacyUsageProvenance(legacyRecords) {
         pendingRepairs: 0,
     };
 }
-export function mergeUsageSummary(legacy, canonical, query, now) {
-    const projected = projectModelCallUsageSummary(canonical.attempts, query, now);
+export function mergeUsageSummary(legacy, canonical) {
+    const projected = canonical.projection;
     return {
         range: projected.range,
         totalRequests: legacy.totalRequests + projected.totalRequests,
@@ -95,17 +94,16 @@ export function mergeUsageSummary(legacy, canonical, query, now) {
         },
     };
 }
-export function mergeUsageBuckets(legacy, canonical, query, groupBy, now) {
-    const projected = projectModelCallUsageBuckets(canonical.attempts, query, groupBy, now);
+export function mergeUsageBuckets(legacy, canonical) {
     const merged = new Map();
-    for (const bucket of [...legacy, ...projected]) {
+    for (const bucket of [...legacy, ...canonical.projection.buckets]) {
         const existing = merged.get(bucket.key);
         merged.set(bucket.key, existing ? combineBuckets(existing, bucket) : { ...bucket });
     }
     return {
         buckets: [...merged.values()].sort((left, right) => right.requests - left.requests),
         provenance: {
-            coverage: projectModelCallUsageSummary(canonical.attempts, query, now).coverage,
+            coverage: canonical.projection.coverage,
             legacyRecords: legacy.reduce((total, bucket) => total + bucket.requests, 0),
             unreadableRecords: canonical.unreadableRecords,
             pendingRepairs: canonical.pendingRepairs,
@@ -117,8 +115,8 @@ export function mergeUsageBuckets(legacy, canonical, query, groupBy, now) {
  * the merged order can only come from the first `offset + limit` rows of each —
  * callers may bound their reads to that prefix and still page exactly.
  */
-export function mergeUsageLogs(legacy, canonical, query, now, offset, limit) {
-    const projected = projectModelCallUsageLogs(canonical.attempts, query, now, 0, offset + limit);
+export function mergeUsageLogs(legacy, canonical, offset, limit) {
+    const projected = canonical.projection;
     const rows = [];
     let left = 0;
     let right = 0;