@jagilber-org/index-server 1.19.1

package/dist/services/features.js

@@ -0,0 +1,35 @@
+"use strict";
+// Feature flag & metrics infrastructure (Phase 0)
+// INDEX_SERVER_FEATURES=usage,window,hotness,drift,risk
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasFeature = hasFeature;
+exports.incrementCounter = incrementCounter;
+exports.getCounters = getCounters;
+exports.featureStatus = featureStatus;
+exports.enableFeature = enableFeature;
+const runtimeConfig_1 = require("../config/runtimeConfig");
+const BASE_FEATURES = Array.from((0, runtimeConfig_1.getRuntimeConfig)().featureFlags.indexFeatures);
+const SET = new Set(BASE_FEATURES);
+function hasFeature(name) { return SET.has(name); }
+// Simple in-memory counters (could be exposed via metrics_snapshot already existing)
+const counters = {};
+function incrementCounter(name, by = 1) { counters[name] = (counters[name] || 0) + by; }
+function getCounters() { return { ...counters }; }
+// Record activation counts once at module load
+for (const f of SET) {
+    incrementCounter(`featureActivated:${f}`);
+}
+function featureStatus() {
+    return {
+        features: Array.from(SET.values()).sort(),
+        counters: getCounters(),
+        env: BASE_FEATURES.length ? [...BASE_FEATURES] : [],
+    };
+}
+// Test helper / dynamic enable (used in tests to activate features post-initial load)
+function enableFeature(name) {
+    if (!SET.has(name)) {
+        SET.add(name);
+        incrementCounter(`featureActivated:${name}`);
+    }
+}

package/dist/services/handlers/instructions.add.d.ts

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

package/dist/services/handlers/instructions.add.js

