@dxos/pipeline 0.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +105 -0
- package/README.md +41 -0
- package/dist/lib/neutral/chunk-J5LGTIGS.mjs +10 -0
- package/dist/lib/neutral/chunk-J5LGTIGS.mjs.map +7 -0
- package/dist/lib/neutral/index.mjs +67 -0
- package/dist/lib/neutral/index.mjs.map +7 -0
- package/dist/lib/neutral/meta.json +1 -0
- package/dist/lib/neutral/testing/index.mjs +18 -0
- package/dist/lib/neutral/testing/index.mjs.map +7 -0
- package/dist/types/src/Pipeline.d.ts +31 -0
- package/dist/types/src/Pipeline.d.ts.map +1 -0
- package/dist/types/src/Pipeline.test.d.ts +2 -0
- package/dist/types/src/Pipeline.test.d.ts.map +1 -0
- package/dist/types/src/Stage.d.ts +64 -0
- package/dist/types/src/Stage.d.ts.map +1 -0
- package/dist/types/src/Stage.test.d.ts +2 -0
- package/dist/types/src/Stage.test.d.ts.map +1 -0
- package/dist/types/src/index.d.ts +3 -0
- package/dist/types/src/index.d.ts.map +1 -0
- package/dist/types/src/testing/capture.d.ts +8 -0
- package/dist/types/src/testing/capture.d.ts.map +1 -0
- package/dist/types/src/testing/capture.test.d.ts +2 -0
- package/dist/types/src/testing/capture.test.d.ts.map +1 -0
- package/dist/types/src/testing/index.d.ts +2 -0
- package/dist/types/src/testing/index.d.ts.map +1 -0
- package/dist/types/tsconfig.tsbuildinfo +1 -0
- package/package.json +45 -0
- package/src/Pipeline.test.ts +118 -0
- package/src/Pipeline.ts +54 -0
- package/src/Stage.test.ts +66 -0
- package/src/Stage.ts +128 -0
- package/src/index.ts +6 -0
- package/src/testing/capture.test.ts +18 -0
- package/src/testing/capture.ts +22 -0
- package/src/testing/index.ts +5 -0
package/LICENSE
ADDED
|
@@ -0,0 +1,105 @@
|
|
|
1
|
+
# Functional Source License, Version 1.1, ALv2 Future License
|
|
2
|
+
|
|
3
|
+
## Abbreviation
|
|
4
|
+
|
|
5
|
+
FSL-1.1-Apache-2.0
|
|
6
|
+
|
|
7
|
+
## Notice
|
|
8
|
+
|
|
9
|
+
Copyright 2026 DXOS
|
|
10
|
+
|
|
11
|
+
## Terms and Conditions
|
|
12
|
+
|
|
13
|
+
### Licensor ("We")
|
|
14
|
+
|
|
15
|
+
The party offering the Software under these Terms and Conditions.
|
|
16
|
+
|
|
17
|
+
### The Software
|
|
18
|
+
|
|
19
|
+
The "Software" is each version of the software that we make available under
|
|
20
|
+
these Terms and Conditions, as indicated by our inclusion of these Terms and
|
|
21
|
+
Conditions with the Software.
|
|
22
|
+
|
|
23
|
+
### License Grant
|
|
24
|
+
|
|
25
|
+
Subject to your compliance with this License Grant and the Patents,
|
|
26
|
+
Redistribution and Trademark clauses below, we hereby grant you the right to
|
|
27
|
+
use, copy, modify, create derivative works, publicly perform, publicly display
|
|
28
|
+
and redistribute the Software for any Permitted Purpose identified below.
|
|
29
|
+
|
|
30
|
+
### Permitted Purpose
|
|
31
|
+
|
|
32
|
+
A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
|
|
33
|
+
means making the Software available to others in a commercial product or
|
|
34
|
+
service that:
|
|
35
|
+
|
|
36
|
+
1. substitutes for the Software;
|
|
37
|
+
|
|
38
|
+
2. substitutes for any other product or service we offer using the Software
|
|
39
|
+
that exists as of the date we make the Software available; or
|
|
40
|
+
|
|
41
|
+
3. offers the same or substantially similar functionality as the Software.
|
|
42
|
+
|
|
43
|
+
Permitted Purposes specifically include using the Software:
|
|
44
|
+
|
|
45
|
+
1. for your internal use and access;
|
|
46
|
+
|
|
47
|
+
2. for non-commercial education;
|
|
48
|
+
|
|
49
|
+
3. for non-commercial research; and
|
|
50
|
+
|
|
51
|
+
4. in connection with professional services that you provide to a licensee
|
|
52
|
+
using the Software in accordance with these Terms and Conditions.
|
|
53
|
+
|
|
54
|
+
### Patents
|
|
55
|
+
|
|
56
|
+
To the extent your use for a Permitted Purpose would necessarily infringe our
|
|
57
|
+
patents, the license grant above includes a license under our patents. If you
|
|
58
|
+
make a claim against any party that the Software infringes or contributes to
|
|
59
|
+
the infringement of any patent, then your patent license to the Software ends
|
|
60
|
+
immediately.
|
|
61
|
+
|
|
62
|
+
### Redistribution
|
|
63
|
+
|
|
64
|
+
The Terms and Conditions apply to all copies, modifications and derivatives of
|
|
65
|
+
the Software.
|
|
66
|
+
|
|
67
|
+
If you redistribute any copies, modifications or derivatives of the Software,
|
|
68
|
+
you must include a copy of or a link to these Terms and Conditions and not
|
|
69
|
+
remove any copyright notices provided in or with the Software.
|
|
70
|
+
|
|
71
|
+
### Disclaimer
|
|
72
|
+
|
|
73
|
+
THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
|
|
74
|
+
IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
|
|
75
|
+
PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
|
|
76
|
+
|
|
77
|
+
IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
|
|
78
|
+
SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
|
|
79
|
+
EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
|
|
80
|
+
|
|
81
|
+
### Trademarks
|
|
82
|
+
|
|
83
|
+
Except for displaying the License Details and identifying us as the origin of
|
|
84
|
+
the Software, you have no right under these Terms and Conditions to use our
|
|
85
|
+
trademarks, trade names, service marks or product names.
|
|
86
|
+
|
|
87
|
+
## Grant of Future License
|
|
88
|
+
|
|
89
|
+
We hereby irrevocably grant you an additional license to use the Software under
|
|
90
|
+
the Apache License, Version 2.0 that is effective on the second anniversary of
|
|
91
|
+
the date we make the Software available. On or after that date, you may use the
|
|
92
|
+
Software under the Apache License, Version 2.0, in which case the following
|
|
93
|
+
will apply:
|
|
94
|
+
|
|
95
|
+
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
96
|
+
this file except in compliance with the License.
|
|
97
|
+
|
|
98
|
+
You may obtain a copy of the License at
|
|
99
|
+
|
|
100
|
+
http://www.apache.org/licenses/LICENSE-2.0
|
|
101
|
+
|
|
102
|
+
Unless required by applicable law or agreed to in writing, software distributed
|
|
103
|
+
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
|
104
|
+
CONDITIONS OF ANY KIND, either express or implied. See the License for the
|
|
105
|
+
specific language governing permissions and limitations under the License.
|
package/README.md
ADDED
|
@@ -0,0 +1,41 @@
|
|
|
1
|
+
# @dxos/pipeline
|
|
2
|
+
|
|
3
|
+
Generic, back-pressured streaming pipeline. A pipeline runs an Effect `Stream` source through an
|
|
4
|
+
ordered chain of stages — each a pipeable `Stream → Stream` transform, composed with `pipe` — and
|
|
5
|
+
drains the result to a sink. Back pressure is the default (pull-based `Stream`) and configurable
|
|
6
|
+
per pipeline or per stage (`suspend` / `sliding` / `dropping`). Shared dependencies flow through
|
|
7
|
+
Effect's Requirements channel (`Context.Tag` / `Layer`), provided once at the edge.
|
|
8
|
+
|
|
9
|
+
## Usage
|
|
10
|
+
|
|
11
|
+
```ts
|
|
12
|
+
import * as Effect from 'effect/Effect';
|
|
13
|
+
import * as Stream from 'effect/Stream';
|
|
14
|
+
|
|
15
|
+
import { EffectEx } from '@dxos/effect';
|
|
16
|
+
import { Pipeline, Stage } from '@dxos/pipeline';
|
|
17
|
+
|
|
18
|
+
await EffectEx.runPromise(
|
|
19
|
+
Stream.fromIterable([1, 2, 3]).pipe(
|
|
20
|
+
Stage.map('double', (n: number) => Effect.succeed(n * 2)),
|
|
21
|
+
Pipeline.run({ sink: (out) => Effect.sync(() => console.log(out)) }),
|
|
22
|
+
),
|
|
23
|
+
);
|
|
24
|
+
```
|
|
25
|
+
|
|
26
|
+
Shared dependencies flow through Effect's Requirements channel rather than an explicit `context`
|
|
27
|
+
parameter — a stage reads them with `yield*` inside its `Effect.gen`, and the caller provides them
|
|
28
|
+
once at the edge:
|
|
29
|
+
|
|
30
|
+
```ts
|
|
31
|
+
class Factor extends Context.Tag('Factor')<Factor, { readonly factor: number }>() {}
|
|
32
|
+
|
|
33
|
+
const program = source.pipe(
|
|
34
|
+
Stage.map('scale', (n: number) => Factor.pipe(Effect.map(({ factor }) => n * factor))),
|
|
35
|
+
Pipeline.run({ sink }),
|
|
36
|
+
);
|
|
37
|
+
|
|
38
|
+
await EffectEx.runPromise(Effect.provide(program, Layer.succeed(Factor, { factor: 5 })));
|
|
39
|
+
```
|
|
40
|
+
|
|
41
|
+
See [`@dxos/pipeline-email`](../pipeline-email) for a worked pipeline over the Enron email dataset.
|
|
@@ -0,0 +1,67 @@
|
|
|
1
|
+
import {
|
|
2
|
+
__export
|
|
3
|
+
} from "./chunk-J5LGTIGS.mjs";
|
|
4
|
+
|
|
5
|
+
// src/Pipeline.ts
|
|
6
|
+
var Pipeline_exports = {};
|
|
7
|
+
__export(Pipeline_exports, {
|
|
8
|
+
run: () => run
|
|
9
|
+
});
|
|
10
|
+
import * as Function from "effect/Function";
|
|
11
|
+
import * as Stream2 from "effect/Stream";
|
|
12
|
+
|
|
13
|
+
// src/Stage.ts
|
|
14
|
+
var Stage_exports = {};
|
|
15
|
+
__export(Stage_exports, {
|
|
16
|
+
DEFAULT_BUFFER_SIZE: () => DEFAULT_BUFFER_SIZE,
|
|
17
|
+
filter: () => filter2,
|
|
18
|
+
map: () => map,
|
|
19
|
+
window: () => window
|
|
20
|
+
});
|
|
21
|
+
import * as Effect from "effect/Effect";
|
|
22
|
+
import * as Stream from "effect/Stream";
|
|
23
|
+
var DEFAULT_BUFFER_SIZE = 16;
|
|
24
|
+
var withBuffer = (options) => (stream) => options.overflow ? Stream.buffer(stream, {
|
|
25
|
+
capacity: options.bufferSize ?? DEFAULT_BUFFER_SIZE,
|
|
26
|
+
strategy: options.overflow
|
|
27
|
+
}) : stream;
|
|
28
|
+
var map = (id, fn, options = {}) => (self) => self.pipe(
|
|
29
|
+
withBuffer(options),
|
|
30
|
+
// The overflow buffer sits *before* `mapEffect`: while a run is in flight it absorbs new
|
|
31
|
+
// input, so `sliding` coalesces to the latest queued item (latest-wins) and `dropping` sheds
|
|
32
|
+
// new arrivals. A buffer after `mapEffect` would bound outputs, not in-flight input, leaving
|
|
33
|
+
// overflow inert.
|
|
34
|
+
Stream.mapEffect((item) => fn(item).pipe(Effect.withSpan(id)), {
|
|
35
|
+
concurrency: options.concurrency ?? 1
|
|
36
|
+
}),
|
|
37
|
+
Stream.filter((item) => item !== void 0)
|
|
38
|
+
);
|
|
39
|
+
var window = (id, size, fn, options = {}) => {
|
|
40
|
+
if (!Number.isInteger(size) || size < 1) {
|
|
41
|
+
throw new RangeError(`Stage.window size must be a positive integer: ${size}`);
|
|
42
|
+
}
|
|
43
|
+
return (self) => self.pipe(Stream.mapAccum([], (buffer3, item) => {
|
|
44
|
+
const next = [
|
|
45
|
+
...buffer3,
|
|
46
|
+
item
|
|
47
|
+
].slice(-size);
|
|
48
|
+
return [
|
|
49
|
+
next,
|
|
50
|
+
next
|
|
51
|
+
];
|
|
52
|
+
}), Stream.mapEffect((buffer3) => fn(buffer3).pipe(Effect.withSpan(id)), {
|
|
53
|
+
concurrency: 1
|
|
54
|
+
}), withBuffer(options), Stream.filter((item) => item !== void 0));
|
|
55
|
+
};
|
|
56
|
+
var filter2 = (id, pred) => (self) => self.pipe(Stream.filter(pred));
|
|
57
|
+
|
|
58
|
+
// src/Pipeline.ts
|
|
59
|
+
var run = Function.dual(2, (source, options) => source.pipe(Stream2.buffer({
|
|
60
|
+
capacity: options.bufferSize ?? DEFAULT_BUFFER_SIZE,
|
|
61
|
+
strategy: options.overflow ?? "suspend"
|
|
62
|
+
}), Stream2.runForEach(options.sink)));
|
|
63
|
+
export {
|
|
64
|
+
Pipeline_exports as Pipeline,
|
|
65
|
+
Stage_exports as Stage
|
|
66
|
+
};
|
|
67
|
+
//# sourceMappingURL=index.mjs.map
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
{
|
|
2
|
+
"version": 3,
|
|
3
|
+
"sources": ["../../../src/Pipeline.ts", "../../../src/Stage.ts"],
|
|
4
|
+
"sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Effect from 'effect/Effect';\nimport * as Function from 'effect/Function';\nimport * as Stream from 'effect/Stream';\n\nimport * as Stage from './Stage';\n\n/**\n * Terminal commit for a pipeline: applies a stage's output value. Keeps stages pure — they emit\n * typed `Out` descriptions and the sink performs the side effect (in-memory capture in tests, a\n * database write in production).\n */\nexport type Sink<Out, E = never, R = never> = (out: Out) => Effect.Effect<void, E, R>;\n\nexport type RunOptions<Out, E = never, R = never> = {\n /** Terminal commit for the final stage output. */\n readonly sink: Sink<Out, E, R>;\n /** Pipeline-level overflow policy. Defaults to `suspend` (back pressure, never drop). */\n readonly overflow?: Stage.Overflow;\n /** Pipeline-level bounded-buffer capacity. */\n readonly bufferSize?: number;\n};\n\n/**\n * Drain a composed stream to a sink: apply the pipeline-level overflow buffer and run to\n * completion. Cancellation is structural — interrupting the returned effect interrupts the stream\n * and all in-flight stage work; there are no daemon fibers to leak. Compose with `pipe`, chaining\n * `Stage` transforms ahead of it: `pipe(source, Stage.map(...), Stage.window(...), Pipeline.run({\n * sink }))`. Mirrors `Stream.runForEach`'s own shape: the sink's `E`/`R` (bound once, from `options`)\n * are kept independent of — and unioned with — the piped-in stream's own `E`/`R`, so the incoming\n * stream's generics aren't forced to unify with the sink's at the call site.\n */\nexport const run: {\n <Out, E2, R2>(\n options: RunOptions<Out, E2, R2>,\n ): <E, R>(source: Stream.Stream<Out, E, R>) => Effect.Effect<void, E2 | E, R2 | R>;\n <Out, E, R, E2, R2>(\n source: Stream.Stream<Out, E, R>,\n options: RunOptions<Out, E2, R2>,\n ): Effect.Effect<void, E2 | E, R2 | R>;\n} = Function.dual(2, (source: Stream.Stream<any, any, any>, options: RunOptions<any, any, any>) =>\n source.pipe(\n Stream.buffer({\n capacity: options.bufferSize ?? Stage.DEFAULT_BUFFER_SIZE,\n strategy: options.overflow ?? 'suspend',\n }),\n Stream.runForEach(options.sink),\n ),\n);\n", "//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Effect from 'effect/Effect';\nimport * as Stream from 'effect/Stream';\n\n/**\n * Overflow policy applied when a consumer cannot keep pace, mapped onto `Stream.buffer` strategies.\n * - `suspend`: back pressure — never drop (default; correct for email/document processing).\n * - `sliding`: drop the oldest buffered item, keep the latest (correct for live transcription).\n * - `dropping`: drop the newest item when the buffer is full.\n */\nexport type Overflow = 'suspend' | 'sliding' | 'dropping';\n\n/** Default bounded-buffer capacity for both pipeline-level and per-stage buffering. */\nexport const DEFAULT_BUFFER_SIZE = 16;\n\n/**\n * A pipeline stage: a pipeable `Stream → Stream` transform, the same shape `Stream.mapEffect` /\n * `Stream.filter` already have — generic over the *input* stream's own error/requirements (`E0`/\n * `R0`) and unioning in the stage's own `E`/`R`, so stages compose in a `pipe` chain the same way\n * Effect's own Stream operators do. Authors build stages with {@link map} / {@link window} /\n * {@link filter}; shared dependencies flow through `R`, provided once at the edge via\n * `Effect.provide`.\n */\nexport type Stage<In, Out, E = never, R = never> = <E0 = never, R0 = never>(\n self: Stream.Stream<In, E0, R0>,\n) => Stream.Stream<Out, E0 | E, R0 | R>;\n\n/** Options shared by buffering stage constructors. */\ntype BufferOptions = {\n /**\n * Per-stage overflow override; when set, a bounded buffer is inserted at the stage's async\n * boundary. For {@link map} the buffer sits *before* `mapEffect`, so under load it sheds/coalesces\n * in-flight input (`sliding` keeps the latest queued item — true latest-wins — `dropping` drops\n * new arrivals while a run is in flight). For {@link window} it sits after windowing (a window\n * must see every item), bounding output rate.\n */\n readonly overflow?: Overflow;\n /** Buffer capacity for the per-stage override. */\n readonly bufferSize?: number;\n};\n\nexport type MapOptions = BufferOptions & {\n /** In-flight parallelism. Defaults to 1 (ordered + back-pressured); higher values may reorder. */\n readonly concurrency?: number;\n};\n\nexport type WindowOptions = BufferOptions;\n\n// A per-stage buffer is inserted only when an overflow override is requested; otherwise the stage\n// stays a pure transform and relies on the pipeline-level buffer.\nconst withBuffer =\n (options: BufferOptions) =>\n <A, E, R>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>\n options.overflow\n ? Stream.buffer(stream, { capacity: options.bufferSize ?? DEFAULT_BUFFER_SIZE, strategy: options.overflow })\n : stream;\n\n/**\n * 1:1 async transform. `fn` may return `undefined` to no-op for an item; the value is dropped\n * before it reaches the next stage, so the returned stage's `Out` excludes `undefined`.\n * `concurrency` defaults to 1 (ordered). `id` labels the per-item span for tracing.\n *\n * `Out`/`E`/`R` always infer from `fn`'s result; `In` only infers when the stage is composed inline\n * in a `pipe` (pinned by the upstream stream). Built as a standalone value, pin `In` by annotating\n * the callback parameter (`(item: T) => …`) or the binding (`const s: Stage<…> = …`). The four type\n * parameters are intentionally all-or-nothing: passing a partial list (e.g. `map<In, Out>(…)`) is a\n * compile error rather than silently forcing `E`/`R` to `never` and rejecting a service-using `fn`.\n */\nexport const map =\n <In, Out, E, R>(\n id: string,\n fn: (item: In) => Effect.Effect<Out, E, R>,\n options: MapOptions = {},\n ): Stage<In, Exclude<Out, undefined>, E, R> =>\n <E0, R0>(self: Stream.Stream<In, E0, R0>) =>\n self.pipe(\n withBuffer(options),\n // The overflow buffer sits *before* `mapEffect`: while a run is in flight it absorbs new\n // input, so `sliding` coalesces to the latest queued item (latest-wins) and `dropping` sheds\n // new arrivals. A buffer after `mapEffect` would bound outputs, not in-flight input, leaving\n // overflow inert.\n Stream.mapEffect((item) => fn(item).pipe(Effect.withSpan(id)), { concurrency: options.concurrency ?? 1 }),\n Stream.filter((item): item is Exclude<Out, undefined> => item !== undefined),\n );\n\n/**\n * Sliding-window transform: invokes `fn` once per incoming item with a fixed-size rolling view of\n * the last `size` items. The window is bounded by `size`, so memory does not grow with stream\n * length; it composes with (and is distinct from) the overflow buffer, which bounds rate mismatch.\n * `fn` may return `undefined` to no-op, narrowing `Out` the same way {@link map} does. Type\n * parameters follow {@link map}: `Out`/`E`/`R` infer from `fn`, `In` is pinned inline by the\n * upstream or (standalone) by annotating the callback parameter or the binding, and a partial type\n * argument list is a compile error.\n */\nexport const window = <In, Out, E, R>(\n id: string,\n size: number,\n fn: (window: readonly In[]) => Effect.Effect<Out, E, R>,\n options: WindowOptions = {},\n): Stage<In, Exclude<Out, undefined>, E, R> => {\n // A window must retain at least one item; a non-positive size makes `.slice(-size)` degenerate\n // (`slice(-0)` returns the whole array, growing unbounded).\n if (!Number.isInteger(size) || size < 1) {\n throw new RangeError(`Stage.window size must be a positive integer: ${size}`);\n }\n\n return <E0, R0>(self: Stream.Stream<In, E0, R0>) =>\n self.pipe(\n Stream.mapAccum([] as readonly In[], (buffer, item) => {\n const next = [...buffer, item].slice(-size);\n return [next, next];\n }),\n Stream.mapEffect((buffer) => fn(buffer).pipe(Effect.withSpan(id)), { concurrency: 1 }),\n withBuffer(options),\n Stream.filter((item): item is Exclude<Out, undefined> => item !== undefined),\n );\n};\n\n/** Drop items that do not match `pred`. */\nexport const filter =\n <In>(id: string, pred: (item: In) => boolean): Stage<In, In> =>\n <E0, R0>(self: Stream.Stream<In, E0, R0>) =>\n self.pipe(Stream.filter(pred));\n"],
|
|
5
|
+
"mappings": ";;;;;AAAA;;;;AAOA,YAAYA,cAAc;AAC1B,YAAYC,aAAY;;;ACRxB;;;gBAAAC;EAAA;;;AAMA,YAAYC,YAAY;AACxB,YAAYC,YAAY;AAWjB,IAAMC,sBAAsB;AAqCnC,IAAMC,aACJ,CAACC,YACD,CAAUC,WACRD,QAAQE,WACGC,cAAOF,QAAQ;EAAEG,UAAUJ,QAAQK,cAAcP;EAAqBQ,UAAUN,QAAQE;AAAS,CAAA,IACxGD;AAaD,IAAMM,MACX,CACEC,IACAC,IACAT,UAAsB,CAAC,MAEzB,CAASU,SACPA,KAAKC;EACHZ,WAAWC,OAAAA;;;;;EAKJY,iBAAU,CAACC,SAASJ,GAAGI,IAAAA,EAAMF,KAAYG,gBAASN,EAAAA,CAAAA,GAAM;IAAEO,aAAaf,QAAQe,eAAe;EAAE,CAAA;EAChGpB,cAAO,CAACkB,SAA0CA,SAASG,MAAAA;AAAAA;AAYjE,IAAMC,SAAS,CACpBT,IACAU,MACAT,IACAT,UAAyB,CAAC,MAAC;AAI3B,MAAI,CAACmB,OAAOC,UAAUF,IAAAA,KAASA,OAAO,GAAG;AACvC,UAAM,IAAIG,WAAW,iDAAiDH,IAAAA,EAAM;EAC9E;AAEA,SAAO,CAASR,SACdA,KAAKC,KACIW,gBAAS,CAAA,GAAqB,CAACnB,SAAQU,SAAAA;AAC5C,UAAMU,OAAO;SAAIpB;MAAQU;MAAMW,MAAM,CAACN,IAAAA;AACtC,WAAO;MAACK;MAAMA;;EAChB,CAAA,GACOX,iBAAU,CAACT,YAAWM,GAAGN,OAAAA,EAAQQ,KAAYG,gBAASN,EAAAA,CAAAA,GAAM;IAAEO,aAAa;EAAE,CAAA,GACpFhB,WAAWC,OAAAA,GACJL,cAAO,CAACkB,SAA0CA,SAASG,MAAAA,CAAAA;AAExE;AAGO,IAAMrB,UACX,CAAKa,IAAYiB,SACjB,CAASf,SACPA,KAAKC,KAAYhB,cAAO8B,IAAAA,CAAAA;;;AD1FrB,IAAMC,MAQAC,cAAK,GAAG,CAACC,QAAsCC,YAC1DD,OAAOE,KACEC,eAAO;EACZC,UAAUH,QAAQI,cAAoBC;EACtCC,UAAUN,QAAQO,YAAY;AAChC,CAAA,GACOC,mBAAWR,QAAQS,IAAI,CAAA,CAAA;",
|
|
6
|
+
"names": ["Function", "Stream", "filter", "Effect", "Stream", "DEFAULT_BUFFER_SIZE", "withBuffer", "options", "stream", "overflow", "buffer", "capacity", "bufferSize", "strategy", "map", "id", "fn", "self", "pipe", "mapEffect", "item", "withSpan", "concurrency", "undefined", "window", "size", "Number", "isInteger", "RangeError", "mapAccum", "next", "slice", "pred", "run", "dual", "source", "options", "pipe", "buffer", "capacity", "bufferSize", "DEFAULT_BUFFER_SIZE", "strategy", "overflow", "runForEach", "sink"]
|
|
7
|
+
}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"inputs":{"src/Stage.ts":{"bytes":14069,"imports":[{"path":"effect/Effect","kind":"import-statement","external":true},{"path":"effect/Stream","kind":"import-statement","external":true}],"format":"esm"},"src/Pipeline.ts":{"bytes":4930,"imports":[{"path":"effect/Function","kind":"import-statement","external":true},{"path":"effect/Stream","kind":"import-statement","external":true},{"path":"src/Stage.ts","kind":"import-statement","original":"./Stage"}],"format":"esm"},"src/index.ts":{"bytes":574,"imports":[{"path":"src/Pipeline.ts","kind":"import-statement","original":"./Pipeline"},{"path":"src/Stage.ts","kind":"import-statement","original":"./Stage"}],"format":"esm"},"src/testing/capture.ts":{"bytes":1482,"imports":[{"path":"effect/Effect","kind":"import-statement","external":true}],"format":"esm"},"src/testing/index.ts":{"bytes":375,"imports":[{"path":"src/testing/capture.ts","kind":"import-statement","original":"./capture"}],"format":"esm"}},"outputs":{"dist/lib/neutral/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":10277},"dist/lib/neutral/index.mjs":{"imports":[{"path":"dist/lib/neutral/chunk-J5LGTIGS.mjs","kind":"import-statement"},{"path":"effect/Function","kind":"import-statement","external":true},{"path":"effect/Stream","kind":"import-statement","external":true},{"path":"effect/Effect","kind":"import-statement","external":true},{"path":"effect/Stream","kind":"import-statement","external":true}],"exports":["Pipeline","Stage"],"entryPoint":"src/index.ts","inputs":{"src/Pipeline.ts":{"bytesInOutput":378},"src/Stage.ts":{"bytesInOutput":1609},"src/index.ts":{"bytesInOutput":0}},"bytes":2199},"dist/lib/neutral/testing/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":885},"dist/lib/neutral/testing/index.mjs":{"imports":[{"path":"dist/lib/neutral/chunk-J5LGTIGS.mjs","kind":"import-statement"},{"path":"effect/Effect","kind":"import-statement","external":true}],"exports":["captureSink"],"entryPoint":"src/testing/index.ts","inputs":{"src/testing/capture.ts":{"bytesInOutput":197},"src/testing/index.ts":{"bytesInOutput":0}},"bytes":317},"dist/lib/neutral/chunk-J5LGTIGS.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":93},"dist/lib/neutral/chunk-J5LGTIGS.mjs":{"imports":[],"exports":["__export"],"inputs":{},"bytes":235}}}
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
import "../chunk-J5LGTIGS.mjs";
|
|
2
|
+
|
|
3
|
+
// src/testing/capture.ts
|
|
4
|
+
import * as Effect from "effect/Effect";
|
|
5
|
+
var captureSink = () => {
|
|
6
|
+
const items = [];
|
|
7
|
+
const sink = (out) => Effect.sync(() => {
|
|
8
|
+
items.push(out);
|
|
9
|
+
});
|
|
10
|
+
return {
|
|
11
|
+
sink,
|
|
12
|
+
items
|
|
13
|
+
};
|
|
14
|
+
};
|
|
15
|
+
export {
|
|
16
|
+
captureSink
|
|
17
|
+
};
|
|
18
|
+
//# sourceMappingURL=index.mjs.map
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
{
|
|
2
|
+
"version": 3,
|
|
3
|
+
"sources": ["../../../../src/testing/capture.ts"],
|
|
4
|
+
"sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport * as Pipeline from '../Pipeline';\n\n/** In-memory sink capturing every emitted value for assertions. */\nexport type CaptureSink<Out> = {\n readonly sink: Pipeline.Sink<Out>;\n readonly items: Out[];\n};\n\nexport const captureSink = <Out>(): CaptureSink<Out> => {\n const items: Out[] = [];\n const sink: Pipeline.Sink<Out> = (out) =>\n Effect.sync(() => {\n items.push(out);\n });\n return { sink, items };\n};\n"],
|
|
5
|
+
"mappings": ";;;AAIA,YAAYA,YAAY;AAUjB,IAAMC,cAAc,MAAA;AACzB,QAAMC,QAAe,CAAA;AACrB,QAAMC,OAA2B,CAACC,QACzBC,YAAK,MAAA;AACVH,UAAMI,KAAKF,GAAAA;EACb,CAAA;AACF,SAAO;IAAED;IAAMD;EAAM;AACvB;",
|
|
6
|
+
"names": ["Effect", "captureSink", "items", "sink", "out", "sync", "push"]
|
|
7
|
+
}
|
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
import * as Effect from 'effect/Effect';
|
|
2
|
+
import * as Stream from 'effect/Stream';
|
|
3
|
+
import * as Stage from './Stage';
|
|
4
|
+
/**
|
|
5
|
+
* Terminal commit for a pipeline: applies a stage's output value. Keeps stages pure — they emit
|
|
6
|
+
* typed `Out` descriptions and the sink performs the side effect (in-memory capture in tests, a
|
|
7
|
+
* database write in production).
|
|
8
|
+
*/
|
|
9
|
+
export type Sink<Out, E = never, R = never> = (out: Out) => Effect.Effect<void, E, R>;
|
|
10
|
+
export type RunOptions<Out, E = never, R = never> = {
|
|
11
|
+
/** Terminal commit for the final stage output. */
|
|
12
|
+
readonly sink: Sink<Out, E, R>;
|
|
13
|
+
/** Pipeline-level overflow policy. Defaults to `suspend` (back pressure, never drop). */
|
|
14
|
+
readonly overflow?: Stage.Overflow;
|
|
15
|
+
/** Pipeline-level bounded-buffer capacity. */
|
|
16
|
+
readonly bufferSize?: number;
|
|
17
|
+
};
|
|
18
|
+
/**
|
|
19
|
+
* Drain a composed stream to a sink: apply the pipeline-level overflow buffer and run to
|
|
20
|
+
* completion. Cancellation is structural — interrupting the returned effect interrupts the stream
|
|
21
|
+
* and all in-flight stage work; there are no daemon fibers to leak. Compose with `pipe`, chaining
|
|
22
|
+
* `Stage` transforms ahead of it: `pipe(source, Stage.map(...), Stage.window(...), Pipeline.run({
|
|
23
|
+
* sink }))`. Mirrors `Stream.runForEach`'s own shape: the sink's `E`/`R` (bound once, from `options`)
|
|
24
|
+
* are kept independent of — and unioned with — the piped-in stream's own `E`/`R`, so the incoming
|
|
25
|
+
* stream's generics aren't forced to unify with the sink's at the call site.
|
|
26
|
+
*/
|
|
27
|
+
export declare const run: {
|
|
28
|
+
<Out, E2, R2>(options: RunOptions<Out, E2, R2>): <E, R>(source: Stream.Stream<Out, E, R>) => Effect.Effect<void, E2 | E, R2 | R>;
|
|
29
|
+
<Out, E, R, E2, R2>(source: Stream.Stream<Out, E, R>, options: RunOptions<Out, E2, R2>): Effect.Effect<void, E2 | E, R2 | R>;
|
|
30
|
+
};
|
|
31
|
+
//# sourceMappingURL=Pipeline.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"Pipeline.d.ts","sourceRoot":"","sources":["../../../src/Pipeline.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAEjC;;;;GAIG;AACH,MAAM,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAEtF,MAAM,MAAM,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,IAAI;IAClD,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/B,yFAAyF;IACzF,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC;IACnC,8CAA8C;IAC9C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,EACV,OAAO,EAAE,UAAU,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,GAC/B,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC;IACnF,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,EAChC,OAAO,EAAE,UAAU,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,GAC/B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC;CASxC,CAAC"}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"Pipeline.test.d.ts","sourceRoot":"","sources":["../../../src/Pipeline.test.ts"],"names":[],"mappings":""}
|
|
@@ -0,0 +1,64 @@
|
|
|
1
|
+
import * as Effect from 'effect/Effect';
|
|
2
|
+
import * as Stream from 'effect/Stream';
|
|
3
|
+
/**
|
|
4
|
+
* Overflow policy applied when a consumer cannot keep pace, mapped onto `Stream.buffer` strategies.
|
|
5
|
+
* - `suspend`: back pressure — never drop (default; correct for email/document processing).
|
|
6
|
+
* - `sliding`: drop the oldest buffered item, keep the latest (correct for live transcription).
|
|
7
|
+
* - `dropping`: drop the newest item when the buffer is full.
|
|
8
|
+
*/
|
|
9
|
+
export type Overflow = 'suspend' | 'sliding' | 'dropping';
|
|
10
|
+
/** Default bounded-buffer capacity for both pipeline-level and per-stage buffering. */
|
|
11
|
+
export declare const DEFAULT_BUFFER_SIZE = 16;
|
|
12
|
+
/**
|
|
13
|
+
* A pipeline stage: a pipeable `Stream → Stream` transform, the same shape `Stream.mapEffect` /
|
|
14
|
+
* `Stream.filter` already have — generic over the *input* stream's own error/requirements (`E0`/
|
|
15
|
+
* `R0`) and unioning in the stage's own `E`/`R`, so stages compose in a `pipe` chain the same way
|
|
16
|
+
* Effect's own Stream operators do. Authors build stages with {@link map} / {@link window} /
|
|
17
|
+
* {@link filter}; shared dependencies flow through `R`, provided once at the edge via
|
|
18
|
+
* `Effect.provide`.
|
|
19
|
+
*/
|
|
20
|
+
export type Stage<In, Out, E = never, R = never> = <E0 = never, R0 = never>(self: Stream.Stream<In, E0, R0>) => Stream.Stream<Out, E0 | E, R0 | R>;
|
|
21
|
+
/** Options shared by buffering stage constructors. */
|
|
22
|
+
type BufferOptions = {
|
|
23
|
+
/**
|
|
24
|
+
* Per-stage overflow override; when set, a bounded buffer is inserted at the stage's async
|
|
25
|
+
* boundary. For {@link map} the buffer sits *before* `mapEffect`, so under load it sheds/coalesces
|
|
26
|
+
* in-flight input (`sliding` keeps the latest queued item — true latest-wins — `dropping` drops
|
|
27
|
+
* new arrivals while a run is in flight). For {@link window} it sits after windowing (a window
|
|
28
|
+
* must see every item), bounding output rate.
|
|
29
|
+
*/
|
|
30
|
+
readonly overflow?: Overflow;
|
|
31
|
+
/** Buffer capacity for the per-stage override. */
|
|
32
|
+
readonly bufferSize?: number;
|
|
33
|
+
};
|
|
34
|
+
export type MapOptions = BufferOptions & {
|
|
35
|
+
/** In-flight parallelism. Defaults to 1 (ordered + back-pressured); higher values may reorder. */
|
|
36
|
+
readonly concurrency?: number;
|
|
37
|
+
};
|
|
38
|
+
export type WindowOptions = BufferOptions;
|
|
39
|
+
/**
|
|
40
|
+
* 1:1 async transform. `fn` may return `undefined` to no-op for an item; the value is dropped
|
|
41
|
+
* before it reaches the next stage, so the returned stage's `Out` excludes `undefined`.
|
|
42
|
+
* `concurrency` defaults to 1 (ordered). `id` labels the per-item span for tracing.
|
|
43
|
+
*
|
|
44
|
+
* `Out`/`E`/`R` always infer from `fn`'s result; `In` only infers when the stage is composed inline
|
|
45
|
+
* in a `pipe` (pinned by the upstream stream). Built as a standalone value, pin `In` by annotating
|
|
46
|
+
* the callback parameter (`(item: T) => …`) or the binding (`const s: Stage<…> = …`). The four type
|
|
47
|
+
* parameters are intentionally all-or-nothing: passing a partial list (e.g. `map<In, Out>(…)`) is a
|
|
48
|
+
* compile error rather than silently forcing `E`/`R` to `never` and rejecting a service-using `fn`.
|
|
49
|
+
*/
|
|
50
|
+
export declare const map: <In, Out, E, R>(id: string, fn: (item: In) => Effect.Effect<Out, E, R>, options?: MapOptions) => Stage<In, Exclude<Out, undefined>, E, R>;
|
|
51
|
+
/**
|
|
52
|
+
* Sliding-window transform: invokes `fn` once per incoming item with a fixed-size rolling view of
|
|
53
|
+
* the last `size` items. The window is bounded by `size`, so memory does not grow with stream
|
|
54
|
+
* length; it composes with (and is distinct from) the overflow buffer, which bounds rate mismatch.
|
|
55
|
+
* `fn` may return `undefined` to no-op, narrowing `Out` the same way {@link map} does. Type
|
|
56
|
+
* parameters follow {@link map}: `Out`/`E`/`R` infer from `fn`, `In` is pinned inline by the
|
|
57
|
+
* upstream or (standalone) by annotating the callback parameter or the binding, and a partial type
|
|
58
|
+
* argument list is a compile error.
|
|
59
|
+
*/
|
|
60
|
+
export declare const window: <In, Out, E, R>(id: string, size: number, fn: (window: readonly In[]) => Effect.Effect<Out, E, R>, options?: WindowOptions) => Stage<In, Exclude<Out, undefined>, E, R>;
|
|
61
|
+
/** Drop items that do not match `pred`. */
|
|
62
|
+
export declare const filter: <In>(id: string, pred: (item: In) => boolean) => Stage<In, In>;
|
|
63
|
+
export {};
|
|
64
|
+
//# sourceMappingURL=Stage.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"Stage.d.ts","sourceRoot":"","sources":["../../../src/Stage.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,CAAC;AAE1D,uFAAuF;AACvF,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,MAAM,KAAK,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EACxE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,KAC5B,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC;AAExC,sDAAsD;AACtD,KAAK,aAAa,GAAG;IACnB;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,kDAAkD;IAClD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG;IACvC,kGAAkG;IAClG,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC;AAW1C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG,GACb,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,MACR,MAAM,MACN,CAAC,IAAI,EAAE,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,YACjC,UAAU,KAClB,KAAK,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,EAAE,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,CAUvC,CAAC;AAEN;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,GAAI,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,MAC9B,MAAM,QACJ,MAAM,MACR,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,YAC9C,aAAa,KACrB,KAAK,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,EAAE,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,CAiBzC,CAAC;AAEF,2CAA2C;AAC3C,eAAO,MAAM,MAAM,GAChB,EAAE,MAAM,MAAM,QAAQ,CAAC,IAAI,EAAE,EAAE,KAAK,OAAO,KAAG,KAAK,CAAC,EAAE,EAAE,EAAE,CAE3B,CAAC"}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"Stage.test.d.ts","sourceRoot":"","sources":["../../../src/Stage.test.ts"],"names":[],"mappings":""}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC"}
|
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
import * as Pipeline from '../Pipeline';
|
|
2
|
+
/** In-memory sink capturing every emitted value for assertions. */
|
|
3
|
+
export type CaptureSink<Out> = {
|
|
4
|
+
readonly sink: Pipeline.Sink<Out>;
|
|
5
|
+
readonly items: Out[];
|
|
6
|
+
};
|
|
7
|
+
export declare const captureSink: <Out>() => CaptureSink<Out>;
|
|
8
|
+
//# sourceMappingURL=capture.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../../../src/testing/capture.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,QAAQ,MAAM,aAAa,CAAC;AAExC,mEAAmE;AACnE,MAAM,MAAM,WAAW,CAAC,GAAG,IAAI;IAC7B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,GAAG,OAAK,WAAW,CAAC,GAAG,CAOlD,CAAC"}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"capture.test.d.ts","sourceRoot":"","sources":["../../../../src/testing/capture.test.ts"],"names":[],"mappings":""}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/index.ts"],"names":[],"mappings":"AAIA,cAAc,WAAW,CAAC"}
|