@t4h.framework/fs 0.7.0 → 0.8.0

package/.ai/skills/framework-fs/SKILL.md

@@ -4,6 +4,7 @@ description: >-
   Guides correct use of @t4h.framework/fs in T4H Framework workflows: the
   FileSystemClaim abstraction that the package activities (http, jsx) use to
   read/write files, the Binary result workflows consume, and runtime providers.
+  A workflow never implements Binary itself — see the framework-fs-write skill.
   Use when a workflow orchestrates file-backed package activities, consuming
   Binary results, mocking FileSystemClaim in workflow tests, registering fs
   claim providers, or debugging missing fs provider errors.
@@ -28,6 +29,8 @@ import {
   split, Split, FileSplitActivity, type FileSplitOptions,
   join, FileJoinActivity, type FileJoinOptions, type FileJoinWhere,
   read, FileReadActivity, type FileReadOptions,
+  // turn workflow content into a Binary — see the framework-fs-write skill
+  write, FileWriteActivity, type FileWriteOptions,
   ByteDelimiterScanner, type FileSplitDelimiter, type ByteRange, type ByteTrim,
 } from '@t4h.framework/fs'
 ```
@@ -46,6 +49,7 @@ export abstract class FileSystemClaim {
   public abstract write(
     path: string,
     readable: Readable | Buffer,
+    contentType?: string,
   ): Binary | Promise<Binary>
 
   public abstract read(path: string): Binary | Promise<Binary>
@@ -60,7 +64,7 @@ export abstract class FileSystemClaim {
 
 | Method | Purpose |
 |--------|---------|
-| `write(path, readable)` | Persist stream or buffer at `path`; return a `Binary` handle (metadata + `stream()`). |
+| `write(path, readable, contentType?)` | Persist stream or buffer at `path`; return a `Binary` handle (metadata + `stream()`). When `contentType` is omitted, infer it from the path. |
 | `read(path)` | Load an existing file at `path`; return a `Binary` handle. |
 | `slice(binary, range, encoding?)` | A view over a byte range of an existing binary, **without copying data**. When `encoding` is set, the runtime hydrates the slice as a decoded string instead of a binary — this is how `split` children receive plain strings. Implementations must **compose ranges**: slicing a slice is relative to it, and the stored range is absolute against the underlying file. |
 
@@ -96,9 +100,15 @@ read the resulting `Binary` (e.g. `await res.body.json()` / `text()`). Your only
 responsibility is that the runtime **registers a provider** (below). See
 **Known consumers** for which package primitives to orchestrate.
 
-This package's own workflow-facing primitives are `split`, `join` and `read`
+This package's own workflow-facing primitives are `split`, `join`, `read`
 (small byte windows — headers, trailers — hydrated into the workflow as a
-string, capped at 1 MiB). See the `framework-fs-split` skill.
+string, capped at 1 MiB) and `write` (content produced in the workflow turned
+into a file). See the `framework-fs-split` and `framework-fs-write` skills.
+
+**A workflow never implements `Binary`.** Every `Binary` comes from the
+framework — an HTTP response body, `sftp.get`, `write`, `join`. A class holding
+bytes in memory cannot be persisted, and every primitive it is handed to
+persists its input. See the `framework-fs-write` skill.
 
 ---
 
@@ -135,6 +145,9 @@ Test the **workflow** with `TestWorkflowEnvironment` from
 claims the triggered activities need, e.g. `HttpClientRequestClaim` for an HTTP
 call). See the **framework-workflow-testing** skill for the harness API.
 
+Subclassing `Binary` is legitimate **only here**, in a test double standing in
+for the claim — never in workflow or App code.
+
 ```typescript
 import { Readable } from 'node:stream'
 import { Binary } from '@t4h.framework/core'
@@ -180,7 +193,9 @@ Assert `mockWrite` was called with the expected path and body when relevant.
 
 1. **Extend** `FileSystemClaim` from `@t4h.framework/fs`.
 2. **Return** a `Binary` subclass (or core-compatible `Binary`) from `write` and `read` with correct `contentType`, `contentLength`, and `stream()`.
