squish-memory 1.0.2 → 1.1.5

package/dist/core/places/walking.js

@@ -0,0 +1,121 @@
+/**
+ * Walking Interface - Sequential memory retrieval through places
+ *
+ * Implements Method of Loci walking through memory places:
+ * - Walk single place to get memories in order
+ * - Walk all places for full tour
+ * - Token budget handling with TOON compression
+ */
+import { getProjectPlaces } from './places.js';
+import { getPlaceMemories } from './memory-places.js';
+import { getMemory } from '../memory/memories.js';
+import { compressForContext } from '../toon.js';
+import { logger } from '../logger.js';
+/**
+ * Walk through a single place
+ */
+export async function walkPlace(projectId, placeType, options = {}) {
+    const { tokenBudget = 170, maxMemoriesPerPlace = 10, includePurpose = true, compressWithToon = false } = options;
+    // Get the place
+    const places = await getProjectPlaces(projectId);
+    const place = places.find(p => p.placeType === placeType);
+    if (!place) {
+        logger.warn(`[Walking] Place not found: ${placeType}`);
+        return null;
+    }
+    // Get memory IDs for this place
+    const memoryIds = await getPlaceMemories(place.id, maxMemoriesPerPlace);
+    // Get full memories
+    const memories = [];
+    let totalTokens = 0;
+    for (const memoryId of memoryIds) {
+        const memory = await getMemory(memoryId);
+        if (!memory)
+            continue;
+        let content = memory.content || '';
+        // Compress with TOON if requested
+        if (compressWithToon && content) {
+            content = compressForContext(content);
+        }
+        const tokenEstimate = Math.ceil(content.length / 4); // rough token estimate
+        if (totalTokens + tokenEstimate > tokenBudget) {
+            // Would exceed budget - stop adding
+            break;
+        }
+        memories.push({
+            id: memory.id,
+            content,
+            type: memory.type,
+            tags: memory.tags || [],
+            createdAt: memory.createdAt || '',
+        });
+        totalTokens += tokenEstimate;
+    }
+    return {
+        place,
+        memories,
+        totalTokens,
+        truncated: memories.length < memoryIds.length,
+    };
+}
+/**
+ * Walk through all places in loci order
+ */
+export async function walkAllPlaces(projectId, options = {}) {
+    const places = await getProjectPlaces(projectId);
+    const results = [];
+    for (const place of places) {
+        const walkResult = await walkPlace(projectId, place.placeType, options);
+        if (walkResult && walkResult.memories.length > 0) {
+            results.push(walkResult);
+        }
+    }
+    logger.info(`[Walking] Walked ${results.length} places for project ${projectId}`);
+    return results;
+}
+/**
+ * Quick tour - just place names and purposes (minimal tokens)
+ */
+export async function quickTour(projectId) {
+    const places = await getProjectPlaces(projectId);
+    return {
+        places: places.map(p => ({
+            name: p.name,
+            purpose: p.purpose || '',
+            memoryCount: p.memoryCount,
+        })),
+        totalMemories: places.reduce((sum, p) => sum + p.memoryCount, 0),
+    };
+}
+/**
+ * Get context summary for a place (for injection)
+ */
+export async function getPlaceContext(projectId, placeType, maxTokens = 50) {
+    const walkResult = await walkPlace(projectId, placeType, {
+        tokenBudget: maxTokens,
+        compressWithToon: true,
+    });
+    if (!walkResult || walkResult.memories.length === 0) {
+        return '';
+    }
+    const lines = walkResult.memories.map((m, i) => `${i + 1}. [${m.type}] ${m.content.substring(0, 100)}`);
+    return `## ${walkResult.place.name}\n${lines.join('\n')}`;
+}
+/**
+ * Full context for session start (all places)
+ */
+export async function getFullWalkingContext(projectId, maxTokens = 170) {
+    const results = await walkAllPlaces(projectId, {
+        tokenBudget: Math.floor(maxTokens / 7), // Distribute across 7 places
+        compressWithToon: true,
+    });
+    if (results.length === 0) {
+        return 'No memories yet. Start building your spatial memory!';
+    }
+    const sections = results.map(r => {
+        const lines = r.memories.slice(0, 3).map((m, i) => `  ${i + 1}. ${m.content.substring(0, 60)}...`).join('\n');
+        return `## ${r.place.name}\n${lines}`;
+    });
+    return sections.join('\n\n');
+}
+//# sourceMappingURL=walking.js.map

