@veewo/gitnexus 1.3.10 → 1.3.11

package/dist/mcp/local/unity-parity-cache.test.js

@@ -0,0 +1,143 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { readUnityParityCache, upsertUnityParityCache } from './unity-parity-cache.js';
+test('unity parity cache reads and writes by symbol key', async () => {
+    const storagePath = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-unity-parity-'));
+    try {
+        const before = await readUnityParityCache(storagePath, 'abc123', 'Class:Foo');
+        assert.equal(before, null);
+        await upsertUnityParityCache(storagePath, 'abc123', 'Class:Foo', {
+            resourceBindings: [{
+                    resourcePath: 'Assets/A.prefab',
+                    resourceType: 'prefab',
+                    bindingKind: 'direct',
+                    componentObjectId: '100',
+                    serializedFields: { scalarFields: [], referenceFields: [] },
+                    resolvedReferences: [],
+                    evidence: { line: 1, lineText: 'm_Script: ...' },
+                }],
+            serializedFields: { scalarFields: [], referenceFields: [] },
+            unityDiagnostics: [],
+        });
+        const after = await readUnityParityCache(storagePath, 'abc123', 'Class:Foo');
+        assert.equal(after?.resourceBindings.length, 1);
+        assert.equal(after?.resourceBindings[0]?.componentObjectId, '100');
+    }
+    finally {
+        await fs.rm(storagePath, { recursive: true, force: true });
+    }
+});
+test('unity parity cache invalidates entries on indexed commit change', async () => {
+    const storagePath = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-unity-parity-'));
+    try {
+        await upsertUnityParityCache(storagePath, 'old-commit', 'Class:Foo', {
+            resourceBindings: [{
+                    resourcePath: 'Assets/A.prefab',
+                    resourceType: 'prefab',
+                    bindingKind: 'direct',
+                    componentObjectId: '100',
+                    serializedFields: { scalarFields: [], referenceFields: [] },
+                    resolvedReferences: [],
+                    evidence: { line: 1, lineText: 'm_Script: ...' },
+                }],
+            serializedFields: { scalarFields: [], referenceFields: [] },
+            unityDiagnostics: [],
+        });
+        const stale = await readUnityParityCache(storagePath, 'new-commit', 'Class:Foo');
+        assert.equal(stale, null);
+    }
+    finally {
+        await fs.rm(storagePath, { recursive: true, force: true });
+    }
+});
+test('unity parity cache persists entries in shard files and supports atomic replace', async () => {
+    const storagePath = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-unity-parity-'));
+    try {
+        await upsertUnityParityCache(storagePath, 'abc123', 'Class:Foo', {
+            resourceBindings: [{
+                    resourcePath: 'Assets/A.prefab',
+                    resourceType: 'prefab',
+                    bindingKind: 'direct',
+                    componentObjectId: '101',
+                    serializedFields: { scalarFields: [], referenceFields: [] },
+                    resolvedReferences: [],
+                    evidence: { line: 1, lineText: 'm_Script: ...' },
+                }],
+            serializedFields: { scalarFields: [], referenceFields: [] },
+            unityDiagnostics: [],
+        });
+        await upsertUnityParityCache(storagePath, 'abc123', 'Class:Bar', {
+            resourceBindings: [{
+                    resourcePath: 'Assets/B.prefab',
+                    resourceType: 'prefab',
+                    bindingKind: 'direct',
+                    componentObjectId: '102',
+                    serializedFields: { scalarFields: [], referenceFields: [] },
+                    resolvedReferences: [],
+                    evidence: { line: 1, lineText: 'm_Script: ...' },
+                }],
+            serializedFields: { scalarFields: [], referenceFields: [] },
+            unityDiagnostics: [],
+        });
+        const shardsDir = path.join(storagePath, 'unity-parity-cache');
+        const shards = await fs.readdir(shardsDir);
+        assert.ok(shards.length > 0);
+        assert.ok(shards.every((name) => name.endsWith('.json')));
+    }
+    finally {
+        await fs.rm(storagePath, { recursive: true, force: true });
+    }
+});
+test('unity parity cache evicts oldest entries when max entries exceeded', async () => {
+    const storagePath = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-unity-parity-'));
+    try {
+        const shard = (key) => createHash('sha1').update(key).digest('hex').slice(0, 2);
+        const firstKey = 'Class:A';
+        let secondKey = '';
+        for (let i = 0; i < 4096; i += 1) {
+            const candidate = `Class:B:${i}`;
+            if (shard(candidate) === shard(firstKey)) {
+                secondKey = candidate;
+                break;
+            }
+        }
+        assert.notEqual(secondKey, '');
+        await upsertUnityParityCache(storagePath, 'abc123', firstKey, {
+            resourceBindings: [{
+                    resourcePath: 'Assets/A.prefab',
+                    resourceType: 'prefab',
+                    bindingKind: 'direct',
+                    componentObjectId: '201',
+                    serializedFields: { scalarFields: [], referenceFields: [] },
+                    resolvedReferences: [],
+                    evidence: { line: 1, lineText: 'm_Script: ...' },
+                }],
+            serializedFields: { scalarFields: [], referenceFields: [] },
+            unityDiagnostics: [],
+        }, { maxEntries: 1 });
+        await upsertUnityParityCache(storagePath, 'abc123', secondKey, {
+            resourceBindings: [{
+                    resourcePath: 'Assets/B.prefab',
+                    resourceType: 'prefab',
+                    bindingKind: 'direct',
+                    componentObjectId: '202',
+                    serializedFields: { scalarFields: [], referenceFields: [] },
+                    resolvedReferences: [],
+                    evidence: { line: 1, lineText: 'm_Script: ...' },
+                }],
+            serializedFields: { scalarFields: [], referenceFields: [] },
+            unityDiagnostics: [],
+        }, { maxEntries: 1 });
+        const evicted = await readUnityParityCache(storagePath, 'abc123', firstKey);
+        const retained = await readUnityParityCache(storagePath, 'abc123', secondKey);
+        assert.equal(evicted, null);
+        assert.ok(retained);
+    }
+    finally {
+        await fs.rm(storagePath, { recursive: true, force: true });
+    }
+});