-3. **Accept** `Readable | Buffer` in `write` (match the abstract signature).
+3. **Accept** `Readable | Buffer` and the optional `contentType` in `write`
+   (match the abstract signature), falling back to inferring the content type
+   from the path when it is omitted.
 4. **Register** `{ provide: FileSystemClaim, value: new YourImpl() }` in the runtime (tests use `mockClaim(FileSystemClaim, ...)` instead).
 5. **Keep paths deterministic** when activities replay — unpredictable temp paths are fine if only `Binary` metadata is serialized and replay re-executes `write`; know your serializer/replay story if `path` is persisted.
 
@@ -206,6 +221,7 @@ Assert `mockWrite` was called with the expected path and body when relevant.
 ## Related skills
 
 - `framework-fs-split` — `split`/`join`: fan a file out into a batch of workflows and fold the results back into a file.
+- `framework-fs-write` — `write`: turn workflow content into a `Binary`, and why an App must never implement `Binary`.
 - `framework-core` — `Claim`, `Binary`, and the `TestWorkflowEnvironment` testing harness.
 - `framework-http` — HTTP activities that persist bodies via `FileSystemClaim`.
 - `framework-jsx` — render activities that write/read via `fs`.

package/.ai/skills/framework-fs-write/SKILL.md

@@ -0,0 +1,242 @@
+---
+name: framework-fs-write
+description: >-
+  Guides the use of `write` from @t4h.framework/fs — the only supported way to
+  turn content produced inside a workflow (a JSON string, a CSV, a positional
+  return file, a Buffer) into a `Binary` that other primitives accept. Use
+  whenever a workflow must upload, send or save content it built itself:
+  `sftp.put`/`sftp.append` with generated content, an HTTP request carrying a
+  file, persisting a report, or when the user mentions creating/building a
+  Binary, converting a string or Buffer to a Binary, "stringToBinary",
+  "BufferBinary", or hits `Unsupported binary instance`. A workflow must NEVER
+  implement its own `Binary` subclass — this skill explains why and what to do
+  instead.
+---
+
+# `write` — turn workflow content into a `Binary`
+
+Every file primitive in the framework speaks `Binary`: `sftp.put`,
+`sftp.append`, `split`, `join`, `pdf`, HTTP bodies. A `Binary` is a
+**reference** to stored content, not the bytes themselves.
+
+`write` is what produces one from content your workflow built:
+
+```typescript
+import { write } from '@t4h.framework/fs'
+
+const file = await write(JSON.stringify(state, null, 2), {
+  contentType: 'application/json',
+})
+
+await sftp.put('/out/state.json', file)
+```
+
+Package path: `framework/packages/fs`. Import only from the package root.
+
+---
+
+## Never implement `Binary` yourself
+
+This is the rule this skill exists to enforce:
+
+```typescript
+// ❌ NEVER — this class cannot be persisted
+class BufferBinary extends Binary {
+  constructor(
+    private readonly content: Buffer,
+    readonly contentType = '...',
+  ) {
+    super()
+  }
+
+  get contentLength() {
+    return this.content.length
+  }
+
+  stream() {
+    return Readable.from(this.content)
+  }
+}
+
+await sftp.put('/out/state.json', new BufferBinary(Buffer.from(json)))
+```
+
+```typescript
+// ✅ ALWAYS
+await sftp.put(
+  '/out/state.json',
+  await write(json, {
+    contentType: 'application/json',
+  }),
+)
+```
+
+### Why a custom `Binary` cannot work
+
+A workflow is **durable**: the body replays, and each activity is persisted
+before it runs. When you pass a value to a primitive, that value becomes the
+activity **input**, and the input is serialized to storage.
+
+A `Binary` holding bytes in memory has nothing to serialize into — the buffer
+lives in the process that built it, and the activity may run in another
+process, minutes later, after a replay. The runtime therefore has to spool the
+content somewhere before the activity can be persisted at all.
+
+Symptoms of doing it by hand:
+
+- `TypeError: Unsupported binary instance` when the activity input is
+  serialized, on older runtimes;
+- the activity is never persisted, the transaction rolls back, and the message
+  ends up in the dead letter queue after the retries — the run stops mid-way
+  with no obvious error in the workflow itself;
+- it may still "work" locally, because the dev server keeps values in memory
+  and never crosses a process boundary. **Passing locally proves nothing here.**
+
+Current runtimes spool an unknown `Binary` to storage instead of failing, so a
+hand-rolled class may survive — but it pays a hidden copy, loses the content
+type you meant to set, and depends on runtime-version behavior. `write` is the
+contract.
+
+---
+
+## API
+
+```typescript
+function write(
+  content: string | Buffer,
+  options?: FileWriteOptions,
+): Promise<Binary>
+```
+
+| Option        | Type             | Required | Purpose                                                                                                                                                     |
+| ------------- | ---------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `contentType` | `string`         | No       | Content type stored with the file — `'application/json'`, `'text/csv'`, … Defaults to what the filename extension implies, then `application/octet-stream`. |
+| `filename`    | `string`         | No       | Name the file is stored under. Defaults to the activity id.                                                                                                 |
+| `encoding`    | `BufferEncoding` | No       | How a **string** `content` is encoded. Defaults to `'utf8'`. Ignored for a `Buffer`, which always travels as base64.                                        |
+
+`write` is a durable activity: on replay the content is **not** written again;
+the recorded `Binary` is returned.
+
+---
+
+## When to use it
+
+| Situation                                                                     | Use                                             |
+| ----------------------------------------------------------------------------- | ----------------------------------------------- |
+| Send content the workflow built (JSON, CSV, positional file) over SFTP/HTTP   | `write`                                         |
+| Read a small window of an existing file into the workflow                     | [`read`](./read) — see **framework-fs-split**   |
+| Fan a large file out into one workflow per record                             | `split` — see **framework-fs-split**            |
+| Fold a finished batch back into a file                                        | `join` — see **framework-fs-split**             |
+| Content already is a `Binary` (HTTP response body, `sftp.get`, `join` result) | pass it straight through — do not re-`write` it |
+
+---
+
+## Size matters: keep content bounded
+
+`write` takes content **in workflow memory**, so it is bounded by what the
+workflow can reasonably hold — a state file, a report, a return file. It is not
+the tool for gigabyte outputs.
+
+To build a large file out of many records, use `join` over a batch: it streams
+results one at a time into storage, and nothing but the resulting `Binary`
+reaches the workflow.
+
+---
+
+## Patterns
+
+### A) Write then upload
+
+```typescript
+const csv = await write(rows.map(toCsvLine).join('\n'), {
+  contentType: 'text/csv',
+  filename: `report-${input.date}.csv`,
+})
+
+await sftp.put(`/out/report-${input.date}.csv`, csv)
+```
+
+### B) Write once, use twice
+
+The same `Binary` can be handed to more than one primitive — it is a reference,
+so nothing is copied and nothing is re-uploaded:
+
+```typescript
+const file = await write(json, { contentType: 'application/json' })
+
+await sftp.put(`${path}.tmp`, file)
+await sftp.put(path, file)
+```
+
+Note that a hand-rolled `Binary` backed by a single-use stream would break on
+the second call — another reason not to build one.
+
+### C) Binary content
+
+```typescript
+const pdfBytes: Buffer = await buildPdf()
+
+await sftp.put(
+  '/out/invoice.pdf',
+  await write(pdfBytes, {
+    contentType: 'application/pdf',
+  }),
+)
+```
+
+---
+
+## Testing
+
+`write` goes through `FileSystemClaim.write`, so mock that claim like any
+other. See the **framework-workflow-testing** skill for the harness API.
+
+```typescript
+import { TestWorkflowEnvironment, mockClaim } from '@t4h.framework/core/testing'
+import { FileSystemClaim } from '@t4h.framework/fs'
+
+// replay runs the workflow twice — return a fresh Binary per call
+const write = vi
+  .fn()
+  .mockImplementation(
+    async (path, content, contentType) =>
+      new MockBinary(
+        Buffer.isBuffer(content) ? content : await toBuffer(content),
+        contentType,
+      ),
+  )
+
+await env.execute(workflow, input, {
+  claims: [
+    mockClaim(FileSystemClaim, { write, read: vi.fn(), slice: vi.fn() }),
+  ],
+})
+
+expect(write).toHaveBeenCalledWith('report.csv', expect.any(Buffer), 'text/csv')
+```
+
+---
+
+## Anti-patterns
+
+- **Declaring a class that extends `Binary`** in an App. There is no valid
+  reason to; use `write`.
+- Helper functions like `stringToBinary(value)` that wrap content in a custom
+  class — replace the implementation with `write`, keeping the helper name if
+  it reads well.
+- `write`-ing a value that already is a `Binary` (an HTTP response body, a
+  `sftp.get` result, a `join` output) — that copies a file to obtain a
+  reference you already had.
+- Building a large file by concatenating records in memory and calling `write`
+  once — use `split`/`join` instead.
+- Relying on the filename extension to set the content type when the consumer
+  cares about it — pass `contentType` explicitly.
+
+---
+
+## Related skills
+
+- `framework-fs` — the `FileSystemClaim` contract and runtime providers.
+- `framework-fs-split` — `read`/`split`/`join`: windows, fan-out and fold.
+- `framework-sftp` — `sftp.put`/`append`, the most common consumer of `write`.
+- `framework-workflow-creation` — the rules a workflow body must follow.

