ofcoop-shared-core 0.1.0-alpha.0

package/dist/services/impl/DbAdapterShuConfigService.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbAdapterShuConfigService = void 0;
+const ShuConfigService_1 = require("../ShuConfigService");
+const runtimeSupport_1 = require("./runtimeSupport");
+class DbAdapterShuConfigService {
+    constructor(repos, options = {}) {
+        this.repos = repos;
+        this.options = options;
+        this.newId = (0, runtimeSupport_1.makeIdFactory)('shu-config');
+    }
+    async getActiveShuConfig(scope) {
+        return this.repos.shuConfigRepository.getActive(scope);
+    }
+    async upsertShuConfig(input) {
+        (0, ShuConfigService_1.assertValidShuConfigInput)(input);
+        const scope = { koperasiId: input.koperasiId, tenantId: input.tenantId, branchId: input.branchId };
+        const current = await this.repos.shuConfigRepository.getActive(scope);
+        const now = (0, runtimeSupport_1.nowIso)();
+        if (current) {
+            const updated = await this.repos.shuConfigRepository.upsert({
+                ...current,
+                ...input,
+                notes: input.notes ?? null,
+                approvalRef: input.approvalRef ?? null,
+                version: current.version + 1,
+                lastModified: now,
+            });
+            await (0, runtimeSupport_1.emitDomainEvent)(this.options, {
+                name: 'shu.config-upserted',
+                occurredAt: (0, runtimeSupport_1.nowIso)(),
+                entityId: updated.id,
+                tenantId: updated.tenantId ?? null,
+                branchId: updated.branchId ?? null,
+                payload: { effectiveDate: updated.effectiveDate },
+            });
+            return updated;
+        }
+        const created = await this.repos.shuConfigRepository.upsert({
+            id: this.newId(),
+            ...input,
+            notes: input.notes ?? null,
+            approvalRef: input.approvalRef ?? null,
+            version: 1,
+            lastModified: now,
+            deleted: false,
+        });
+        await (0, runtimeSupport_1.emitDomainEvent)(this.options, {
+            name: 'shu.config-upserted',
+            occurredAt: (0, runtimeSupport_1.nowIso)(),
+            entityId: created.id,
+            tenantId: created.tenantId ?? null,
+            branchId: created.branchId ?? null,
+            payload: { effectiveDate: created.effectiveDate },
+        });
+        return created;
+    }
+    async listShuConfigs(scope, options) {
+        return this.repos.shuConfigRepository.list(scope, options);
+    }
+}
+exports.DbAdapterShuConfigService = DbAdapterShuConfigService;

package/dist/services/impl/DbAdapterShuService.d.ts

@@ -0,0 +1,26 @@
+import type { DbAdapter } from 'ofcore';
+import type { CreateShuPeriodInput, CsvExportPayload, ShuAllocationContract, ShuAllocationQueryOptions, ShuPeriodContract, ShuPeriodQueryOptions, ShuServiceContract } from '../../contracts/ShuContract';
+import { type OfcoopRepositories } from '../../data/repositories';
+import { type ServiceRuntimeOptions } from './runtimeSupport';
+export declare class DbAdapterShuService implements ShuServiceContract {
+    private readonly db;
+    private readonly repos;
+    private readonly options;
+    private readonly newPeriodId;
+    private readonly newAllocationId;
+    constructor(db: DbAdapter, repos: OfcoopRepositories, options?: ServiceRuntimeOptions);
+    private inTx;
+    private toDateOnly;
+    private dateToUtcMs;
+    private diffDaysInclusive;
+    private getEligibleWindow;
+    private applySavingEntryToBalance;
+    private computeAverageModalBasis;
+    private allocateWithLargestRemainder;
+    createShuPeriod(input: CreateShuPeriodInput): Promise<ShuPeriodContract>;
+    finalizeShuPeriod(periodId: string): Promise<ShuPeriodContract>;
+    listShuPeriods(options?: ShuPeriodQueryOptions): Promise<ShuPeriodContract[]>;
+    generateShuAllocations(periodId: string): Promise<ShuAllocationContract[]>;
+    listShuAllocations(periodId: string, options?: ShuAllocationQueryOptions): Promise<ShuAllocationContract[]>;
+    exportShuAllocationsCsv(periodId: string): Promise<CsvExportPayload>;
+}