package/dist/mcp/local/unity-parity-seed-loader.d.ts

@@ -0,0 +1,2 @@
+import type { UnityParitySeed } from '../../core/ingestion/unity-parity-seed.js';
+export declare function loadUnityParitySeed(storagePath: string): Promise<UnityParitySeed | null>;

package/dist/mcp/local/unity-parity-seed-loader.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const SEED_FILENAME = 'unity-parity-seed.json';
+export async function loadUnityParitySeed(storagePath) {
+    const seedPath = path.join(storagePath, SEED_FILENAME);
+    let raw = '';
+    try {
+        raw = await fs.readFile(seedPath, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed
+            || parsed.version !== 1
+            || typeof parsed.symbolToScriptPath !== 'object'
+            || typeof parsed.scriptPathToGuid !== 'object'
+            || typeof parsed.guidToResourcePaths !== 'object') {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/mcp/local/unity-parity-seed-loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mcp/local/unity-parity-seed-loader.test.js

@@ -0,0 +1,25 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { loadUnityParitySeed } from './unity-parity-seed-loader.js';
+test('loadUnityParitySeed returns null on missing file and parsed object on valid file', async () => {
+    const storagePath = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-seed-loader-'));
+    try {
+        const missing = await loadUnityParitySeed(storagePath);
+        assert.equal(missing, null);
+        await fs.writeFile(path.join(storagePath, 'unity-parity-seed.json'), JSON.stringify({
+            version: 1,
+            symbolToScriptPath: { DoorObj: 'Assets/Code/DoorObj.cs' },
+            scriptPathToGuid: { 'Assets/Code/DoorObj.cs': 'abc123abc123abc123abc123abc123ab' },
+            guidToResourcePaths: { abc123abc123abc123abc123abc123ab: ['Assets/Prefabs/Door.prefab'] },
+        }), 'utf-8');
+        const loaded = await loadUnityParitySeed(storagePath);
+        assert.equal(loaded?.version, 1);
+        assert.equal(loaded?.symbolToScriptPath.DoorObj, 'Assets/Code/DoorObj.cs');
+    }
+    finally {
+        await fs.rm(storagePath, { recursive: true, force: true });
+    }
+});

package/dist/mcp/local/unity-parity-warmup-queue.d.ts

@@ -0,0 +1,6 @@
+export interface ParityWarmupQueue {
+    run<T>(task: () => Promise<T>): Promise<T>;
+}
+export declare function createParityWarmupQueue(input: {
+    maxParallel: number;
+}): ParityWarmupQueue;

package/dist/mcp/local/unity-parity-warmup-queue.js

@@ -0,0 +1,28 @@
+export function createParityWarmupQueue(input) {
+    const maxParallel = Math.max(1, Math.floor(input.maxParallel || 1));
+    let running = 0;
+    const pending = [];
+    const drain = () => {
+        while (running < maxParallel && pending.length > 0) {
+            const job = pending.shift();
+            if (!job)
+                return;
+            running += 1;
+            job();
+        }
+    };
+    const run = (task) => (new Promise((resolve, reject) => {
+        const exec = () => {
+            Promise.resolve()
+                .then(task)
+                .then(resolve, reject)
+                .finally(() => {
+                running = Math.max(0, running - 1);
+                drain();
+            });
+        };
+        pending.push(exec);
+        drain();
+    }));
+    return { run };
+}

package/dist/mcp/local/unity-parity-warmup-queue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mcp/local/unity-parity-warmup-queue.test.js

@@ -0,0 +1,15 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createParityWarmupQueue } from './unity-parity-warmup-queue.js';
+test('runWarmupTask respects max parallel limit', async () => {
+    let running = 0;
+    let maxSeen = 0;
+    const queue = createParityWarmupQueue({ maxParallel: 2 });
+    await Promise.all(Array.from({ length: 6 }).map(() => queue.run(async () => {
+        running += 1;
+        maxSeen = Math.max(maxSeen, running);
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        running -= 1;
+    })));
+    assert.equal(maxSeen <= 2, true);
+});

package/dist/mcp/tools.js

@@ -35,7 +35,12 @@ Returns results grouped by process (execution flow):
 - process_symbols: all symbols in those flows with file locations and module (functional area)
 - definitions: standalone types/interfaces not in any process
 
-Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank Fusion.`,
+Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank Fusion.
+
+Includes optional Unity retrieval contract:
+- Set unity_resources=on|auto to include Unity resource evidence.
+- Default unity_hydration_mode=compact (fast path).
+- Check response hydrationMeta: when needsParityRetry=true, rerun with unity_hydration_mode=parity for completeness.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -51,6 +56,12 @@ Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank
                     description: 'Unity resource retrieval mode (default: off)',
                     default: 'off',
                 },
+                unity_hydration_mode: {
+                    type: 'string',
+                    enum: ['parity', 'compact'],
+                    description: 'Unity hydration mode when unity_resources is enabled (default: compact)',
+                    default: 'compact',
+                },
                 repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
             },
             required: ['query'],
@@ -104,7 +115,12 @@ Shows categorized incoming/outgoing references (calls, imports, extends, impleme
 WHEN TO USE: After query() to understand a specific symbol in depth. When you need to know all callers, callees, and what execution flows a symbol participates in.
 AFTER THIS: Use impact() if planning changes, or READ gitnexus://repo/{name}/process/{processName} for full execution trace.
 
-Handles disambiguation: if multiple symbols share the same name, returns candidates for you to pick from. Use uid param for zero-ambiguity lookup from prior results.`,
+Handles disambiguation: if multiple symbols share the same name, returns candidates for you to pick from. Use uid param for zero-ambiguity lookup from prior results.
+
+Unity retrieval contract:
+- Set unity_resources=on|auto to include Unity resource evidence.
+- Default unity_hydration_mode=compact (fast path).
+- Check response hydrationMeta: when needsParityRetry=true, rerun with unity_hydration_mode=parity for completeness.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -118,6 +134,12 @@ Handles disambiguation: if multiple symbols share the same name, returns candida
                     description: 'Unity resource retrieval mode (default: off)',
                     default: 'off',
                 },
+                unity_hydration_mode: {
+                    type: 'string',
+                    enum: ['parity', 'compact'],
+                    description: 'Unity hydration mode when unity_resources is enabled (default: compact)',
+                    default: 'compact',
+                },
                 repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
             },
             required: [],