package/CHANGELOG.md

@@ -0,0 +1,78 @@
+# @t4h.framework/fs
+
+## 0.8.0
+
+### Minor Changes
+
+- [`8c56f76`](https://github.com/tech4humans-brasil/framework/commit/8c56f7697390a1ea966d1e91ff5f35ce5751a0d7) Thanks [@gusteycamargo](https://github.com/gusteycamargo)! - feat: write in-memory content to durable storage from a workflow
+
+  There was no supported way to turn a string or a Buffer into a `Binary` inside
+  a workflow — every `Binary` came from an existing file (`http` response,
+  `sftp.get`, `split`, `join`). Anyone needing to upload computed content had to
+  implement `Binary` by hand, and such an instance can never be persisted, so the
+  activity carrying it failed to serialize.
+
+  `write(content, options?)` covers that gap: it pushes an activity that stores
+  the content through the `FileSystemClaim` and returns a `Binary` that survives
+  replay.
+
+  ```ts
+  const file = await write(JSON.stringify(data), {
+    contentType: 'application/json',
+  })
+
+  await sftp.put('/out/data.json', file)
+  ```
+
+  `FileSystemClaim.write` takes an optional `contentType` — until now the content
+  type was always inferred from the file extension.
+
+  The dev codec no longer diverges from the runtime one: its binary kind used to
+  match only `DevFileBinary`, so a hand-written `Binary` was silently serialized
+  as a plain object locally and blew up once deployed. It now matches any
+  `Binary` and spools unknown ones to disk, the same way the runtime spools them
+  to the file storage.
+
+- [`8c56f76`](https://github.com/tech4humans-brasil/framework/commit/8c56f7697390a1ea966d1e91ff5f35ce5751a0d7) Thanks [@gusteycamargo](https://github.com/gusteycamargo)! - Adds FS write activity
+
+## 0.7.0
+
+### Minor Changes
+
+- Adds support to read file ([#109](https://github.com/tech4humans-brasil/framework/pull/109))
+
+## 0.6.0
+
+### Minor Changes
+
+- Adds activity to split and join binary ([#100](https://github.com/tech4humans-brasil/framework/pull/100))
+
+## 0.5.0
+
+### Patch Changes
+
+- Update skills ([`6d7e7bc`](https://github.com/tech4humans-brasil/framework/commit/6d7e7bca0c780a9c53a0c9e5aa0a865c5af67959))
+
+## 0.4.0
+
+### Patch Changes
+
+- Internal dependency updates
+
+## 0.3.0
+
+### Minor Changes
+
+- Adds fs package ([`538c9bd`](https://github.com/tech4humans-brasil/framework/commit/538c9bd5c49031ceb94ef8d6c513f6ffc9c848c5))
+- Adds support to buffer in fs write package ([`476f9f0`](https://github.com/tech4humans-brasil/framework/commit/476f9f08a7b379a3361e42f8577078462276210b))
+- Adds .ai/skills in packages ([#88](https://github.com/tech4humans-brasil/framework/pull/88))
+
+### Patch Changes
+
+- Remove activity prefix from file system claim class name ([`d257bd1`](https://github.com/tech4humans-brasil/framework/commit/d257bd177d477a56a897ba862a0be1f50531c633))
+- Adds github workflow to run, build, tests and lint ([#18](https://github.com/tech4humans-brasil/framework/pull/18))
+- Adds readme ([`3a55794`](https://github.com/tech4humans-brasil/framework/commit/3a557942769fa022b9a39504046d22b0083e734f))
+- Update package metadata and author information across multiple packages ([`2ca73df`](https://github.com/tech4humans-brasil/framework/commit/2ca73df42dc63c86ed44717b50d5402fca45b4e7))
+- Improve repository info ([`1fad92d`](https://github.com/tech4humans-brasil/framework/commit/1fad92d959b804189fd1486d047115995ac81eb0))
+- Fix resolve module resolution issues in check-types ([`c97a0d2`](https://github.com/tech4humans-brasil/framework/commit/c97a0d2747f38e561cc5c7d592b20de0459bc1ee))
+- Update package dependencies across multiple packages ([`8b4fc1d`](https://github.com/tech4humans-brasil/framework/commit/8b4fc1d0e92d6bd880ddf4c8119fb68c49c53760))

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tech for humans
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -3,8 +3,8 @@
 File system claim for reading and writing files within activities, plus the
 workflow-facing file activities: `split` fans a large file out into one child
 workflow per slice, `join` folds the batch results back into a single file,
-and `read` brings a small byte window (a header, a trailer) into the workflow
-as a string.
+`read` brings a small byte window (a header, a trailer) into the workflow as a
+string, and `write` turns content the workflow produced into a file.
 
 ## Claim
 
@@ -23,6 +23,7 @@ abstract class FileSystemClaim {
   public abstract write(
     path: string,
     readable: Readable | Buffer,
+    contentType?: string,
   ): Binary | Promise<Binary>
   public abstract read(path: string): Binary | Promise<Binary>
 
@@ -107,6 +108,39 @@ Reading a slice is relative to the slice: `read(slice, { range: { start: 0,
 end: 10 } })` returns the first 10 bytes of the slice, not of the underlying
 file — slice ranges compose.
 
+## File write
+
+### write
+
+Stores content produced inside the workflow and returns its `Binary` — the only
+supported way to obtain a `Binary` from a string or a `Buffer`:
+
+```typescript
+import { write } from '@t4h.framework/fs'
+
+const file = await write(JSON.stringify(state, null, 2), {
+  contentType: 'application/json',
+})
+
+await sftp.put('/out/state.json', file)
+```
+
+Options: `contentType` (default: inferred from the filename, then
+`application/octet-stream`), `filename` (default: the activity id) and
+`encoding` for a string content (default `'utf8'`; a `Buffer` always travels as
+base64).
+
+**Never implement `Binary` in an App.** Passing a value to a primitive makes it
+the input of a durable activity, and that input is serialized to storage before
+the activity runs — a `Binary` holding bytes in memory has nothing to serialize
+into, and the activity may run in another process after a replay. A hand-rolled
+class can pass locally (the dev server keeps values in memory) and fail once
+deployed.
+
+`write` takes content already in workflow memory — a state file, a report, a
+return file. To build a large file out of many records, use `split` + `join`,
+which stream through storage.
+
 ## File split
 
 ### split

package/dist/FileSystemClaim.d.ts

@@ -1,7 +1,7 @@
 import type { Readable } from 'node:stream';
 import type { Binary } from '@t4h.framework/core';
 export declare abstract class FileSystemClaim {
-    abstract write(path: string, readable: Readable | Buffer): Binary | Promise<Binary>;
+    abstract write(path: string, readable: Readable | Buffer, contentType?: string): Binary | Promise<Binary>;
     abstract read(path: string): Binary | Promise<Binary>;
     abstract slice(binary: Binary, range: {
         start: number;

package/dist/FileSystemClaim.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileSystemClaim.d.ts","sourceRoot":"","sources":["../src/FileSystemClaim.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,8BAAsB,eAAe;aACnB,KAAK,CACnB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,QAAQ,GAAG,MAAM,GAC1B,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;aAEX,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;aAE5C,KAAK,CACnB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EACrC,QAAQ,CAAC,EAAE,cAAc,GACxB,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAC5B"}
+{"version":3,"file":"FileSystemClaim.d.ts","sourceRoot":"","sources":["../src/FileSystemClaim.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,8BAAsB,eAAe;aACnB,KAAK,CACnB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,QAAQ,GAAG,MAAM,EAC3B,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;aAEX,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;aAE5C,KAAK,CACnB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EACrC,QAAQ,CAAC,EAAE,cAAc,GACxB,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAC5B"}

package/dist/FileSystemClaim.js.map

@@ -1 +1 @@
-{"version":3,"file":"FileSystemClaim.js","sourceRoot":"","sources":["../src/FileSystemClaim.ts"],"names":[],"mappings":"AAIA,MAAM,OAAgB,eAAe;CAapC"}
+{"version":3,"file":"FileSystemClaim.js","sourceRoot":"","sources":["../src/FileSystemClaim.ts"],"names":[],"mappings":"AAIA,MAAM,OAAgB,eAAe;CAcpC"}

package/dist/activities/FileWriteActivity.d.ts

@@ -0,0 +1,20 @@
+import { type Binary, SyncActivity } from '@t4h.framework/core';
+export type FileWriteOptions = {
+    filename?: string;
+    contentType?: string;
+    encoding?: BufferEncoding;
+};
+export type FileWriteActivityInput = {
+    content: string;
+    encoding: BufferEncoding;
+    filename: string;
+    contentType?: string;
+};
+export declare class FileWriteActivity extends SyncActivity<readonly [content: string | Buffer, options: FileWriteOptions], FileWriteActivityInput, Binary, Binary> {
+    private readonly claims;
+    toInput(content: string | Buffer, options: FileWriteOptions): FileWriteActivityInput;
+    run({ content, encoding, filename, contentType, }: FileWriteActivityInput): Promise<Binary>;
+    toOutput(output: Binary): Binary;
+}
+export declare function write(content: string | Buffer, options?: FileWriteOptions): Promise<Binary>;
+//# sourceMappingURL=FileWriteActivity.d.ts.map

package/dist/activities/FileWriteActivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileWriteActivity.d.ts","sourceRoot":"","sources":["../../src/activities/FileWriteActivity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAkB,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAI/E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,cAAc,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,cAAc,CAAA;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,qBAAa,iBAAkB,SAAQ,YAAY,CACjD,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,gBAAgB,CAAC,EAC9D,sBAAsB,EACtB,MAAM,EACN,MAAM,CACP;IACC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAErB;IAEK,OAAO,CACZ,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,OAAO,EAAE,gBAAgB,GACxB,sBAAsB;IAWZ,GAAG,CAAC,EACf,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,WAAW,GACZ,EAAE,sBAAsB,GAAG,OAAO,CAAC,MAAM,CAAC;IAQpC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;CAGxC;AAED,wBAAsB,KAAK,CACzB,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,MAAM,CAAC,CAEjB"}

package/dist/activities/FileWriteActivity.js

@@ -0,0 +1,26 @@
+import { Claim, History, SyncActivity } from '@t4h.framework/core';
+import { FileSystemClaim } from '../FileSystemClaim.js';
+export class FileWriteActivity extends SyncActivity {
+    claims = new Claim({
+        fs: FileSystemClaim,
+    });
+    toInput(content, options) {
+        const isBuffer = Buffer.isBuffer(content);
+        return {
+            content: isBuffer ? content.toString('base64') : content,
+            encoding: isBuffer ? 'base64' : (options.encoding ?? 'utf8'),
+            filename: options.filename ?? this.id,
+            contentType: options.contentType,
+        };
+    }
+    async run({ content, encoding, filename, contentType, }) {
+        return await this.claims.fs.write(filename, Buffer.from(content, encoding), contentType);
+    }
+    toOutput(output) {
+        return output;
+    }
+}
+export async function write(content, options = {}) {
+    return await History.reconciler(FileWriteActivity, content, options);
+}
+//# sourceMappingURL=FileWriteActivity.js.map

package/dist/activities/FileWriteActivity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileWriteActivity.js","sourceRoot":"","sources":["../../src/activities/FileWriteActivity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAE/E,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAevD,MAAM,OAAO,iBAAkB,SAAQ,YAKtC;IACkB,MAAM,GAAG,IAAI,KAAK,CAAC;QAClC,EAAE,EAAE,eAAe;KACpB,CAAC,CAAA;IAEK,OAAO,CACZ,OAAwB,EACxB,OAAyB;QAEzB,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAA;QAEzC,OAAO;YACL,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO;YACxD,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,IAAI,MAAM,CAAC;YAC5D,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC,EAAE;YACrC,WAAW,EAAE,OAAO,CAAC,WAAW;SACjC,CAAA;IACH,CAAC;IAEM,KAAK,CAAC,GAAG,CAAC,EACf,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,WAAW,GACY;QACvB,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAC/B,QAAQ,EACR,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,EAC9B,WAAW,CACZ,CAAA;IACH,CAAC;IAEM,QAAQ,CAAC,MAAc;QAC5B,OAAO,MAAM,CAAA;IACf,CAAC;CACF;AAED,MAAM,CAAC,KAAK,UAAU,KAAK,CACzB,OAAwB,EACxB,UAA4B,EAAE;IAE9B,OAAO,MAAM,OAAO,CAAC,UAAU,CAAC,iBAAiB,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;AACtE,CAAC"}

package/dist/fs.d.ts

@@ -2,5 +2,6 @@ export * from './FileSystemClaim.js';
 export * from './activities/FileJoinActivity.js';
 export * from './activities/FileReadActivity.js';
 export * from './activities/FileSplitActivity.js';
+export * from './activities/FileWriteActivity.js';
 export * from './helpers/byte-delimiter-scanner.js';
 //# sourceMappingURL=fs.d.ts.map

package/dist/fs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,kCAAkC,CAAA;AAChD,cAAc,kCAAkC,CAAA;AAChD,cAAc,mCAAmC,CAAA;AACjD,cAAc,qCAAqC,CAAA"}
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,kCAAkC,CAAA;AAChD,cAAc,kCAAkC,CAAA;AAChD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,qCAAqC,CAAA"}

package/dist/fs.js

@@ -2,5 +2,6 @@ export * from './FileSystemClaim.js';
 export * from './activities/FileJoinActivity.js';
 export * from './activities/FileReadActivity.js';
 export * from './activities/FileSplitActivity.js';
+export * from './activities/FileWriteActivity.js';
 export * from './helpers/byte-delimiter-scanner.js';
 //# sourceMappingURL=fs.js.map

package/dist/fs.js.map

@@ -1 +1 @@
-{"version":3,"file":"fs.js","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,kCAAkC,CAAA;AAChD,cAAc,kCAAkC,CAAA;AAChD,cAAc,mCAAmC,CAAA;AACjD,cAAc,qCAAqC,CAAA"}
+{"version":3,"file":"fs.js","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,kCAAkC,CAAA;AAChD,cAAc,kCAAkC,CAAA;AAChD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,qCAAqC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@t4h.framework/fs",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "File system module for the T4H Framework",
   "homepage": "https://github.com/tech4humans-brasil/framework/tree/main/packages/fs",
   "bugs": "https://github.com/tech4humans-brasil/framework/issues",
@@ -32,12 +32,12 @@
     "test:watch": "vitest"
   },
   "devDependencies": {
-    "@t4h.framework/core": "^0.9.0",
+    "@t4h.framework/core": "^0.9.1",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
-    "@t4h.framework/core": "^0.9.0"
+    "@t4h.framework/core": "^0.9.1"
   },
   "packageManager": "yarn@4.12.0",
   "engines": {

package/dist/activities/__tests__/FileJoinActivity.spec.d.ts

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

package/dist/activities/__tests__/FileJoinActivity.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FileJoinActivity.spec.d.ts","sourceRoot":"","sources":["../../../src/activities/__tests__/FileJoinActivity.spec.ts"],"names":[],"mappings":""}