sliccy 3.5.4 → 3.6.0

package/dist/node-server/_cloud_core/src/types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Registry entry for a cloud-hosted cone (sandbox). Renamed from
+ * CloudSessionEntry in node-server — the canonical name going forward is
+ * ConeEntry to align with the wider SLICC vocabulary (cone/scoops/licks).
+ */
+export interface ConeEntry {
+    /** Substrate identifier (e.g., 'e2b'). Typed as string for cloud-core portability. */
+    substrate: string;
+    /** Substrate-assigned ID (e.g., e2b sandbox ID). */
+    sandboxId: string;
+    /** User-supplied or auto-generated name. */
+    name?: string;
+    /** ISO 8601 timestamp of creation. */
+    createdAt: string;
+    /** Join URL for the tray session. */
+    joinUrl: string;
+    /** ISO 8601 timestamp; updated on every list/resume tick. */
+    lastSeen: string;
+    /**
+     * Sandbox state. 'reserved' is used for in-flight start/resume operations
+     * holding a cap slot before the substrate reports real state. Reconciled
+     * state from substrate will only ever be running/paused/dead.
+     */
+    state: 'running' | 'paused' | 'dead' | 'reserved';
+    /**
+     * Last-known tray identity from `/tmp/slicc-join.json`. Set by `runStart`
+     * after the initial cloud-status read; preserved by `runPause` (do NOT
+     * overwrite this on pause — it is the comparison baseline that lets
+     * `runResume` detect tray rebuilds). `runResume` overwrites it after a
+     * successful refresh.
+     */
+    trayId?: string;
+    /**
+     * `updatedAt` from the last successful `/tmp/slicc-join.json` read.
+     * `runResume` polls for an `updatedAt` strictly newer than this value, so
+     * resume only declares success after the kick produced a fresh refresh.
+     * Preserved across `runPause` for the same reason as `trayId`.
+     */
+    lastJoinUpdatedAt?: string;
+    /**
+     * ISO timestamp set when state transitions to 'reserved'. Used by listCones
+     * to GC stale reservations from crashed operations (TTL: 10 minutes).
+     */
+    reservedAt?: string;
+    /**
+     * Additional metadata (e.g., { userId, createdBy }). Used by workers for
+     * filtering and by CLI for tracking.
+     */
+    metadata?: Record<string, string>;
+}
+/**
+ * The shape persisted to `/tmp/slicc-join.json` inside the sandbox. Read by
+ * both start and resume operations to determine the join URL and tray state.
+ */
+export interface CloudStatus {
+    joinUrl: string;
+    trayId?: string;
+    sliccVersion?: string;
+    /** ISO 8601 timestamp written by /api/cloud-status; load-bearing for resume. */
+    updatedAt?: string;
+}
+/**
+ * Return value of the start operation — minimal shape with the sandbox ID,
+ * join URL, and optional name.
+ */
+export interface StartResult {
+    sandboxId: string;
+    joinUrl: string;
+    name?: string;
+}
+/**
+ * Return value of the resume operation — includes join URL, tray rebuild flag,
+ * and optional version mismatch warning.
+ */
+export interface ResumeResult {
+    sandboxId: string;
+    joinUrl: string;
+    trayRebuilt: boolean;
+    versionMismatch?: {
+        running: string;
+        local: string;
+    };
+}
+/**
+ * Summary of a sandbox returned by substrate.list(). Minimal shape with ID,
+ * name, state, and metadata.
+ */
+export interface SandboxSummary {
+    sandboxId: string;
+    name?: string;
+    state: 'running' | 'paused' | 'dead';
+    metadata: Record<string, string>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/node-server/_cloud_core/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,sFAAsF;IACtF,SAAS,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,KAAK,EAAE,SAAS,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IAClD;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CACtD;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC"}

package/dist/node-server/_cloud_core/src/types.js

@@ -0,0 +1,3 @@
+// Shared types for cloud-core operations. Consumed by both node-server (CLI)
+// and cloudflare-worker (Plan D).
+export {};

package/dist/node-server/_cloud_core/tests/fixtures/fake-substrate.d.ts

@@ -0,0 +1,39 @@
+import type { CreateOpts, SandboxHandle, SandboxSubstrate, SandboxSummary } from '../../src/index.js';
+export interface FakeSandboxHandleOpts {
+    sandboxId?: string;
+    /** /tmp/slicc-join.json contents to return from readFile. */
+    joinJson?: string;
+    /** stdout for handle.run() (the kick curl); default '200'. */
+    runStdout?: string;
+    /** exit code for handle.run(); default 0. */
+    runExitCode?: number;
+    /** stderr for handle.run(); default ''. */
+    runStderr?: string;
+    /** Optional: throw on kill (e.g., not-found discrimination tests). */
+    killError?: Error;
+    /** Captures all writeFile calls. */
+    writes?: Array<{
+        path: string;
+        contents: string | Uint8Array;
+    }>;
+}
+export declare function makeFakeHandle(opts?: FakeSandboxHandleOpts): SandboxHandle;
+export interface FakeSubstrateOpts {
+    /** Handle returned by connect(). Defaults to a vanilla fake handle. */
+    handle?: SandboxHandle;
+    /** If set, connect() throws this. Useful for not-found tests. */
+    connectError?: Error;
+    /** Override create(); default returns the same handle. */
+    onCreate?: (opts: CreateOpts) => Promise<SandboxHandle>;
+    /** Captures all create() calls. */
+    creates?: CreateOpts[];
+    /** List result to return; default []. */
+    listResult?: SandboxSummary[];
+    /** Captures all extendTimeout calls. */
+    timeoutCalls?: Array<{
+        sandboxId: string;
+        ttlMs: number;
+    }>;
+}
+export declare function makeFakeSubstrate(opts?: FakeSubstrateOpts): SandboxSubstrate;
+//# sourceMappingURL=fake-substrate.d.ts.map

package/dist/node-server/_cloud_core/tests/fixtures/fake-substrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-substrate.d.ts","sourceRoot":"","sources":["../../../tests/fixtures/fake-substrate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EAEV,aAAa,EAEb,gBAAgB,EAEhB,cAAc,EACf,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,qBAAqB;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sEAAsE;IACtE,SAAS,CAAC,EAAE,KAAK,CAAC;IAClB,oCAAoC;IACpC,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAA;KAAE,CAAC,CAAC;CACjE;AAED,wBAAgB,cAAc,CAAC,IAAI,GAAE,qBAA0B,GAAG,aAAa,CAqC9E;AAED,MAAM,WAAW,iBAAiB;IAChC,uEAAuE;IACvE,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,iEAAiE;IACjE,YAAY,CAAC,EAAE,KAAK,CAAC;IACrB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;IACxD,mCAAmC;IACnC,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IACvB,yCAAyC;IACzC,UAAU,CAAC,EAAE,cAAc,EAAE,CAAC;IAC9B,wCAAwC;IACxC,YAAY,CAAC,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC5D;AAED,wBAAgB,iBAAiB,CAAC,IAAI,GAAE,iBAAsB,GAAG,gBAAgB,CAiChF"}

package/dist/node-server/_cloud_core/tests/fixtures/fake-substrate.js

@@ -0,0 +1,75 @@
+export function makeFakeHandle(opts = {}) {
+    const writes = opts.writes ?? [];
+    return {
+        sandboxId: opts.sandboxId ?? 'sbx-fake',
+        substrate: 'e2b',
+        pause: async () => { },
+        kill: async () => {
+            if (opts.killError)
+                throw opts.killError;
+        },
+        getInfo: async () => ({
+            sandboxId: opts.sandboxId ?? 'sbx-fake',
+            state: 'running',
+            metadata: {},
+            createdAt: new Date().toISOString(),
+        }),
+        writeFile: async (path, contents) => {
+            writes.push({ path, contents });
+        },
+        readFile: async (path) => {
+            if (path === '/tmp/slicc-join.json') {
+                return (opts.joinJson ??
+                    JSON.stringify({
+                        joinUrl: 'https://w/join/fake',
+                        trayId: 't-fake',
+                        updatedAt: new Date().toISOString(),
+                    }));
+            }
+            throw new Error(`ENOENT ${path}`);
+        },
+        run: async (_cmd) => ({
+            stdout: opts.runStdout ?? '200',
+            stderr: opts.runStderr ?? '',
+            exitCode: opts.runExitCode ?? 0,
+        }),
+    };
+}
+export function makeFakeSubstrate(opts = {}) {
+    const handle = opts.handle ?? makeFakeHandle();
+    const creates = opts.creates ?? [];
+    const listResult = opts.listResult ?? [];
+    const timeoutCalls = opts.timeoutCalls ?? [];
+    return {
+        id: 'e2b',
+        async create(createOpts) {
+            creates.push(createOpts);
+            if (opts.onCreate)
+                return opts.onCreate(createOpts);
+            return handle;
+        },
+        async connect(_id) {
+            if (opts.connectError)
+                throw opts.connectError;
+            return handle;
+        },
+        async list(listOpts) {
+            // Optionally filter listResult by metadata if provided
+            if (!listOpts?.metadata)
+                return listResult;
+            const filterMetadata = listOpts.metadata;
+            return listResult.filter((s) => {
+                if (!s.metadata)
+                    return false;
+                for (const [k, v] of Object.entries(filterMetadata)) {
+                    if (s.metadata[k] !== v)
+                        return false;
+                }
+                return true;
+            });
+        },
+        async extendTimeout(sandboxId, ttlMs) {
+            timeoutCalls.push({ sandboxId, ttlMs });
+        },
+    };
+}

package/dist/node-server/_cloud_core/tests/fixtures/index.d.ts

@@ -0,0 +1,4 @@
+export { makeFakeHandle, makeFakeSubstrate } from './fake-substrate.js';
+export type { FakeSandboxHandleOpts, FakeSubstrateOpts } from './fake-substrate.js';
+export { MemRegistry } from './mem-registry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/node-server/_cloud_core/tests/fixtures/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../tests/fixtures/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxE,YAAY,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACpF,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/node-server/_cloud_core/tests/fixtures/index.js

@@ -0,0 +1,2 @@
+export { makeFakeHandle, makeFakeSubstrate } from './fake-substrate.js';
+export { MemRegistry } from './mem-registry.js';

package/dist/node-server/_cloud_core/tests/fixtures/mem-registry.d.ts

@@ -0,0 +1,10 @@
+import type { ConeEntry, Registry } from '../../src/index.js';
+export declare class MemRegistry implements Registry {
+    entries: ConeEntry[];
+    list(): Promise<ConeEntry[]>;
+    findByNameOrId(query: string): Promise<ConeEntry | null>;
+    append(entry: ConeEntry): Promise<void>;
+    update(sandboxId: string, patch: Partial<ConeEntry>): Promise<void>;
+    remove(sandboxId: string): Promise<void>;
+}
+//# sourceMappingURL=mem-registry.d.ts.map

package/dist/node-server/_cloud_core/tests/fixtures/mem-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mem-registry.d.ts","sourceRoot":"","sources":["../../../tests/fixtures/mem-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9D,qBAAa,WAAY,YAAW,QAAQ;IAC1C,OAAO,EAAE,SAAS,EAAE,CAAM;IAEpB,IAAI,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAI5B,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAIxD,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAMvC,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAMnE,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG/C"}

package/dist/node-server/_cloud_core/tests/fixtures/mem-registry.js

@@ -0,0 +1,25 @@
+export class MemRegistry {
+    entries = [];
+    async list() {
+        return [...this.entries];
+    }
+    async findByNameOrId(query) {
+        return this.entries.find((e) => e.sandboxId === query || e.name === query) ?? null;
+    }
+    async append(entry) {
+        const i = this.entries.findIndex((e) => e.sandboxId === entry.sandboxId);
+        if (i >= 0)
+            this.entries[i] = { ...this.entries[i], ...entry };
+        else
+            this.entries.push(entry);
+    }
+    async update(sandboxId, patch) {
+        const i = this.entries.findIndex((e) => e.sandboxId === sandboxId);
+        if (i < 0)
+            throw new Error(`entry not found: ${sandboxId}`);
+        this.entries[i] = { ...this.entries[i], ...patch };
+    }
+    async remove(sandboxId) {
+        this.entries = this.entries.filter((e) => e.sandboxId !== sandboxId);
+    }
+}

package/dist/node-server/_cloud_core/tests/kill.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=kill.test.d.ts.map

package/dist/node-server/_cloud_core/tests/kill.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kill.test.d.ts","sourceRoot":"","sources":["../../tests/kill.test.ts"],"names":[],"mappings":""}

package/dist/node-server/_cloud_core/tests/kill.test.js

@@ -0,0 +1,164 @@
+import { describe, it, expect } from 'vitest';
+import { killCone } from '../src/index.js';
+import { MemRegistry, makeFakeSubstrate } from './fixtures/index.js';
+// Specialized handle for kill tests: allows controlled throw on kill.
+function makeKillTestHandle(throwOnKill) {
+    return {
+        sandboxId: 'sbx-test-1',
+        substrate: 'e2b',
+        pause: async () => { },
+        kill: async () => {
+            if (throwOnKill)
+                throw throwOnKill;
+        },
+        getInfo: async () => ({
+            sandboxId: 'sbx-test-1',
+            state: 'running',
+            metadata: {},
+            createdAt: new Date().toISOString(),
+        }),
+        writeFile: async () => { },
+        readFile: async () => '',
+        run: async () => ({ stdout: '', stderr: '', exitCode: 0 }),
+    };
+}
+describe('killCone', () => {
+    it('kills sandbox and removes registry entry', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 'sbx-1',
+            substrate: 'e2b',
+            createdAt: new Date().toISOString(),
+            lastSeen: new Date().toISOString(),
+            joinUrl: 'https://tray.example.com/join/abc123',
+            state: 'running',
+        });
+        const substrate = makeFakeSubstrate({
+            handle: makeKillTestHandle(),
+        });
+        const result = await killCone({ substrate, registry }, 'sbx-1');
+        expect(result).toEqual({ sandboxId: 'sbx-1', alreadyDead: false });
+        expect(registry.entries).toEqual([]);
+    });
+    it('throws NOT_FOUND when query has no match', async () => {
+        const registry = new MemRegistry();
+        const substrate = makeFakeSubstrate({
+            handle: makeKillTestHandle(),
+        });
+        let caught = null;
+        try {
+            await killCone({ substrate, registry }, 'missing');
+        }
+        catch (err) {
+            caught = err;
+        }
+        expect(caught).toBeTruthy();
+        expect(caught?.code).toBe('NOT_FOUND');
+        expect(caught?.message).toContain('cloud session not found');
+    });
+    it('still removes registry entry if substrate.kill says sandbox is already gone', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 'sbx-1',
+            substrate: 'e2b',
+            createdAt: new Date().toISOString(),
+            lastSeen: new Date().toISOString(),
+            joinUrl: 'https://tray.example.com/join/paused123',
+            state: 'paused',
+        });
+        const notFoundErr = new Error('unknown sandbox id');
+        const substrate = makeFakeSubstrate({
+            handle: makeKillTestHandle(notFoundErr),
+        });
+        const result = await killCone({ substrate, registry }, 'sbx-1');
+        expect(result.alreadyDead).toBe(true);
+        expect(result.sandboxId).toBe('sbx-1');
+        expect(registry.entries).toEqual([]);
+    });
+    it('handles "not found" pattern variations', async () => {
+        const patterns = ['sandbox not found', 'unknown sandbox', '404 not found', 'does not exist'];
+        for (const pattern of patterns) {
+            const registry = new MemRegistry();
+            await registry.append({
+                sandboxId: 'sbx-test',
+                substrate: 'e2b',
+                createdAt: new Date().toISOString(),
+                lastSeen: new Date().toISOString(),
+                joinUrl: 'https://tray.example.com/join/test',
+                state: 'running',
+            });
+            const err = new Error(pattern);
+            const substrate = makeFakeSubstrate({
+                handle: makeKillTestHandle(err),
+            });
+            const result = await killCone({ substrate, registry }, 'sbx-test');
+            expect(result.alreadyDead).toBe(true);
+            expect(registry.entries).toEqual([]);
+        }
+    });
+    it('finds entry by name', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 'sbx-1',
+            name: 'my-prod-session',
+            substrate: 'e2b',
+            createdAt: new Date().toISOString(),
+            lastSeen: new Date().toISOString(),
+            joinUrl: 'https://tray.example.com/join/prod123',
+            state: 'running',
+        });
+        const substrate = makeFakeSubstrate({
+            handle: makeKillTestHandle(),
+        });
+        const result = await killCone({ substrate, registry }, 'my-prod-session');
+        expect(result.sandboxId).toBe('sbx-1');
+        expect(registry.entries).toEqual([]);
+    });
+    it('re-throws non-NotFound errors from kill', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 'sbx-1',
+            substrate: 'e2b',
+            createdAt: new Date().toISOString(),
+            lastSeen: new Date().toISOString(),
+            joinUrl: 'https://tray.example.com/join/net123',
+            state: 'running',
+        });
+        const networkErr = new Error('network timeout');
+        const substrate = makeFakeSubstrate({
+            handle: makeKillTestHandle(networkErr),
+        });
+        let caught = null;
+        try {
+            await killCone({ substrate, registry }, 'sbx-1');
+        }
+        catch (err) {
+            caught = err;
+        }
+        expect(caught).toBeTruthy();
+        expect(caught?.code).toBe('INTERNAL');
+        expect(caught?.message).toContain('network timeout');
+        // Registry entry should still exist since we didn't get past the throw.
+        expect(registry.entries.length).toBe(1);
+        expect(registry.entries[0]?.sandboxId).toBe('sbx-1');
+    });
+    it('handles case-insensitive "not found" patterns', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 'sbx-1',
+            substrate: 'e2b',
+            createdAt: new Date().toISOString(),
+            lastSeen: new Date().toISOString(),
+            joinUrl: 'https://tray.example.com/join/case123',
+            state: 'running',
+        });
+        // Test case insensitivity
+        const err = new Error('NOT FOUND IN THE SYSTEM');
+        const substrate = makeFakeSubstrate({
+            handle: makeKillTestHandle(err),
+        });
+        const result = await killCone({ substrate, registry }, 'sbx-1');
+        expect(result.alreadyDead).toBe(true);
+        expect(registry.entries).toEqual([]);
+    });
+});

package/dist/node-server/_cloud_core/tests/list.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=list.test.d.ts.map

package/dist/node-server/_cloud_core/tests/list.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.test.d.ts","sourceRoot":"","sources":["../../tests/list.test.ts"],"names":[],"mappings":""}