package/dist/types/pipeline.d.ts

@@ -30,6 +30,13 @@ export interface PipelineResult {
     unityResult?: UnityResourceProcessingResult;
     scopeDiagnostics?: ScopeSelectionDiagnostics;
 }
+export interface PipelineRuntimeSummary {
+    totalFileCount: number;
+    communityResult?: CommunityDetectionResult;
+    processResult?: ProcessDetectionResult;
+    unityResult?: UnityResourceProcessingResult;
+    scopeDiagnostics?: ScopeSelectionDiagnostics;
+}
 export interface SerializablePipelineResult {
     nodes: GraphNode[];
     relationships: GraphRelationship[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veewo/gitnexus",
-  "version": "1.3.10",
+  "version": "1.3.11",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",
@@ -54,6 +54,9 @@
     "benchmark:agent-context:quick": "npm run check:neonspark-target && npm run build && node dist/cli/index.js benchmark-agent-context ../benchmarks/agent-context/neonspark-refactor-v1 --profile quick --target-path \"$GITNEXUS_NEONSPARK_TARGET_PATH\" --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt",
     "benchmark:agent-context:full": "npm run check:neonspark-target && npm run build && node dist/cli/index.js benchmark-agent-context ../benchmarks/agent-context/neonspark-refactor-v1 --profile full --target-path \"$GITNEXUS_NEONSPARK_TARGET_PATH\" --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt",
     "benchmark:u2:sample": "npm run build && node dist/benchmark/u2-performance-sampler.js",
+    "benchmark:analyze-memory:sample": "npm run build && node --test dist/benchmark/analyze-memory-sampler.test.js",
+    "benchmark:unity:lazy-context": "npm run build && node dist/benchmark/unity-lazy-context-sampler.js",
+    "benchmark:unity:hydration-gates": "npm run build && node dist/benchmark/unity-lazy-context-sampler.js",
     "benchmark:u2:e2e": "npm run check:u2-e2e-target && npm run build && node dist/cli/index.js benchmark-u2-e2e --config ../benchmarks/u2-e2e/neonspark-full-u2-e2e.config.json"
   },
   "dependencies": {

package/skills/gitnexus-cli.md

@@ -70,6 +70,24 @@ npx gitnexus list
 
 Lists all repositories registered in `~/.gitnexus/registry.json`. The MCP `list_repos` tool provides the same information.
 
+### query/context — Unity hydration mode
+
+For Unity resource retrieval:
+
+```bash
+npx gitnexus context DoorObj --repo neonnew-core --file Assets/NEON/Code/Game/Doors/DoorObj.cs --unity-resources on --unity-hydration compact
+```
+
+```bash
+npx gitnexus query "DoorObj binding" --repo neonnew-core --unity-resources on --unity-hydration compact
+```
+
+Rules:
+
+- `--unity-hydration compact` is the default (fast path).
+- If response `hydrationMeta.needsParityRetry=true`, rerun with `--unity-hydration parity`.
+- `--unity-hydration parity` is completeness-first mode for advanced verification.
+
 ## After Indexing
 
 1. **Read `gitnexus://repo/{name}/context`** to verify the index loaded

package/skills/gitnexus-debugging.md

@@ -18,8 +18,9 @@ description: "Use when the user is debugging a bug, tracing an error, or asking
 ```
 1. gitnexus_query({query: "<error or symptom>"})            → Find related execution flows
 2. gitnexus_context({name: "<suspect>"})                    → See callers/callees/processes
-3. READ gitnexus://repo/{name}/process/{name}                → Trace execution flow
-4. gitnexus_cypher({query: "MATCH path..."})                 → Custom traces if needed
+3. (Unity symbols) use unity_resources + hydration contract
+4. READ gitnexus://repo/{name}/process/{name}                → Trace execution flow
+5. gitnexus_cypher({query: "MATCH path..."})                 → Custom traces if needed
 ```
 
 > If "Index is stale" → run `npx gitnexus analyze` in terminal.
@@ -31,6 +32,8 @@ description: "Use when the user is debugging a bug, tracing an error, or asking
 - [ ] gitnexus_query for error text or related code
 - [ ] Identify the suspect function from returned processes
 - [ ] gitnexus_context to see callers and callees
+- [ ] For Unity retrieval, start with `unity_hydration_mode: "compact"` and inspect `hydrationMeta`
+- [ ] If `hydrationMeta.needsParityRetry === true`, rerun with `unity_hydration_mode: "parity"` before concluding root cause
 - [ ] Trace execution flow via process resource if applicable
 - [ ] gitnexus_cypher for custom call chain traces if needed
 - [ ] Read source files to confirm root cause
@@ -65,6 +68,17 @@ gitnexus_context({name: "validatePayment"})
 → Processes: CheckoutFlow (step 3/7)
 ```
 
+**Unity debug retrieval** — explicit completeness control:
+
+```
+gitnexus_context({
+  name: "DoorObj",
+  unity_resources: "on",
+  unity_hydration_mode: "compact"
+})
+→ if hydrationMeta.needsParityRetry then rerun with unity_hydration_mode: "parity"
+```
+
 **gitnexus_cypher** — custom call chain traces:
 
 ```cypher

package/skills/gitnexus-exploring.md

@@ -20,7 +20,8 @@ description: "Use when the user asks how code works, wants to understand archite
 2. READ gitnexus://repo/{name}/context             → Codebase overview, check staleness
 3. gitnexus_query({query: "<what you want to understand>"})  → Find related execution flows
 4. gitnexus_context({name: "<symbol>"})            → Deep dive on specific symbol
-5. READ gitnexus://repo/{name}/process/{name}      → Trace full execution flow
+5. (Unity symbols) rerun context/query with unity params when needed
+6. READ gitnexus://repo/{name}/process/{name}      → Trace full execution flow
 ```
 
 > If step 2 says "Index is stale" → run `npx gitnexus analyze` in terminal.
@@ -32,6 +33,8 @@ description: "Use when the user asks how code works, wants to understand archite
 - [ ] gitnexus_query for the concept you want to understand
 - [ ] Review returned processes (execution flows)
 - [ ] gitnexus_context on key symbols for callers/callees
+- [ ] For Unity evidence, call context/query with `unity_resources: "on"` and `unity_hydration_mode: "compact"`
+- [ ] If `hydrationMeta.needsParityRetry === true`, rerun with `unity_hydration_mode: "parity"`
 - [ ] READ process resource for full execution traces
 - [ ] Read source files for implementation details
 ```
@@ -64,6 +67,17 @@ gitnexus_context({name: "validateUser"})
 → Processes: LoginFlow (step 2/5), TokenRefresh (step 1/3)
 ```
 
+**Unity-focused context/query** — use compact first, parity only when needed:
+
+```
+gitnexus_context({
+  name: "DoorObj",
+  unity_resources: "on",
+  unity_hydration_mode: "compact"
+})
+→ hydrationMeta.needsParityRetry ? rerun with unity_hydration_mode: "parity" : continue
+```
+
 ## Example: "How does payment processing work?"
 
 ```

package/skills/gitnexus-guide.md

@@ -40,6 +40,21 @@ For any task involving code understanding, debugging, impact analysis, or refact
 | `cypher`         | Raw graph queries (read `gitnexus://repo/{name}/schema` first)           |
 | `list_repos`     | Discover indexed repos                                                   |
 
+### Unity Retrieval Contract (query/context)
+
+When you need Unity resource evidence, pass:
+
+- `unity_resources: "on"` (or `"auto"` when you want adaptive behavior)
+- `unity_hydration_mode: "compact" | "parity"` (default: `"compact"`)
+
+Recommended default workflow:
+
+1. Call `context/query` with `unity_hydration_mode: "compact"` for speed.
+2. Inspect `hydrationMeta` in the response:
+   - `needsParityRetry: true` → rerun same call with `unity_hydration_mode: "parity"`
+   - `isComplete: true` → keep compact result
+3. Treat parity as the completeness path for advanced verification.
+
 ## Resources Reference
 
 Lightweight reads (~100-500 tokens) for navigation:

package/skills/gitnexus-impact-analysis.md

@@ -31,6 +31,8 @@ description: "Use when the user wants to know what will break if they change som
 - [ ] gitnexus_impact({target, direction: "upstream"}) to find dependents
 - [ ] Review d=1 items first (these WILL BREAK)
 - [ ] Check high-confidence (>0.8) dependencies
+- [ ] For Unity symbols, verify `context(..., unity_resources: "on")` hydration completeness
+- [ ] If compact response has `hydrationMeta.needsParityRetry === true`, rerun in parity before final risk call
 - [ ] READ processes to check affected execution flows
 - [ ] gitnexus_detect_changes() for pre-commit check
 - [ ] Assess risk level and report to user

package/skills/gitnexus-refactoring.md

@@ -19,7 +19,8 @@ description: "Use when the user wants to rename, extract, split, move, or restru
 1. gitnexus_impact({target: "X", direction: "upstream"})  → Map all dependents
 2. gitnexus_query({query: "X"})                            → Find execution flows involving X
 3. gitnexus_context({name: "X"})                           → See all incoming/outgoing refs
-4. Plan update order: interfaces → implementations → callers → tests
+4. (Unity symbols) validate compact/parity retrieval completeness
+5. Plan update order: interfaces → implementations → callers → tests
 ```
 
 > If "Index is stale" → run `npx gitnexus analyze` in terminal.
@@ -40,6 +41,8 @@ description: "Use when the user wants to rename, extract, split, move, or restru
 
 ```
 - [ ] gitnexus_context({name: target}) — see all incoming/outgoing refs
+- [ ] For Unity targets: `unity_resources: "on"`, `unity_hydration_mode: "compact"` first
+- [ ] If `hydrationMeta.needsParityRetry === true`, rerun with `unity_hydration_mode: "parity"` before extraction
 - [ ] gitnexus_impact({target, direction: "upstream"}) — find all external callers
 - [ ] Define new module interface
 - [ ] Extract code, update imports
@@ -51,6 +54,7 @@ description: "Use when the user wants to rename, extract, split, move, or restru
 
 ```
 - [ ] gitnexus_context({name: target}) — understand all callees
+- [ ] For Unity targets: ensure final verification run uses parity when compact requests retry
 - [ ] Group callees by responsibility
 - [ ] gitnexus_impact({target, direction: "upstream"}) — map callers to update
 - [ ] Create new functions/services