package/dist/core/projects.d.ts

@@ -7,6 +7,11 @@ export interface ProjectRecord {
 }
 export declare function getProjectByPath(path: string): Promise<ProjectRecord | null>;
 export declare function ensureProject(path?: string): Promise<ProjectRecord | null>;
+export declare class ProjectNotFoundError extends Error {
+    constructor(path: string);
+}
+export declare function requireProject(path: string): Promise<ProjectRecord>;
+export declare function getOrCreateProject(path?: string): Promise<ProjectRecord | null>;
 export declare function getAllProjects(): Promise<ProjectRecord[]>;
 export declare function getProjectById(id: string): Promise<ProjectRecord | null>;
 //# sourceMappingURL=projects.d.ts.map

package/dist/core/projects.js

@@ -3,9 +3,8 @@ import { randomUUID } from 'crypto';
 import { eq } from 'drizzle-orm';
 import { getDb } from '../db/index.js';
 import { getSchema } from '../db/schema.js';
-import { fromSqliteJson, toSqliteJson } from './memory/serialization.js';
-import { config } from '../config.js';
-import { createDatabaseClient } from './database.js';
+import { serializeMetadata, deserializeMetadata } from './memory/serialization.js';
+import { createDatabaseClient } from './storage/database.js';
 export async function getProjectByPath(path) {
     try {
         const db = createDatabaseClient(await getDb());
@@ -31,26 +30,48 @@ export async function ensureProject(path) {
     const id = randomUUID();
     const name = basename(path) || path;
     const metadata = { source: 'mcp' };
-    if (config.isTeamMode) {
-        await db.insert(schema.projects).values({
-            id,
-            name,
-            path,
-            metadata,
-        });
+    await db.insert(schema.projects).values({
+        id,
+        name,
+        path,
+        metadata: serializeMetadata(metadata),
+    });
+    return { id, name, path, metadata };
+}
+export class ProjectNotFoundError extends Error {
+    constructor(path) {
+        super(`Project not found: ${path}`);
+        this.name = 'ProjectNotFoundError';
     }
-    else {
-        await db.insert(schema.projects).values({
-            id,
-            name,
-            path,
-            metadata: toSqliteJson(metadata),
-        });
+}
+export async function requireProject(path) {
+    const project = await getProjectByPath(path);
+    if (!project) {
+        throw new ProjectNotFoundError(path);
     }
+    return project;
+}
+export async function getOrCreateProject(path) {
+    if (!path)
+        return null;
+    const existing = await getProjectByPath(path);
+    if (existing)
+        return existing;
+    const db = createDatabaseClient(await getDb());
+    const schema = await getSchema();
+    const id = randomUUID();
+    const name = basename(path) || path;
+    const metadata = { source: 'mcp' };
+    await db.insert(schema.projects).values({
+        id,
+        name,
+        path,
+        metadata: serializeMetadata(metadata),
+    });
     return { id, name, path, metadata };
 }
 function normalizeProject(row) {
-    const metadata = config.isTeamMode ? row.metadata : fromSqliteJson(row.metadata);
+    const metadata = deserializeMetadata(row.metadata ?? null);
     return {
         id: row.id,
         name: row.name,

package/dist/core/responses.d.ts

@@ -0,0 +1,96 @@
+/**
+ * ResponseFormatter - Unified response formatting for all Squish output contexts
+ * @module core/responses
+ */
+export type ResponseStatus = 'ok' | 'error';
+export interface BaseResponse<T = unknown> {
+    status: ResponseStatus;
+    message?: string;
+    data?: T;
+    error?: string;
+    timestamp?: string;
+}
+export interface PaginatedResponse<T> extends BaseResponse<T[]> {
+    count: number;
+    total?: number;
+    page?: number;
+    limit?: number;
+}
+/**
+ * Format options for web responses
+ */
+export interface WebFormatOptions {
+    statusCode?: number;
+    pagination?: {
+        total: number;
+        page: number;
+        limit: number;
+    };
+}
+/**
+ * Unified response formatter for all Squish output contexts
+ */
+export declare class ResponseFormatter {
+    /**
+     * Generate ISO timestamp
+     */
+    private static getTimestamp;
+    /**
+     * Build base response with timestamp
+     */
+    private static buildBase;
+    /**
+     * Format response for CLI output (pretty-printed JSON)
+     */
+    static cli<T>(data: T, message?: string): string;
+    /**
+     * Format error for CLI and exit process
+     */
+    static cliError(error: Error): never;
+    /**
+     * Format successful response for Web API
+     */
+    static web<T>(data: T, message?: string, options?: WebFormatOptions): {
+        status: number;
+        body: BaseResponse<T>;
+    };
+    /**
+     * Format error response for Web API
+     */
+    static webError(error: Error, options?: {
+        statusCode?: number;
+        log?: boolean;
+    }): {
+        status: number;
+        body: BaseResponse;
+    };
+    /**
+     * Format response for MCP tools
+     */
+    static mcp<T>(data: T, message?: string): {
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    };
+    /**
+     * Format error for MCP tools (throws McpError)
+     */
+    static mcpError(error: Error, context?: string): never;
+    /**
+     * Format response for algorithm handlers
+     */
+    static algorithm<T>(data: T, message: string, options?: {
+        ok?: boolean;
+        error?: string;
+    }): BaseResponse<T>;
+    /**
+     * Convenience method for success responses
+     */
+    static success<T>(data: T, message?: string): BaseResponse<T>;
+    /**
+     * Convenience method for failure responses
+     */
+    static failure(message: string, error?: Error | string): BaseResponse;
+}
+//# sourceMappingURL=responses.d.ts.map

package/dist/core/responses.js

@@ -0,0 +1,122 @@
+/**
+ * ResponseFormatter - Unified response formatting for all Squish output contexts
+ * @module core/responses
+ */
+/**
+ * Unified response formatter for all Squish output contexts
+ */
+export class ResponseFormatter {
+    /**
+     * Generate ISO timestamp
+     */
+    static getTimestamp() {
+        return new Date().toISOString();
+    }
+    /**
+     * Build base response with timestamp
+     */
+    static buildBase(status, message, data, error) {
+        return {
+            status,
+            message,
+            data,
+            error,
+            timestamp: this.getTimestamp(),
+        };
+    }
+    // CLI Formatters
+    /**
+     * Format response for CLI output (pretty-printed JSON)
+     */
+    static cli(data, message) {
+        const response = this.buildBase(data instanceof Error ? 'error' : 'ok', message, data);
+        return JSON.stringify(response, null, 2);
+    }
+    /**
+     * Format error for CLI and exit process
+     */
+    static cliError(error) {
+        const response = this.buildBase('error', error.message, undefined, error.message);
+        console.error(JSON.stringify(response, null, 2));
+        process.exit(1);
+    }
+    // Web API Formatters
+    /**
+     * Format successful response for Web API
+     */
+    static web(data, message, options) {
+        const body = this.buildBase('ok', message, data);
+        // Add pagination metadata if provided
+        if (options?.pagination) {
+            body.count = options.pagination.total;
+            body.total = options.pagination.total;
+            body.page = options.pagination.page;
+            body.limit = options.pagination.limit;
+        }
+        return {
+            status: options?.statusCode ?? 200,
+            body,
+        };
+    }
+    /**
+     * Format error response for Web API
+     */
+    static webError(error, options) {
+        const statusCode = options?.statusCode ?? 500;
+        const body = this.buildBase('error', error.message, undefined, error.message);
+        if (options?.log !== false) {
+            console.error(`[Web API Error ${statusCode}]:`, error.message);
+        }
+        return { status: statusCode, body };
+    }
+    // MCP Formatters
+    /**
+     * Format response for MCP tools
+     */
+    static mcp(data, message) {
+        const response = this.buildBase('ok', message, data);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+        };
+    }
+    /**
+     * Format error for MCP tools (throws McpError)
+     */
+    static mcpError(error, context) {
+        const message = context ? `${context}: ${error.message}` : error.message;
+        const response = this.buildBase('error', message, undefined, message);
+        // Import McpError dynamically to avoid requiring @modelcontextprotocol/sdk in non-MCP contexts
+        try {
+            const { McpError, ErrorCode } = require('@modelcontextprotocol/sdk/types.js');
+            throw new McpError(ErrorCode.InternalError, JSON.stringify(response));
+        }
+        catch (e) {
+            // If McpError is not available, throw a standard error with MCP-formatted message
+            const mcpError = new Error(JSON.stringify(response));
+            mcpError.name = 'McpError';
+            throw mcpError;
+        }
+    }
+    // Algorithm Handler Formatters
+    /**
+     * Format response for algorithm handlers
+     */
+    static algorithm(data, message, options) {
+        const isOk = options?.ok !== false;
+        return this.buildBase(isOk ? 'ok' : 'error', message, isOk ? data : undefined, options?.error);
+    }
+    /**
+     * Convenience method for success responses
+     */
+    static success(data, message) {
+        return this.buildBase('ok', message, data);
+    }
+    /**
+     * Convenience method for failure responses
+     */
+    static failure(message, error) {
+        const errorMessage = error instanceof Error ? error.message : error;
+        return this.buildBase('error', message, undefined, errorMessage);
+    }
+}
+//# sourceMappingURL=responses.js.map

package/dist/core/scheduler/cron-scheduler.js

@@ -1,10 +1,11 @@
 /** Cron Scheduler - Persistent cron-based job scheduling with fallback support */
 import cron from 'node-cron';
 import { selfIterationHandler } from '../session-hooks/self-iteration-job.js';
+import { runLifecycleMaintenance } from '../lifecycle.js';
 import { logger } from '../logger.js';
 import { config } from '../../config.js';
 import { getDb } from '../../db/index.js';
-import { maintenanceJobs, maintenanceJobHistory } from '../../drizzle/schema-sqlite.js';
+import { maintenanceJobs, maintenanceJobHistory } from '../../db/drizzle/schema-sqlite.js';
 import { eq } from 'drizzle-orm';
 const jobHandlers = new Map();
 const activeTasks = new Map();
@@ -14,6 +15,20 @@ export function registerJobHandler(jobName, handler) {
 }
 // Register self-iteration job handler
 registerJobHandler('self_iteration', selfIterationHandler);
+// Decay job handler - runs lifecycle maintenance (decay, tier updates, eviction)
+const decayHandler = async (context) => {
+    const stats = await runLifecycleMaintenance();
+    return {
+        recordsProcessed: stats.decayed + stats.expired + stats.evicted,
+        summary: {
+            decayed: stats.decayed,
+            expired: stats.expired,
+            evicted: stats.evicted,
+            tierChanges: stats.tierChanges,
+        },
+    };
+};
+registerJobHandler('decay_maintenance', decayHandler);
 export async function initializeScheduler() {
     if (!config.cronEnabled) {
         logger.info('[Scheduler] Cron scheduling disabled, using heartbeat fallback');
@@ -42,6 +57,13 @@ export async function initializeScheduler() {
 }
 async function ensureDefaultJobs(db) {
     const defaultJobs = [
+        {
+            jobName: 'decay_maintenance',
+            jobType: 'hourly',
+            cronExpression: '0 * * * *', // Run every hour at :00
+            enabled: true,
+            jobConfig: { applyDecay: true, updateTiers: true, evictOld: true },
+        },
         {
             jobName: 'nightly_maintenance',
             jobType: 'nightly',
@@ -110,12 +132,12 @@ async function ensureDefaultJobs(db) {
                 logger.warn(`[Scheduler] Drizzle insert failed, using raw SQL: ${insertError.message}`);
                 const rawDb = db.$client;
                 if (rawDb && typeof rawDb.prepare === 'function') {
-                    const stmt = rawDb.prepare(`
-            INSERT INTO maintenance_jobs 
-            (id, job_name, job_type, cron_expression, enabled, job_config, 
-             total_runs, success_count, failure_count, last_run_at, next_run_at, 
-             last_run_duration, last_run_status, last_run_error)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    const stmt = rawDb.prepare(`
+            INSERT INTO maintenance_jobs 
+            (id, job_name, job_type, cron_expression, enabled, job_config, 
+             total_runs, success_count, failure_count, last_run_at, next_run_at, 
+             last_run_duration, last_run_status, last_run_error)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
           `);
                     stmt.run(crypto.randomUUID(), job.jobName, job.jobType, job.cronExpression, job.enabled ? 1 : 0, JSON.stringify(job.jobConfig), 0, 0, 0, null, null, null, null, null);
                 }

package/dist/core/scheduler/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Scheduler Module
- * v0.10.0 - Cron-based job scheduling with heartbeat fallback
+ * Cron-based job scheduling with heartbeat fallback
  */
 export * from './cron-scheduler.js';
 export * from './heartbeat.js';

package/dist/core/scheduler/index.js

@@ -1,6 +1,6 @@
 /**
  * Scheduler Module
- * v0.10.0 - Cron-based job scheduling with heartbeat fallback
+ * Cron-based job scheduling with heartbeat fallback
  */
 export * from './cron-scheduler.js';
 export * from './heartbeat.js';

package/dist/core/scheduler/job-runner.js

@@ -5,7 +5,7 @@ import { runLifecycleMaintenance } from '../lifecycle.js';
 import { pruneWeakAssociations } from '../associations.js';
 import { pruneOldSummaries } from '../summarization.js';
 import { getDb } from '../../db/index.js';
-import { memories, memoryFeedback } from '../../drizzle/schema-sqlite.js';
+import { memories, memoryFeedback } from '../../db/drizzle/schema-sqlite.js';
 import { eq, and, gt, lt } from 'drizzle-orm';
 export async function runNightlyJob(context) {
     const summary = {};

package/dist/core/search/conversations.js

@@ -2,10 +2,10 @@ import { and, desc, eq, gte, lte } from 'drizzle-orm';
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
 import { config } from '../../config.js';
-import { getProjectByPath } from '../../core/projects.js';
-import { fromSqliteJson } from '../../core/memory/serialization.js';
-import { createDatabaseClient } from '../../core/database.js';
-import { normalizeTimestamp, clampLimit } from '../../core/utils.js';
+import { requireProject } from '../../core/projects.js';
+import { deserializeMetadata } from '../../core/memory/serialization.js';
+import { createDatabaseClient } from '../storage/database.js';
+import { normalizeTimestamp, clampLimit } from '../lib/utils.js';
 export async function searchConversations(input) {
     const limit = clampLimit(input.limit, 5, 1, 50);
     if (config.isTeamMode) {
@@ -19,10 +19,8 @@ export async function getRecentConversations(input) {
     const limit = clampLimit(input.n, 3, 1, 50);
     const whereParts = [];
     if (input.project) {
-        const project = await getProjectByPath(input.project);
-        if (project) {
-            whereParts.push(eq(schema.conversations.projectId, project.id));
-        }
+        const project = await requireProject(input.project);
+        whereParts.push(eq(schema.conversations.projectId, project.id));
     }
     if (input.before) {
         whereParts.push(lte(schema.conversations.startedAt, new Date(input.before)));
@@ -46,24 +44,24 @@ async function searchConversationsSqlite(input, limit) {
         params.push(input.role);
     }
     params.push(limit);
-    const statement = sqlite.prepare(`
-    SELECT DISTINCT
-      c.id as id,
-      c.project_id as projectId,
-      c.session_id as sessionId,
-      c.title as title,
-      c.summary as summary,
-      c.message_count as messageCount,
-      c.token_count as tokenCount,
-      c.started_at as startedAt,
-      c.ended_at as endedAt,
-      c.metadata as metadata
-    FROM conversations c
-    JOIN messages m ON m.conversation_id = c.id
-    JOIN messages_fts ON messages_fts.rowid = m.rowid
-    WHERE ${where}
-    ORDER BY c.started_at DESC
-    LIMIT ?
+    const statement = sqlite.prepare(`
+    SELECT DISTINCT
+      c.id as id,
+      c.project_id as projectId,
+      c.session_id as sessionId,
+      c.title as title,
+      c.summary as summary,
+      c.message_count as messageCount,
+      c.token_count as tokenCount,
+      c.started_at as startedAt,
+      c.ended_at as endedAt,
+      c.metadata as metadata
+    FROM conversations c
+    JOIN messages m ON m.conversation_id = c.id
+    JOIN messages_fts ON messages_fts.rowid = m.rowid
+    WHERE ${where}
+    ORDER BY c.started_at DESC
+    LIMIT ?
   `);
     const rows = statement.all(...params);
     return rows.map((row) => normalizeConversation(row));
@@ -77,26 +75,26 @@ async function searchConversationsPostgres(input, limit) {
         whereParts.push(`m.role = $${values.length}`);
     }
     values.push(limit);
-    const rows = await db.$client.query(`SELECT DISTINCT ON (c.id)
-      c.id as "id",
-      c.project_id as "projectId",
-      c.session_id as "sessionId",
-      c.title as "title",
-      c.summary as "summary",
-      c.message_count as "messageCount",
-      c.token_count as "tokenCount",
-      c.started_at as "startedAt",
-      c.ended_at as "endedAt",
-      c.metadata as "metadata"
-    FROM conversations c
-    JOIN messages m ON m.conversation_id = c.id
-    WHERE ${whereParts.join(' AND ')}
-    ORDER BY c.id, c.started_at DESC
+    const rows = await db.$client.query(`SELECT DISTINCT ON (c.id)
+      c.id as "id",
+      c.project_id as "projectId",
+      c.session_id as "sessionId",
+      c.title as "title",
+      c.summary as "summary",
+      c.message_count as "messageCount",
+      c.token_count as "tokenCount",
+      c.started_at as "startedAt",
+      c.ended_at as "endedAt",
+      c.metadata as "metadata"
+    FROM conversations c
+    JOIN messages m ON m.conversation_id = c.id
+    WHERE ${whereParts.join(' AND ')}
+    ORDER BY c.id, c.started_at DESC
     LIMIT $${values.length}`, values);
     return rows.rows.map((row) => normalizeConversation(row));
 }
 function normalizeConversation(row) {
-    const metadata = config.isTeamMode ? row.metadata : fromSqliteJson(row.metadata ?? null);
+    const metadata = deserializeMetadata(row.metadata ?? null);
     return {
         id: row.id,
         projectId: row.projectId ?? row.project_id ?? null,

package/dist/core/search/entities.js

@@ -1,17 +1,14 @@
 import { desc, eq } from 'drizzle-orm';
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
-import { config } from '../../config.js';
-import { getProjectByPath } from '../../core/projects.js';
-import { fromSqliteJson } from '../../core/memory/serialization.js';
-import { createDatabaseClient } from '../../core/database.js';
-import { normalizeTimestamp } from '../../core/utils.js';
+import { requireProject } from '../../core/projects.js';
+import { deserializeMetadata } from '../../core/memory/serialization.js';
+import { createDatabaseClient } from '../storage/database.js';
+import { normalizeTimestamp } from '../lib/utils.js';
 export async function getEntitiesForProject(projectPath, limit) {
     const db = createDatabaseClient(await getDb());
     const schema = await getSchema();
-    const project = await getProjectByPath(projectPath);
-    if (!project)
-        return [];
+    const project = await requireProject(projectPath);
     const rows = await db.select().from(schema.entities)
         .where(eq(schema.entities.projectId, project.id))
         .orderBy(desc(schema.entities.createdAt))
@@ -19,7 +16,7 @@ export async function getEntitiesForProject(projectPath, limit) {
     return rows.map((row) => normalizeEntity(row));
 }
 function normalizeEntity(row) {
-    const properties = config.isTeamMode ? row.properties : fromSqliteJson(row.properties ?? null);
+    const properties = deserializeMetadata(row.properties ?? null);
     return {
         id: row.id,
         projectId: row.projectId ?? row.project_id ?? null,

package/dist/core/search/graph-boost.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compute a simple graph boost for a set of memory IDs.
+ * For each memory, sum (weight * coactivationCount) of outgoing associations.
+ * Returns a map from memoryId to boost value (default 0).
+ */
+export declare function computeGraphBoost(memoryIds: string[]): Promise<Record<string, number>>;
+//# sourceMappingURL=graph-boost.d.ts.map