package/dist/services/impl/DbAdapterShuService.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbAdapterShuService = void 0;
+const repositories_1 = require("../../data/repositories");
+const errors_1 = require("../errors");
+const ShuService_1 = require("../ShuService");
+const errors_2 = require("../errors");
+const runtimeSupport_1 = require("./runtimeSupport");
+class DbAdapterShuService {
+    constructor(db, repos, options = {}) {
+        this.db = db;
+        this.repos = repos;
+        this.options = options;
+        this.newPeriodId = (0, runtimeSupport_1.makeIdFactory)('shu-period');
+        this.newAllocationId = (0, runtimeSupport_1.makeIdFactory)('shu-allocation');
+    }
+    async inTx(callback) {
+        return this.db.transaction(async (tx) => callback((0, repositories_1.createOfcoopRepositories)(tx)));
+    }
+    toDateOnly(input) {
+        return input.slice(0, 10);
+    }
+    dateToUtcMs(input) {
+        return Date.parse(`${this.toDateOnly(input)}T00:00:00.000Z`);
+    }
+    diffDaysInclusive(startDate, endDate) {
+        const ms = this.dateToUtcMs(endDate) - this.dateToUtcMs(startDate);
+        return Math.floor(ms / 86400000) + 1;
+    }
+    getEligibleWindow(member, periodStart, periodEnd) {
+        if (member.status !== 'active' && member.status !== 'exited')
+            return null;
+        const joinedAt = this.toDateOnly(member.joinDate);
+        const exitedAt = member.exitDate ? this.toDateOnly(member.exitDate) : null;
+        if (member.status === 'exited' && !exitedAt)
+            return null;
+        const start = joinedAt > periodStart ? joinedAt : periodStart;
+        const naturalEnd = exitedAt && exitedAt < periodEnd ? exitedAt : periodEnd;
+        if (start > naturalEnd)
+            return null;
+        const activeDays = this.diffDaysInclusive(start, naturalEnd);
+        const totalDays = this.diffDaysInclusive(periodStart, periodEnd);
+        return {
+            start,
+            end: naturalEnd,
+            activeDays,
+            proRataFactor: totalDays > 0 ? activeDays / totalDays : 0,
+        };
+    }
+    applySavingEntryToBalance(balances, entry, allowedSukarelaReferenceTypes) {
+        const sign = entry.entryType === 'debit' ? -1 : 1;
+        if (entry.savingType === 'pokok')
+            balances.pokok += sign * entry.amount;
+        if (entry.savingType === 'wajib')
+            balances.wajib += sign * entry.amount;
+        if (entry.savingType === 'sukarela') {
+            if (!allowedSukarelaReferenceTypes || allowedSukarelaReferenceTypes.size === 0)
+                return;
+            const ref = (entry.referenceType ?? '').trim();
+            if (!allowedSukarelaReferenceTypes.has(ref))
+                return;
+            balances.sukarela += sign * entry.amount;
+        }
+    }
+    async computeAverageModalBasis(args) {
+        const rows = await args.repos.savingLedgerRepository.listByMember(args.memberId, {
+            includeDeleted: false,
+            dateTo: args.periodEnd,
+            tenantId: args.tenantId ?? null,
+            branchId: args.branchId ?? null,
+        });
+        const asc = rows
+            .slice()
+            .sort((a, b) => this.toDateOnly(a.transactionDate).localeCompare(this.toDateOnly(b.transactionDate)));
+        const balances = { pokok: 0, wajib: 0, sukarela: 0 };
+        const activeStartMs = this.dateToUtcMs(args.activeStart);
+        const activeEndExclusiveMs = this.dateToUtcMs(args.activeEnd) + 86400000;
+        const totalPeriodDays = this.diffDaysInclusive(args.periodStart, args.periodEnd);
+        let weightedModal = 0;
+        let cursorMs = this.dateToUtcMs(args.periodStart);
+        let index = 0;
+        while (index < asc.length && this.dateToUtcMs(asc[index].transactionDate) < cursorMs) {
+            this.applySavingEntryToBalance(balances, asc[index], args.includeSukarela ? args.allowedSukarelaReferenceTypes : null);
+            index += 1;
+        }
+        while (cursorMs < activeEndExclusiveMs) {
+            const nextEventMs = index < asc.length ? this.dateToUtcMs(asc[index].transactionDate) : activeEndExclusiveMs;
+            const sliceEndMs = Math.min(nextEventMs, activeEndExclusiveMs);
+            if (sliceEndMs > cursorMs) {
+                const overlapStart = Math.max(cursorMs, activeStartMs);
+                const overlapEnd = Math.min(sliceEndMs, activeEndExclusiveMs);
+                if (overlapEnd > overlapStart) {
+                    const days = Math.floor((overlapEnd - overlapStart) / 86400000);
+                    const modalNow = balances.pokok + balances.wajib + (args.includeSukarela ? balances.sukarela : 0);
+                    weightedModal += modalNow * days;
+                }
+                cursorMs = sliceEndMs;
+            }
+            else {
+                cursorMs += 86400000;
+            }
+            while (index < asc.length && this.dateToUtcMs(asc[index].transactionDate) === sliceEndMs) {
+                this.applySavingEntryToBalance(balances, asc[index], args.includeSukarela ? args.allowedSukarelaReferenceTypes : null);
+                index += 1;
+            }
+        }
+        return totalPeriodDays > 0 ? weightedModal / totalPeriodDays : 0;
+    }
+    allocateWithLargestRemainder(args) {
+        const totalScore = args.members.reduce((sum, item) => sum + item.score, 0);
+        if (totalScore <= 0) {
+            throw (0, errors_2.invalidState)('SHU allocation requires non-zero total score; escalate to RAT decision');
+        }
+        const floorAllocations = new Map();
+        const remainders = args.members.map((item) => {
+            const raw = (args.poolAmount * item.score) / totalScore;
+            const floored = Math.floor(raw);
+            floorAllocations.set(item.memberId, floored);
+            return { memberId: item.memberId, remainder: raw - floored };
+        });
+        const allocated = Array.from(floorAllocations.values()).reduce((sum, value) => sum + value, 0);
+        let left = args.poolAmount - allocated;
+        remainders.sort((a, b) => {
+            if (b.remainder !== a.remainder)
+                return b.remainder - a.remainder;
+            return a.memberId.localeCompare(b.memberId);
+        });
+        let i = 0;
+        while (left > 0 && remainders.length > 0) {
+            const target = remainders[i % remainders.length];
+            floorAllocations.set(target.memberId, (floorAllocations.get(target.memberId) ?? 0) + 1);
+            left -= 1;
+            i += 1;
+        }
+        return floorAllocations;
+    }
+    async createShuPeriod(input) {
+        (0, ShuService_1.assertValidCreateShuPeriodInput)(input);
+        const created = await this.repos.shuPeriodRepository.create({
+            id: this.newPeriodId(),
+            periodCode: input.periodCode,
+            startDate: input.startDate,
+            endDate: input.endDate,
+            status: 'draft',
+            formulaSnapshot: (0, runtimeSupport_1.clone)(input.formulaSnapshot),
+            branchId: input.branchId ?? null,
+            tenantId: input.tenantId ?? null,
+            version: 1,
+            lastModified: (0, runtimeSupport_1.nowIso)(),
+            deleted: false,
+        });
+        this.options.logger?.logInfo('[ofcoop] shu period created', { periodId: created.id, periodCode: created.periodCode });
+        await (0, runtimeSupport_1.emitDomainEvent)(this.options, {
+            name: 'shu.period-created',
+            occurredAt: (0, runtimeSupport_1.nowIso)(),
+            entityId: created.id,
+            tenantId: created.tenantId ?? null,
+            branchId: created.branchId ?? null,
+            payload: { periodCode: created.periodCode },
+        });
+        return created;
+    }
+    async finalizeShuPeriod(periodId) {
+        const row = await this.repos.shuPeriodRepository.getById(periodId);
+        if (!row || row.deleted)
+            throw (0, errors_1.notFound)('SHU period', periodId);
+        const updated = await this.repos.shuPeriodRepository.update(periodId, {
+            status: 'finalized',
+            version: row.version + 1,
+            lastModified: (0, runtimeSupport_1.nowIso)(),
+        });
+        await (0, runtimeSupport_1.emitDomainEvent)(this.options, {
+            name: 'shu.period-finalized',
+            occurredAt: (0, runtimeSupport_1.nowIso)(),
+            entityId: updated.id,
+            tenantId: updated.tenantId ?? null,
+            branchId: updated.branchId ?? null,
+            payload: { status: updated.status },
+        });
+        return updated;
+    }
+    async listShuPeriods(options = {}) {
+        const rows = await this.repos.shuPeriodRepository.list({
+            includeDeleted: options.includeDeleted,
+            tenantId: options.tenantId,
+            branchId: options.branchId,
+        });
+        return rows.filter((row) => {
+            if (options.status && row.status !== options.status)
+                return false;
+            if (options.dateContains) {
+                const date = options.dateContains.slice(0, 10);
+                if (row.startDate > date)
+                    return false;
+                if (row.endDate < date)
+                    return false;
+            }
+            return true;
+        });
+    }
+    async generateShuAllocations(periodId) {
+        return this.inTx(async (repos) => {
+            const period = await repos.shuPeriodRepository.getById(periodId);
+            if (!period || period.deleted)
+                throw (0, errors_1.notFound)('SHU period', periodId);
+            const members = await repos.memberRepository.list({
+                includeDeleted: false,
+                tenantId: period.tenantId ?? undefined,
+                branchId: period.branchId ?? undefined,
+            });
+            if (members.length === 0)
+                return [];
+            const snapshot = period.formulaSnapshot;
+            const distributionMode = String(snapshot.distributionMode ?? 'equal-share');
+            const rows = [];
+            if (distributionMode === 'score-weighted-v1') {
+                const periodStart = this.toDateOnly(period.startDate);
+                const periodEnd = this.toDateOnly(period.endDate);
+                const totalShuRaw = Number(snapshot.shuTahunBukuIdr ?? snapshot.totalDistributableShuIdr ?? 0);
+                const cadanganPercentRaw = Number(snapshot.cadanganPercent ?? 0);
+                const poolAnggotaPercentRaw = Number(snapshot.poolAnggotaPercent ?? 0);
+                const bobotTransaksiPercentRaw = Number(snapshot.bobotTransaksiPercent ?? 0);
+                const bobotModalPercentRaw = Number(snapshot.bobotModalPercent ?? 0);
+                const includeSukarelaInModalBasis = Boolean(snapshot.includeSukarelaInModalBasis ?? false);
+                const sukarelaModalReferenceTypes = Array.isArray(snapshot.sukarelaModalReferenceTypes)
+                    ? snapshot.sukarelaModalReferenceTypes.map((item) => String(item).trim()).filter((item) => item.length > 0)
+                    : [];
+                const allowedSukarelaReferenceTypes = new Set(sukarelaModalReferenceTypes);
+                const transactionScoreByMemberId = snapshot.transactionScoreByMemberId && typeof snapshot.transactionScoreByMemberId === 'object'
+                    ? snapshot.transactionScoreByMemberId
+                    : {};
+                if (!Number.isFinite(totalShuRaw) || totalShuRaw <= 0) {
+                    throw (0, errors_2.invalidState)('shuTahunBukuIdr must be provided for score-weighted-v1 allocation');
+                }
+                if (!Number.isFinite(cadanganPercentRaw) || cadanganPercentRaw < 0 || cadanganPercentRaw > 100) {
+                    throw (0, errors_2.invalidState)('cadanganPercent must be in range 0-100 for score-weighted-v1 allocation');
+                }
+                if (!Number.isFinite(poolAnggotaPercentRaw) || poolAnggotaPercentRaw < 0 || poolAnggotaPercentRaw > 100) {
+                    throw (0, errors_2.invalidState)('poolAnggotaPercent must be in range 0-100 for score-weighted-v1 allocation');
+                }
+                if (!Number.isFinite(bobotTransaksiPercentRaw) ||
+                    !Number.isFinite(bobotModalPercentRaw) ||
+                    bobotTransaksiPercentRaw < 0 ||
+                    bobotModalPercentRaw < 0 ||
+                    bobotTransaksiPercentRaw + bobotModalPercentRaw !== 100) {
+                    throw (0, errors_2.invalidState)('bobotTransaksiPercent + bobotModalPercent must equal 100 for score-weighted-v1 allocation');
+                }
+                const shuSetelahCadangan = Math.max(0, Math.floor(totalShuRaw - (totalShuRaw * cadanganPercentRaw) / 100));
+                const poolShuAnggota = Math.max(0, Math.floor((shuSetelahCadangan * poolAnggotaPercentRaw) / 100));
+                if (poolShuAnggota <= 0)
+                    return [];
+                const eligibleMembers = [];
+                for (const member of members) {
+                    const window = this.getEligibleWindow(member, periodStart, periodEnd);
+                    if (!window)
+                        continue;
+                    const averageModalBasis = await this.computeAverageModalBasis({
+                        memberId: member.id,
+                        tenantId: period.tenantId ?? null,
+                        branchId: period.branchId ?? null,
+                        periodStart,
+                        periodEnd,
+                        activeStart: window.start,
+                        activeEnd: window.end,
+                        includeSukarela: includeSukarelaInModalBasis,
+                        allowedSukarelaReferenceTypes,
+                        repos,
+                    });
+                    const transaksiScoreRaw = Number(transactionScoreByMemberId[member.id] ?? 0);
+                    const transaksiScore = Number.isFinite(transaksiScoreRaw) && transaksiScoreRaw > 0 ? transaksiScoreRaw * window.proRataFactor : 0;
+                    const modalScore = averageModalBasis > 0 ? averageModalBasis : 0;
+                    const score = (bobotTransaksiPercentRaw / 100) * transaksiScore + (bobotModalPercentRaw / 100) * modalScore;
+                    eligibleMembers.push({
+                        member,
+                        proRataFactor: window.proRataFactor,
+                        modalScore,
+                        transaksiScore,
+                        score,
+                        activeDays: window.activeDays,
+                    });
+                }
+                const scored = eligibleMembers.filter((item) => item.score > 0);
+                const allocations = this.allocateWithLargestRemainder({
+                    poolAmount: poolShuAnggota,
+                    members: scored.map((item) => ({ memberId: item.member.id, score: item.score })),
+                });
+                for (const item of scored) {
+                    rows.push({
+                        id: this.newAllocationId(),
+                        shuPeriodId: periodId,
+                        memberId: item.member.id,
+                        allocationAmount: allocations.get(item.member.id) ?? 0,
+                        calculationBasis: {
+                            mode: 'score-weighted-v1',
+                            shuTahunBukuIdr: totalShuRaw,
+                            cadanganPercent: cadanganPercentRaw,
+                            shuSetelahCadangan,
+                            poolAnggotaPercent: poolAnggotaPercentRaw,
+                            poolShuAnggota,
+                            bobotTransaksiPercent: bobotTransaksiPercentRaw,
+                            bobotModalPercent: bobotModalPercentRaw,
+                            includeSukarelaInModalBasis,
+                            sukarelaModalReferenceTypes,
+                            proRataFactor: item.proRataFactor,
+                            activeDays: item.activeDays,
+                            transaksiScore: item.transaksiScore,
+                            modalScore: item.modalScore,
+                            score: item.score,
+                        },
+                        branchId: item.member.branchId ?? period.branchId ?? null,
+                        tenantId: item.member.tenantId ?? period.tenantId ?? null,
+                        version: 1,
+                        lastModified: (0, runtimeSupport_1.nowIso)(),
+                        deleted: false,
+                    });
+                }
+            }
+            else {
+                const activeMembers = members.filter((member) => member.status === 'active');
+                if (activeMembers.length === 0)
+                    return [];
+                const defaultTotal = Number(snapshot.totalDistributableShuIdr || 0);
+                const total = Number.isFinite(defaultTotal) && defaultTotal > 0 ? defaultTotal : activeMembers.length * 100000;
+                const perMember = Math.floor(total / activeMembers.length);
+                for (const member of activeMembers) {
+                    rows.push({
+                        id: this.newAllocationId(),
+                        shuPeriodId: periodId,
+                        memberId: member.id,
+                        allocationAmount: perMember,
+                        calculationBasis: {
+                            mode: 'equal-share',
+                            memberCount: activeMembers.length,
+                            sourceTotal: total,
+                        },
+                        branchId: member.branchId ?? period.branchId ?? null,
+                        tenantId: member.tenantId ?? period.tenantId ?? null,
+                        version: 1,
+                        lastModified: (0, runtimeSupport_1.nowIso)(),
+                        deleted: false,
+                    });
+                }
+            }
+            const allocations = await repos.shuAllocationRepository.createMany(rows);
+            this.options.logger?.logInfo('[ofcoop] shu allocations generated', {
+                periodId,
+                allocations: allocations.length,
+            });
+            await (0, runtimeSupport_1.emitDomainEvent)(this.options, {
+                name: 'shu.allocations-generated',
+                occurredAt: (0, runtimeSupport_1.nowIso)(),
+                entityId: periodId,
+                tenantId: period.tenantId ?? null,
+                branchId: period.branchId ?? null,
+                payload: { allocations: allocations.length },
+            });
+            return allocations;
+        });
+    }
+    async listShuAllocations(periodId, options) {
+        return this.repos.shuAllocationRepository.listByPeriod(periodId, options);
+    }
+    async exportShuAllocationsCsv(periodId) {
+        const rows = await this.listShuAllocations(periodId, { includeDeleted: false });
+        const body = [
+            'allocationId,shuPeriodId,memberId,allocationAmount',
+            ...rows.map((row) => `${row.id},${row.shuPeriodId},${row.memberId},${row.allocationAmount}`),
+        ].join('\n');
+        return {
+            filename: `shu-allocations-${periodId}.csv`,
+            contentType: 'text/csv',
+            body,
+        };
+    }
+}
+exports.DbAdapterShuService = DbAdapterShuService;