@@ -0,0 +1,496 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const registry_1 = require("../../server/registry");
+const indexContext_1 = require("../indexContext");
+const features_1 = require("../features");
+const schemaVersion_1 = require("../../versioning/schemaVersion");
+const classificationService_1 = require("../classificationService");
+const ownershipService_1 = require("../ownershipService");
+const atomicFs_1 = require("../atomicFs");
+const auditLog_1 = require("../auditLog");
+const toolRegistry_1 = require("../toolRegistry");
+const runtimeConfig_1 = require("../../config/runtimeConfig");
+const canonical_1 = require("../canonical");
+const manifestManager_1 = require("../manifestManager");
+const tracing_1 = require("../tracing");
+const instructions_shared_1 = require("./instructions.shared");
+(0, registry_1.registerHandler)('index_add', (0, instructions_shared_1.guard)('index_add', (p) => {
+    const e = p.entry;
+    const instructionsCfg = (0, runtimeConfig_1.getRuntimeConfig)().instructions;
+    const SEMVER_REGEX = /^([0-9]+)\.([0-9]+)\.([0-9]+)(?:[-+].*)?$/;
+    const ADD_INPUT_SCHEMA = (0, toolRegistry_1.getToolRegistry)({ tier: 'admin' }).find(t => t.name === 'index_add')?.inputSchema;
+    const fail = (error, opts) => {
+        const id = opts?.id || (e && e.id) || 'unknown';
+        const rawBody = e && typeof e.body === 'string' ? e.body : (e && e.body ? String(e.body) : '');
+        const bodyPreview = rawBody.trim().slice(0, 200);
+        const reproEntry = e ? {
+            id,
+            title: e.title || id,
+            requirement: e.requirement,
+            priorityTier: e.priorityTier,
+            owner: e.owner,
+            bodyPreview
+        } : { id };
+        const base = {
+            id,
+            created: false,
+            overwritten: false,
+            skipped: false,
+            error,
+            hash: opts?.hash,
+            feedbackHint: 'Creation failed. If unexpected, call feedback_submit with reproEntry.',
+            reproEntry
+        };
+        if (/^missing (entry|id|required fields)/.test(error) || error === 'missing required fields') {
+            if (ADD_INPUT_SCHEMA) {
+                base.schemaRef = "meta_tools[name='index_add'].inputSchema";
+                base.inputSchema = ADD_INPUT_SCHEMA;
+            }
+            else {
+                base.schemaRef = 'meta_tools (lookup index_add)';
+            }
+        }
+        return base;
+    };
+    if (!e)
+        return fail('missing entry');
+    const lax = !!(p.lax || e?.lax);
+    if (lax) {
+        if (!e.id)
+            return fail('missing id');
+        const mutable = e;
+        if (!mutable.title)
+            mutable.title = mutable.id;
+        if (typeof mutable.priority !== 'number')
+            mutable.priority = 50;
+        if (!mutable.audience)
+            mutable.audience = 'all';
+        if (!mutable.requirement)
+            mutable.requirement = 'optional';
+        if (!Array.isArray(mutable.categories))
+            mutable.categories = [];
+    }
+    if (p.overwrite && (!e.body || !e.title)) {
+        try {
+            const dirCandidate = (0, indexContext_1.getInstructionsDir)();
+            const fileCandidate = path_1.default.join(dirCandidate, `${e.id}.json`);
+            if (fs_1.default.existsSync(fileCandidate)) {
+                try {
+                    const raw = JSON.parse(fs_1.default.readFileSync(fileCandidate, 'utf8'));
+                    if (raw) {
+                        const mutableExisting = e;
+                        if (!mutableExisting.body && typeof raw.body === 'string' && raw.body.trim()) {
+                            mutableExisting.body = raw.body;
+                        }
+                        if (!mutableExisting.title && typeof raw.title === 'string' && raw.title.trim()) {
+                            mutableExisting.title = raw.title;
+                        }
+                    }
+                }
+                catch { /* ignore parse */ }
+            }
+        }
+        catch { /* ignore hydration errors */ }
+    }
+    if (!e.id || !e.title || !e.body)
+        return fail('missing required fields');
+    const dir = (0, indexContext_1.getInstructionsDir)();
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    const file = path_1.default.join(dir, `${e.id}.json`);
+    const exists = fs_1.default.existsSync(file);
+    const existedBeforeOriginal = exists;
+    const overwrite = !!p.overwrite;
+    if (exists && !overwrite) {
+        let st0 = (0, indexContext_1.ensureLoaded)();
+        let visible = st0.byId.has(e.id);
+        let repaired = false;
+        if (!visible) {
+            try {
+                (0, indexContext_1.invalidate)();
+                st0 = (0, indexContext_1.ensureLoaded)();
+                visible = st0.byId.has(e.id);
+                if (visible)
+                    repaired = true;
+            }
+            catch { /* ignore reload */ }
+            if (!visible) {
+                const filePath = file;
+                if (fs_1.default.existsSync(filePath)) {
+                    try {
+                        const rawTxt = fs_1.default.readFileSync(filePath, 'utf8');
+                        if (rawTxt.trim()) {
+                            const rawJson = JSON.parse(rawTxt);
+                            const classifier = new classificationService_1.ClassificationService();
+                            const issues = classifier.validate(rawJson);
+                            if (!issues.length) {
+                                const norm = classifier.normalize(rawJson);
+                                st0.list.push(norm);
+                                st0.byId.set(norm.id, norm);
+                                visible = true;
+                                repaired = true;
+                                (0, features_1.incrementCounter)('instructions:addSkipLateMaterialize');
+                            }
+                            else {
+                                (0, features_1.incrementCounter)('instructions:addSkipLateMaterializeRejected');
+                            }
+                        }
+                        else {
+                            (0, features_1.incrementCounter)('instructions:addSkipLateMaterializeEmpty');
+                        }
+                    }
+                    catch {
+                        (0, features_1.incrementCounter)('instructions:addSkipLateMaterializeParseError');
+                    }
+                }
+            }
+        }
+        (0, auditLog_1.logAudit)('add', e.id, { skipped: true, late_visible: visible, repaired });
+        if ((0, instructions_shared_1.traceVisibility)()) {
+            (0, tracing_1.emitTrace)('[trace:add:skip]', { id: e.id, visible, repaired });
+        }
+        if ((0, instructions_shared_1.traceVisibility)()) {
+            (0, instructions_shared_1.traceInstructionVisibility)(e.id, 'add-skip-pre-return', { visible, repaired });
+            if (!visible)
+                (0, instructions_shared_1.traceEnvSnapshot)('add-skip-anomalous', { repaired });
+        }
+        if (!visible) {
+            return { id: e.id, skipped: true, created: false, overwritten: false, hash: st0.hash, visibilityWarning: 'skipped_file_not_in_index' };
+        }
+        return { id: e.id, skipped: true, created: false, overwritten: false, hash: st0.hash, repaired: repaired ? true : undefined };
+    }
+    const now = new Date().toISOString();
+    const rawBody = typeof e.body === 'string' ? e.body : String(e.body || '');
+    const bodyTrimmed = rawBody.trim();
+    const { bodyMaxLength } = (0, runtimeConfig_1.getRuntimeConfig)().index;
+    if (bodyTrimmed.length > bodyMaxLength) {
+        return {
+            ...fail('body_too_large', { id: e.id }),
+            bodyLength: bodyTrimmed.length,
+            maxLength: bodyMaxLength,
+            guidance: `Body exceeds the ${bodyMaxLength}-character limit (${bodyTrimmed.length} chars). Please split into multiple cross-linked instructions, refine/compress content, or categorize sections as separate entries. Use categories and cross-references (e.g., "See also: <sibling-id>") to maintain discoverability.`
+        };
+    }
+    let categories = Array.from(new Set((Array.isArray(e.categories) ? e.categories : []).filter((c) => typeof c === 'string' && c.trim().length > 0).map(c => c.toLowerCase()))).sort();
+    if (!categories.length) {
+        const allowAuto = lax || !instructionsCfg.requireCategory;
+        if (allowAuto) {
+            categories = ['uncategorized'];
+            if ((0, instructions_shared_1.traceVisibility)())
+                (0, tracing_1.emitTrace)('[trace:add:auto-category]', { id: e.id });
+            (0, features_1.incrementCounter)('instructions:autoCategory');
+        }
+        else {
+            return fail('category_required', { id: e.id });
+        }
+    }
+    const suppliedPrimary = e.primaryCategory;
+    const primaryCategory = (suppliedPrimary && categories.includes(suppliedPrimary.toLowerCase())) ? suppliedPrimary.toLowerCase() : categories[0];
+    const sourceHash = instructionsCfg.canonicalDisable
+        ? crypto_1.default.createHash('sha256').update(bodyTrimmed, 'utf8').digest('hex')
+        : (0, canonical_1.hashBody)(rawBody);
+    if (e.priorityTier === 'P1' && (!categories.length || !e.owner))
+        return fail('P1 requires category & owner', { id: e.id });
+    if ((e.requirement === 'mandatory' || e.requirement === 'critical') && !e.owner)
+        return fail('mandatory/critical require owner', { id: e.id });
+    const classifier = new classificationService_1.ClassificationService();
+    let base;
+    if (exists) {
+        try {
+            const existing = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+            base = { ...existing };
+            const prevBody = existing.body;
+            const prevVersion = existing.version || '1.0.0';
+            if (e.title)
+                base.title = e.title;
+            if (e.body)
+                base.body = bodyTrimmed;
+            if (e.rationale !== undefined)
+                base.rationale = e.rationale;
+            if (typeof e.priority === 'number')
+                base.priority = e.priority;
+            if (e.audience)
+                base.audience = e.audience;
+            if (e.requirement)
+                base.requirement = e.requirement;
+            if (categories.length) {
+                base.categories = categories;
+                base.primaryCategory = primaryCategory;
+            }
+            base.updatedAt = now;
+            if (e.version !== undefined)
+                base.version = e.version;
+            if (e.changeLog !== undefined)
+                base.changeLog = e.changeLog;
+            const semverRegex = SEMVER_REGEX;
+            const parse = (v) => { const m = semverRegex.exec(v); if (!m)
+                return null; return { major: +m[1], minor: +m[2], patch: +m[3] }; };
+            const gt = (a, b) => { const pa = parse(a), pb = parse(b); if (!pa || !pb)
+                return false; if (pa.major !== pb.major)
+                return pa.major > pb.major; if (pa.minor !== pb.minor)
+                return pa.minor > pb.minor; return pa.patch > pb.patch; };
+            const bodyChanged = e.body ? (bodyTrimmed !== prevBody) : false;
+            const titleChanged = e.title !== undefined && e.title !== existing.title;
+            const eRec = e;
+            const ownerChanged = eRec.owner !== undefined && eRec.owner !== existing.owner;
+            const semanticSummaryChanged = eRec.semanticSummary !== undefined && eRec.semanticSummary !== existing.semanticSummary;
+            const classificationChanged = eRec.classification !== undefined && eRec.classification !== existing.classification;
+            const versionChanged = e.version !== undefined && e.version !== existing.version;
+            const categoriesChanged = categories.length > 0 && JSON.stringify(categories.sort()) !== JSON.stringify((existing.categories || []).sort());
+            const governanceMetaChanged = titleChanged || ownerChanged || semanticSummaryChanged || classificationChanged || versionChanged || categoriesChanged;
+            if (overwrite && !bodyChanged && !governanceMetaChanged) {
+                const stNoop = (0, indexContext_1.ensureLoaded)();
+                const respNoop = { id: e.id, created: false, overwritten: false, skipped: true, hash: stNoop.hash, verified: true };
+                if (instructionsCfg.strictCreate)
+                    respNoop.strictVerified = true;
+                (0, auditLog_1.logAudit)('add', e.id, { created: false, overwritten: false, skipped: true, verified: true, noop: true });
+                if ((0, instructions_shared_1.traceVisibility)())
+                    (0, tracing_1.emitTrace)('[trace:add:noop-overwrite]', { id: e.id, hash: stNoop.hash, reason: 'no body/governance delta' });
+                return respNoop;
+            }
+            let incomingVersion = e.version;
+            if (incomingVersion && !semverRegex.test(incomingVersion))
+                return fail('invalid_semver', { id: e.id });
+            if (bodyChanged) {
+                if (incomingVersion) {
+                    if (!gt(incomingVersion, prevVersion))
+                        return fail('version_not_bumped', { id: e.id });
+                }
+                else {
+                    const pv = parse(prevVersion) || { major: 1, minor: 0, patch: 0 };
+                    const autoVersion = `${pv.major}.${pv.minor}.${pv.patch + 1}`;
+                    base.version = autoVersion;
+                    incomingVersion = autoVersion;
+                }
+            }
+            else if (incomingVersion) {
+                if (!gt(incomingVersion, prevVersion))
+                    return fail('version_not_bumped', { id: e.id });
+            }
+            else {
+                base.version = prevVersion;
+                incomingVersion = prevVersion;
+            }
+            if (!Array.isArray(base.changeLog) || !base.changeLog.length) {
+                base.changeLog = [{ version: prevVersion, changedAt: existing.createdAt || now, summary: 'initial import' }];
+            }
+            const finalVersion = base.version || incomingVersion || prevVersion;
+            const last = base.changeLog[base.changeLog.length - 1];
+            if (last.version !== finalVersion) {
+                const summary = bodyChanged ? (e.version ? 'body update' : 'auto bump (body change)') : 'metadata update';
+                base.changeLog.push({ version: finalVersion, changedAt: now, summary });
+            }
+            const repairChangeLog = (cl) => {
+                const out = [];
+                if (Array.isArray(cl)) {
+                    for (const entry of cl) {
+                        if (!entry || typeof entry !== 'object')
+                            continue;
+                        const { version: v, changedAt: ca, summary: sum } = entry;
+                        if (typeof v === 'string' && v.trim() && typeof sum === 'string' && sum.trim()) {
+                            const caIso = typeof ca === 'string' && /T/.test(ca) ? ca : now;
+                            out.push({ version: v.trim(), changedAt: caIso, summary: sum.trim() });
+                        }
+                    }
+                }
+                if (!out.length) {
+                    out.push({ version: prevVersion, changedAt: existing.createdAt || now, summary: 'initial import (repaired)' });
+                }
+                const lastVer = out[out.length - 1].version;
+                if (lastVer !== finalVersion) {
+                    out.push({ version: finalVersion, changedAt: now, summary: bodyChanged ? 'body update (repaired)' : 'metadata update (repaired)' });
+                }
+                return out;
+            };
+            base.changeLog = repairChangeLog(base.changeLog);
+        }
+        catch {
+            base = { id: e.id, title: e.title, body: bodyTrimmed, rationale: e.rationale, priority: e.priority, audience: e.audience, requirement: e.requirement, categories, primaryCategory, sourceHash, schemaVersion: schemaVersion_1.SCHEMA_VERSION, deprecatedBy: e.deprecatedBy, createdAt: now, updatedAt: now, riskScore: e.riskScore, createdByAgent: instructionsCfg.agentId, sourceWorkspace: instructionsCfg.workspaceId };
+            base.version = '1.0.0';
+            base.changeLog = [{ version: '1.0.0', changedAt: now, summary: 'initial import' }];
+        }
+    }
+    else {
+        base = { id: e.id, title: e.title, body: bodyTrimmed, rationale: e.rationale, priority: e.priority, audience: e.audience, requirement: e.requirement, categories, primaryCategory, sourceHash, schemaVersion: schemaVersion_1.SCHEMA_VERSION, deprecatedBy: e.deprecatedBy, createdAt: now, updatedAt: now, riskScore: e.riskScore, createdByAgent: instructionsCfg.agentId, sourceWorkspace: instructionsCfg.workspaceId };
+        if (e.version !== undefined) {
+            if (!SEMVER_REGEX.test(e.version))
+                return fail('invalid_semver', { id: e.id });
+            base.version = e.version;
+        }
+        else {
+            base.version = '1.0.0';
+        }
+        if (!Array.isArray(base.changeLog) || !base.changeLog.length) {
+            base.changeLog = [{ version: base.version, changedAt: now, summary: 'initial import' }];
+        }
+        if (Array.isArray(base.changeLog)) {
+            const repaired = [];
+            for (const entry of base.changeLog) {
+                if (!entry || typeof entry !== 'object')
+                    continue;
+                const { version: v, changedAt: ca, summary: sum } = entry;
+                if (typeof v === 'string' && v.trim() && typeof sum === 'string' && sum.trim()) {
+                    const caIso = typeof ca === 'string' && /T/.test(ca) ? ca : now;
+                    repaired.push({ version: v.trim(), changedAt: caIso, summary: sum.trim() });
+                }
+            }
+            if (!repaired.length) {
+                repaired.push({ version: base.version, changedAt: now, summary: 'initial import (repaired)' });
+            }
+            if (repaired[repaired.length - 1].version !== base.version) {
+                repaired.push({ version: base.version, changedAt: now, summary: 'initial import (normalized)' });
+            }
+            base.changeLog = repaired;
+        }
+    }
+    const govKeys = ['version', 'owner', 'status', 'priorityTier', 'classification', 'lastReviewedAt', 'nextReviewDue', 'semanticSummary', 'contentType'];
+    for (const k of govKeys) {
+        const v = e[k];
+        if (v !== undefined) {
+            base[k] = v;
+        }
+    }
+    if (!exists || base.body === bodyTrimmed) {
+        base.sourceHash = sourceHash;
+    }
+    else {
+        base.sourceHash = instructionsCfg.canonicalDisable
+            ? crypto_1.default.createHash('sha256').update(base.body, 'utf8').digest('hex')
+            : (0, canonical_1.hashBody)(base.body);
+    }
+    const record = classifier.normalize(base);
+    if (record.owner === 'unowned') {
+        const auto = (0, ownershipService_1.resolveOwner)(record.id);
+        if (auto) {
+            record.owner = auto;
+            record.updatedAt = new Date().toISOString();
+        }
+    }
+    try {
+        (0, atomicFs_1.atomicWriteJson)(file, record);
+    }
+    catch (err) {
+        return fail(err.message || 'write-failed', { id: e.id });
+    }
+    try {
+        (0, indexContext_1.touchIndexVersion)();
+    }
+    catch { /* ignore */ }
+    let stReloaded;
+    const strictMode = instructionsCfg.strictVisibility;
+    if (strictMode) {
+        try {
+            const current = (0, indexContext_1.ensureLoaded)();
+            stReloaded = current;
+            if (!current.byId.has(record.id)) {
+                current.byId.set(record.id, record);
+                current.list.push(record);
+            }
+        }
+        catch { /* fallback to reload path below if anything fails */ }
+    }
+    if (!stReloaded) {
+        try {
+            (0, indexContext_1.invalidate)();
+        }
+        catch { /* ignore */ }
+        stReloaded = (0, indexContext_1.ensureLoaded)();
+    }
+    const createdNow = !existedBeforeOriginal;
+    const overwrittenNow = overwrite && existedBeforeOriginal;
+    let strictVerified = false;
+    const verifyIssues = [];
+    try {
+        let diskRaw;
+        let parsed;
+        try {
+            diskRaw = fs_1.default.readFileSync(file, 'utf8');
+        }
+        catch (ex) {
+            verifyIssues.push('read-failed:' + ex.message);
+        }
+        if (diskRaw) {
+            try {
+                parsed = JSON.parse(diskRaw);
+            }
+            catch (ex) {
+                verifyIssues.push('parse-failed:' + ex.message);
+            }
+            if (parsed) {
+                if (parsed.id !== e.id)
+                    verifyIssues.push('id-mismatch');
+                if (!parsed.title)
+                    verifyIssues.push('missing-title');
+                if (!parsed.body)
+                    verifyIssues.push('missing-body');
+                const wantCats = Array.isArray(e.categories) ? e.categories.filter((c) => typeof c === 'string').map(c => c.toLowerCase()) : [];
+                if (wantCats.length) {
+                    for (const c of wantCats) {
+                        if (!parsed.categories?.includes(c)) {
+                            verifyIssues.push('missing-category:' + c);
+                        }
+                    }
+                }
+            }
+        }
+        const mem = stReloaded.byId.get(e.id);
+        if (!mem) {
+            verifyIssues.push('not-in-index');
+        }
+        const wantCats2 = Array.isArray(e.categories) ? e.categories.filter((c) => typeof c === 'string').map(c => c.toLowerCase()) : [];
+        if (wantCats2.length) {
+            const catHit = stReloaded.list.some(rec => rec.id === e.id && wantCats2.every(c => rec.categories.includes(c)));
+            if (!catHit)
+                verifyIssues.push('category-query-miss');
+        }
+        try {
+            if (parsed) {
+                const classifier2 = new classificationService_1.ClassificationService();
+                const issues = classifier2.validate(parsed);
+                if (issues.length) {
+                    verifyIssues.push('classification-issues:' + issues.join(','));
+                }
+            }
+        }
+        catch (err) {
+            verifyIssues.push('classification-exception:' + err.message);
+        }
+        if (verifyIssues.includes('not-in-index')) {
+            try {
+                (0, indexContext_1.invalidate)();
+                const st2 = (0, indexContext_1.ensureLoaded)();
+                if (st2.byId.has(e.id)) {
+                    const idx = verifyIssues.indexOf('not-in-index');
+                    if (idx >= 0)
+                        verifyIssues.splice(idx, 1);
+                }
+            }
+            catch { /* ignore */ }
+        }
+        if (!verifyIssues.length)
+            strictVerified = true;
+    }
+    catch (err) {
+        verifyIssues.push('verify-exception:' + err.message);
+    }
+    try {
+        if (instructionsCfg.manifest.writeEnabled)
+            (0, manifestManager_1.writeManifestFromIndex)();
+        else
+            setImmediate(() => { try {
+                (0, manifestManager_1.attemptManifestUpdate)();
+            }
+            catch { /* ignore */ } });
+    }
+    catch { /* ignore manifest */ }
+    (0, auditLog_1.logAudit)('add', e.id, { created: createdNow, overwritten: overwrittenNow, verified: true, forcedReload: true });
+    if ((0, instructions_shared_1.traceVisibility)())
+        (0, tracing_1.emitTrace)('[trace:add:forced-reload]', { id: e.id, created: createdNow, overwritten: overwrittenNow, hash: stReloaded.hash, strictVerified, issues: verifyIssues.slice(0, 5), strictMode });
+    return { id: e.id, created: createdNow, overwritten: overwrittenNow, skipped: false, hash: stReloaded.hash, verified: true, strictVerified, verifyIssues: verifyIssues.length ? verifyIssues : undefined, strictMode, bodyLength: bodyTrimmed.length };
+}));

package/dist/services/handlers/instructions.groom.d.ts

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