package/dist/services/impl/runtimeSupport.d.ts

@@ -0,0 +1,18 @@
+import type { LoggerAdapter } from 'ofcore';
+export interface ServiceRuntimeOptions {
+    logger?: LoggerAdapter;
+    emitEvent?: (event: OfcoopDomainEvent) => Promise<void> | void;
+}
+export type OfcoopDomainEventName = 'member.created' | 'member.updated' | 'saving.entry-recorded' | 'saving.policy-upserted' | 'shu.config-upserted' | 'shu.period-created' | 'shu.period-finalized' | 'shu.allocations-generated';
+export interface OfcoopDomainEvent {
+    name: OfcoopDomainEventName;
+    occurredAt: string;
+    entityId?: string;
+    tenantId?: string | null;
+    branchId?: string | null;
+    payload?: Record<string, unknown>;
+}
+export declare function nowIso(): string;
+export declare function makeIdFactory(prefix: string): () => string;
+export declare function clone<T>(value: T): T;
+export declare function emitDomainEvent(options: ServiceRuntimeOptions, event: OfcoopDomainEvent): Promise<void>;

package/dist/services/impl/runtimeSupport.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nowIso = nowIso;
+exports.makeIdFactory = makeIdFactory;
+exports.clone = clone;
+exports.emitDomainEvent = emitDomainEvent;
+function nowIso() {
+    return new Date().toISOString();
+}
+function makeIdFactory(prefix) {
+    let counter = 0;
+    return () => {
+        counter += 1;
+        return `${prefix}-${Date.now()}-${counter}`;
+    };
+}
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+async function emitDomainEvent(options, event) {
+    if (!options.emitEvent)
+        return;
+    try {
+        await options.emitEvent(event);
+    }
+    catch (error) {
+        options.logger?.logError(error, { message: '[ofcoop] domain event sink failed', eventName: event.name });
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "ofcoop-shared-core",
+  "version": "0.1.0-alpha.0",
+  "private": false,
+  "description": "Cooperative shared-core baseline (member/saving/shu/policy) with ofcore primitive bridge.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "NODE_PATH=.. npm run build && NODE_PATH=.. node --test ./tests/*.test.js",
+    "verify:contract": "node ./scripts/verify-surface.js",
+    "verify:surface": "node ./scripts/verify-surface.js",
+    "verify:ofcore-primitives": "node ./scripts/verify-ofcore-primitives.js",
+    "verify:governance": "node ./scripts/verify-governance-transport.js",
+    "verify:factory-boundary": "node ./scripts/verify-no-service-logic-in-factory.js",
+    "verify:runtime-bridge": "NODE_PATH=.. npm run build && NODE_PATH=.. node ./scripts/verify-runtime-bridge.js",
+    "verify:logic": "NODE_PATH=.. npm run build && NODE_PATH=.. node ./scripts/verify-residual-conformance.js",
+    "verify:residual-conformance": "NODE_PATH=.. npm run build && NODE_PATH=.. node ./scripts/verify-residual-conformance.js",
+    "ci:check": "npm run typecheck && npm run verify:contract && npm run verify:ofcore-primitives && npm run verify:governance && npm run verify:factory-boundary && npm run verify:runtime-bridge && npm run test && npm run verify:logic",
+    "prepublishOnly": "npm run ci:check",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "ofcore": "0.1.0-alpha.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "author": {
+    "name": "Agus Made",
+    "email": "krisnaparta@gmail.com"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}