create-qpq-app 0.1.5

package/template/docusaurus/docs/actions/core/file/ask-file-read-binary-contents.md

@@ -0,0 +1,78 @@
+---
+title: askFileReadBinaryContents
+description: Read a file from a storage drive as binary data.
+---
+
+# askFileReadBinaryContents
+
+Reads a file on a [storage drive](../../../config/core/storage-drive.md) and returns it as binary data — base64-encoded bytes plus metadata. Use this for non-text files such as images, PDFs, or archives.
+
+- **Action type:** `FileActionType.ReadBinaryContents`
+- **On AWS:** performs an S3 `GetObject` on the drive's bucket and returns the body base64-encoded.
+
+```typescript
+import { askFileReadBinaryContents } from 'quidproquo-core';
+
+export function* askGetLogo() {
+  const logo = yield* askFileReadBinaryContents('assets', 'branding/logo.png');
+  // logo.base64Data, logo.filename, logo.mimetype
+  return logo;
+}
+```
+
+## Signature
+
+```typescript
+function* askFileReadBinaryContents(
+  drive: string,
+  filepath: string,
+): AskResponse<QPQBinaryData>;
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `drive` | `string` | Name of the storage drive to read from — must match a drive declared with [defineStorageDrive](../../../config/core/storage-drive.md) (or one shared via its `owner` option). |
+| `filepath` | `string` | Path of the file within the drive, forward-slash delimited. |
+
+## Returns
+
+`QPQBinaryData` — the file's bytes and metadata:
+
+```typescript
+interface QPQBinaryData {
+  base64Data: string;
+  filename: string;
+  mimetype?: string;
+  contentDisposition?: string;
+}
+```
+
+## Errors
+
+| Error | Meaning |
+| --- | --- |
+| `FileReadBinaryContentsErrorTypeEnum.InvalidStorageClass` | The file is in a cold storage tier and cannot be read directly. Check first with [askFileIsColdStorage](./ask-file-is-cold-storage.md). |
+| `FileReadBinaryContentsErrorTypeEnum.FileNotFound` | No file exists at the given path. |
+
+Errors thrown by actions can be caught with `askCatch` from quidproquo-core. It returns an `EitherActionResult` — `{ success: true, result }` on success, or `{ success: false, error }` on failure:
+
+```typescript
+const outcome = yield* askCatch(askFileReadBinaryContents('assets', 'branding/logo.png'));
+
+if (outcome.success) {
+  const data = outcome.result;
+} else {
+  // outcome.error.errorType / outcome.error.errorText
+}
+```
+
+## Related
+
+- [defineStorageDrive](../../../config/core/storage-drive.md) — declares the drive this action reads from.
+- [askFileWriteBinaryContents](./ask-file-write-binary-contents.md) — the write counterpart.
+- [askFileReadTextContents](./ask-file-read-text-contents.md) — read as a UTF-8 string instead of bytes.
+- [askFileGenerateTemporarySecureUrl](./ask-file-generate-temporary-secure-url.md) — hand a client a download URL instead of routing bytes through your service.
+- [askFileStreamOpen](./ask-file-stream-open.md) — stream large files in chunks instead of loading them whole.
+- [askCreateTextQpqBinaryData](../binary-data/ask-create-text-qpq-binary-data.md) — build a `QPQBinaryData` payload from a text string.

package/template/docusaurus/docs/actions/core/file/ask-file-read-object-json.md

@@ -0,0 +1,72 @@
+---
+title: askFileReadObjectJson
+description: Read a JSON file from a storage drive and parse it into a typed object.
+---
+
+# askFileReadObjectJson
+
+Reads a file on a [storage drive](../../../config/core/storage-drive.md) and parses its contents as JSON, returning a typed object. This is the read counterpart to [askFileWriteObjectJson](./ask-file-write-object-json.md) — the read and `JSON.parse` happen in a single action.
+
+- **Action type:** `FileActionType.ReadObjectJson`
+- **On AWS:** performs an S3 `GetObject` on the drive's bucket and runs `JSON.parse` on the text body.
+
+```typescript
+import { askFileReadObjectJson } from 'quidproquo-core';
+
+interface AppSettings {
+  theme: string;
+  featureFlags: string[];
+}
+
+export function* askGetSettings() {
+  const settings = yield* askFileReadObjectJson<AppSettings>('config', 'settings.json');
+  return settings.theme;
+}
+```
+
+## Signature
+
+```typescript
+function* askFileReadObjectJson<T extends object>(
+  drive: string,
+  filepath: string,
+): AskResponse<T>;
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `drive` | `string` | Name of the storage drive to read from — must match a drive declared with [defineStorageDrive](../../../config/core/storage-drive.md) (or one shared via its `owner` option). |
+| `filepath` | `string` | Path of the JSON file within the drive, forward-slash delimited. |
+
+The type parameter `T` is the shape you expect the parsed JSON to have. It is a compile-time annotation only — the contents are not validated against it at runtime.
+
+## Returns
+
+`T` — the parsed JSON object.
+
+## Errors
+
+| Error | Meaning |
+| --- | --- |
+| `FileReadObjectJsonErrorTypeEnum.InvalidStorageClass` | The file is in a cold storage tier and cannot be read directly. Check first with [askFileIsColdStorage](./ask-file-is-cold-storage.md). |
+
+Errors thrown by actions can be caught with `askCatch` from quidproquo-core. It returns an `EitherActionResult` — `{ success: true, result }` on success, or `{ success: false, error }` on failure:
+
+```typescript
+const outcome = yield* askCatch(askFileReadObjectJson<AppSettings>('config', 'settings.json'));
+
+if (outcome.success) {
+  const settings = outcome.result;
+} else {
+  // outcome.error.errorType / outcome.error.errorText
+}
+```
+
+## Related
+
+- [defineStorageDrive](../../../config/core/storage-drive.md) — declares the drive this action reads from.
+- [askFileWriteObjectJson](./ask-file-write-object-json.md) — the write counterpart (`JSON.stringify` + write).
+- [askFileReadTextContents](./ask-file-read-text-contents.md) — read the raw string without parsing.
+- [askDecodeJson](../json/ask-decode-json.md) — safely parse a JSON string you already have in hand.

package/template/docusaurus/docs/actions/core/file/ask-file-read-text-contents.md

@@ -0,0 +1,69 @@
+---
+title: askFileReadTextContents
+description: Read a file from a storage drive as a UTF-8 string.
+---
+
+# askFileReadTextContents
+
+Reads the contents of a file on a [storage drive](../../../config/core/storage-drive.md) and returns it as a string.
+
+- **Action type:** `FileActionType.ReadTextContents`
+
+```typescript
+import { askFileReadTextContents } from 'quidproquo-core';
+
+export function* askGetWelcomeMessage() {
+  const message = yield* askFileReadTextContents('templates', 'emails/welcome.txt');
+  return message;
+}
+```
+
+## Signature
+
+```typescript
+function* askFileReadTextContents(
+  drive: string,
+  filepath: string,
+): AskResponse<string>;
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `drive` | `string` | Name of the storage drive to read from — must match a drive declared with [defineStorageDrive](../../../config/core/storage-drive.md) (or one shared via its `owner` option). |
+| `filepath` | `string` | Path of the file within the drive. Always use forward slashes, e.g. `'reports/2026/summary.txt'`. |
+
+## Returns
+
+`string` — the full file contents, decoded as text.
+
+## Errors
+
+| Error | Meaning |
+| --- | --- |
+| `FileReadTextContentsErrorTypeEnum.InvalidStorageClass` | The file is in a cold storage tier and cannot be read directly. Check first with `askFileIsColdStorage`. |
+
+Errors thrown by actions can be caught with `askCatch` from quidproquo-core. It returns an `EitherActionResult` — `{ success: true, result }` on success, or `{ success: false, error }` on failure:
+
+```typescript
+const outcome = yield* askCatch(askFileReadTextContents('templates', 'emails/welcome.txt'));
+
+if (outcome.success) {
+  const contents = outcome.result;
+  // ...
+} else {
+  // outcome.error.errorType / outcome.error.errorText
+}
+```
+
+## Related
+
+- [defineStorageDrive](../../../config/core/storage-drive.md) — declares the drive this action reads from.
+- [askFileWriteTextContents](./ask-file-write-text-contents.md) — the write counterpart.
+- [askFileReadObjectJson](./ask-file-read-object-json.md) — read + `JSON.parse` in one action.
+- [askFileReadBinaryContents](./ask-file-read-binary-contents.md) — read raw bytes instead of text.
+- [askFileExists](./ask-file-exists.md) / [askFileIsColdStorage](./ask-file-is-cold-storage.md) — check before reading.
+- [askFileListDirectory](./ask-file-list-directory.md) — enumerate files on the drive.
+- [askFileStreamOpen](./ask-file-stream-open.md) — stream large files in chunks instead of reading them whole.
+- [askDecodeJson](../json/ask-decode-json.md) — safely JSON-parse the string you just read.

package/template/docusaurus/docs/actions/core/file/ask-file-stream-open.md

@@ -0,0 +1,102 @@
+---
+title: askFileStreamOpen
+description: Open a file on a storage drive as a readable stream and consume it in chunks.
+---
+
+# askFileStreamOpen
+
+Opens a file on a [storage drive](../../../config/core/storage-drive.md) as a **stream** and returns a handle you read from chunk by chunk. Use this instead of [askFileReadBinaryContents](./ask-file-read-binary-contents.md) or [askFileReadTextContents](./ask-file-read-text-contents.md) when a file is too large to comfortably load into memory all at once.
+
+- **Action type:** `FileActionType.StreamOpen`
+- **On AWS:** performs an S3 `GetObject` and registers the response body as a chunked async iterator in the runtime's stream registry. Each chunk is `chunkSize` bytes (default `65536`).
+
+The action does not return the file's bytes — it returns a **stream handle**. You then pull chunks with `askStreamRead` and release the stream with `askStreamClose` (both from quidproquo-core).
+
+```typescript
+import { askFileStreamOpen, askStreamRead, askStreamClose } from 'quidproquo-core';
+
+export function* askCountLines(filepath: string) {
+  const handle = yield* askFileStreamOpen('logs', filepath, 'text');
+
+  let lines = 0;
+  while (true) {
+    const chunk = yield* askStreamRead(handle);
+    if (chunk.done) {
+      break;
+    }
+    if (chunk.data) {
+      lines += chunk.data.split('\n').length - 1;
+    }
+  }
+
+  yield* askStreamClose(handle);
+  return lines;
+}
+```
+
+## Signature
+
+```typescript
+function* askFileStreamOpen<E extends StreamEncoding = 'text'>(
+  drive: string,
+  filepath: string,
+  encoding?: E,
+  chunkSize?: number,
+): AskResponse<StreamHandle<E>>;
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `drive` | `string` | Name of the storage drive the file lives on — must match a drive declared with [defineStorageDrive](../../../config/core/storage-drive.md) (or one shared via its `owner` option). |
+| `filepath` | `string` | Path of the file within the drive, forward-slash delimited. |
+| `encoding` | `StreamEncoding` | How each chunk is decoded when you read it. `'text'` (default) yields `string`, `'binary'` yields `Uint8Array`, `'json'` parses each chunk. |
+| `chunkSize` | `number` | Bytes per chunk. Defaults to `65536` (64 KiB) in the AWS runtime. |
+
+`StreamEncoding` is `'text' | 'binary' | 'json'`.
+
+## Returns
+
+`StreamHandle<E>` — an opaque handle you pass to `askStreamRead` / `askStreamClose`:
+
+```typescript
+interface StreamHandle<E extends StreamEncoding> {
+  id: string;
+  encoding: E;
+}
+```
+
+The handle's `encoding` type parameter flows through to `askStreamRead`, so a `'text'` stream reads `string` chunks, a `'binary'` stream reads `Uint8Array` chunks, and a `'json'` stream reads parsed objects.
+
+## Errors
+
+| Error | Meaning |
+| --- | --- |
+| `FileStreamOpenErrorTypeEnum.InvalidStorageClass` | The file is in a cold storage tier and cannot be streamed directly. Check first with [askFileIsColdStorage](./ask-file-is-cold-storage.md). |
+| `FileStreamOpenErrorTypeEnum.FileNotFound` | No file exists at the given path. |
+
+Errors thrown by actions can be caught with `askCatch` from quidproquo-core. It returns an `EitherActionResult` — `{ success: true, result }` on success, or `{ success: false, error }` on failure:
+
+```typescript
+const outcome = yield* askCatch(askFileStreamOpen('logs', 'app/2026-07-07.log', 'text'));
+
+if (outcome.success) {
+  const handle = outcome.result;
+} else {
+  // outcome.error.errorType / outcome.error.errorText
+}
+```
+
+## Notes
+
+- Always release the stream with `askStreamClose` once you are done — including on early exit — so the runtime can free the underlying source.
+- Reading returns a `StreamChunk`: `{ done, data?, skipped? }`. Stop when `done` is `true`.
+
+## Related
+
+- [defineStorageDrive](../../../config/core/storage-drive.md) — declares the drive this action streams from.
+- [askFileReadBinaryContents](./ask-file-read-binary-contents.md) / [askFileReadTextContents](./ask-file-read-text-contents.md) — read a whole file at once instead of streaming.
+- [askStreamRead](../stream/ask-stream-read.md) / [askStreamClose](../stream/ask-stream-close.md) — read chunks from and release the returned handle.
+- [askStreamProcess](../stream/ask-stream-process.md) / [askStreamMap](../stream/ask-stream-map.md) — consume the whole stream in one call (run a callback per chunk, or collect into an array).
+- [askFileIsColdStorage](./ask-file-is-cold-storage.md) — verify a file is directly readable before streaming.

package/template/docusaurus/docs/actions/core/file/ask-file-write-binary-contents.md

@@ -0,0 +1,98 @@
+---
+title: askFileWriteBinaryContents
+description: Write binary data to a file on a storage drive.
+---
+
+# askFileWriteBinaryContents
+
+Writes binary data to a file on a [storage drive](../../../config/core/storage-drive.md), creating the file if it doesn't exist and overwriting it if it does. Use this for non-text files such as images, PDFs, or archives.
+
+- **Action type:** `FileActionType.WriteBinaryContents`
+- **On AWS:** performs an S3 `PutObject` on the drive's bucket, decoding the supplied base64 data. If a `storageDriveTier` is given, the object is written directly into that S3 storage class.
+
+```typescript
+import { askFileWriteBinaryContents } from 'quidproquo-core';
+
+export function* askStoreAvatar(userId: string, base64Png: string) {
+  yield* askFileWriteBinaryContents('user-uploads', `avatars/${userId}.png`, {
+    base64Data: base64Png,
+    filename: `${userId}.png`,
+    mimetype: 'image/png',
+  });
+}
+```
+
+## Signature
+
+```typescript
+function* askFileWriteBinaryContents(
+  drive: string,
+  filepath: string,
+  data: QPQBinaryData,
+  storageDriveAdvancedWriteOptions?: StorageDriveAdvancedWriteOptions,
+): AskResponse<void>;
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `drive` | `string` | Name of the storage drive to write to — must match a drive declared with [defineStorageDrive](../../../config/core/storage-drive.md) (or one shared via its `owner` option). |
+| `filepath` | `string` | Destination path within the drive, forward-slash delimited. Parent "directories" are implicit — no need to create them. |
+| `data` | `QPQBinaryData` | The binary payload to write — see below. |
+| `storageDriveAdvancedWriteOptions` | `StorageDriveAdvancedWriteOptions` | Optional write options — see below. |
+
+### `QPQBinaryData`
+
+```typescript
+interface QPQBinaryData {
+  base64Data: string;
+  filename: string;
+  mimetype?: string;
+  contentDisposition?: string;
+}
+```
+
+### `StorageDriveAdvancedWriteOptions`
+
+| Property | Type | Default | Description |
+| --- | --- | --- | --- |
+| `storageDriveTier` | `StorageDriveTier` | `REGULAR` | The [storage tier](../../../config/core/storage-drive.md#storagedrivetier) to write the file into, e.g. write archives directly to `COLD_STORAGE` without waiting for a lifecycle transition. |
+
+## Returns
+
+`void` — the story resumes once the write has completed.
+
+## Errors
+
+| Error | Meaning |
+| --- | --- |
+| `FileWriteBinaryContentsErrorTypeEnum.AccessDenied` | The caller lacks permission to write to this drive (e.g. a foreign drive shared without write access). |
+| `FileWriteBinaryContentsErrorTypeEnum.DriveNotFound` | No storage drive with that name exists in the deployed config. |
+
+Errors thrown by actions can be caught with `askCatch` from quidproquo-core. It returns an `EitherActionResult` — `{ success: true, result }` on success, or `{ success: false, error }` on failure:
+
+```typescript
+const outcome = yield* askCatch(
+  askFileWriteBinaryContents('user-uploads', 'avatars/42.png', data),
+);
+
+if (outcome.success) {
+  // written
+} else {
+  // outcome.error.errorType / outcome.error.errorText
+}
+```
+
+## Notes
+
+- If the drive declares an `onEvent.create` handler in [defineStorageDrive](../../../config/core/storage-drive.md#file-events-onevent), that story is triggered by this write.
+
+## Related
+
+- [defineStorageDrive](../../../config/core/storage-drive.md) — declares the drive, its tiers, events, and encryption.
+- [askFileReadBinaryContents](./ask-file-read-binary-contents.md) — the read counterpart.
+- [askFileWriteTextContents](./ask-file-write-text-contents.md) — write a UTF-8 string instead of bytes.
+- [askFileGenerateTemporaryUploadSecureUrl](./ask-file-generate-temporary-upload-secure-url.md) — let a browser upload directly to the drive instead of routing bytes through your service.
+- [askCreateTextQpqBinaryData](../binary-data/ask-create-text-qpq-binary-data.md) — build the `QPQBinaryData` payload from a text string.
+- [askEventDocWriteAsset](../../features/event-doc/ask-event-doc-generate-asset-upload-url.md#askeventdocwriteasset) — wraps this to write a document asset server-side.

package/template/docusaurus/docs/actions/core/file/ask-file-write-object-json.md

@@ -0,0 +1,83 @@
+---
+title: askFileWriteObjectJson
+description: Serialize an object to JSON and write it to a file on a storage drive.
+---
+
+# askFileWriteObjectJson
+
+Serializes an object with `JSON.stringify` and writes it to a file on a [storage drive](../../../config/core/storage-drive.md), creating the file if it doesn't exist and overwriting it if it does. This is the write counterpart to [askFileReadObjectJson](./ask-file-read-object-json.md) — the serialize and write happen in a single action.
+
+- **Action type:** `FileActionType.WriteObjectJson`
+- **On AWS:** runs `JSON.stringify` on the object and performs an S3 `PutObject` on the drive's bucket. If a `storageDriveTier` is given, the object is written directly into that S3 storage class.
+
+```typescript
+import { askFileWriteObjectJson } from 'quidproquo-core';
+
+interface AppSettings {
+  theme: string;
+  featureFlags: string[];
+}
+
+export function* askSaveSettings(settings: AppSettings) {
+  yield* askFileWriteObjectJson('config', 'settings.json', settings);
+}
+```
+
+## Signature
+
+```typescript
+function* askFileWriteObjectJson<T extends object>(
+  drive: string,
+  filepath: string,
+  data: T,
+  storageDriveAdvancedWriteOptions?: StorageDriveAdvancedWriteOptions,
+): AskResponse<void>;
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `drive` | `string` | Name of the storage drive to write to — must match a drive declared with [defineStorageDrive](../../../config/core/storage-drive.md) (or one shared via its `owner` option). |
+| `filepath` | `string` | Destination path within the drive, forward-slash delimited. Parent "directories" are implicit — no need to create them. |
+| `data` | `T` | The object to serialize and write. It is stored as `JSON.stringify(data)`. |
+| `storageDriveAdvancedWriteOptions` | `StorageDriveAdvancedWriteOptions` | Optional write options — see below. |
+
+### `StorageDriveAdvancedWriteOptions`
+
+| Property | Type | Default | Description |
+| --- | --- | --- | --- |
+| `storageDriveTier` | `StorageDriveTier` | `REGULAR` | The [storage tier](../../../config/core/storage-drive.md#storagedrivetier) to write the file into, e.g. write archives directly to `COLD_STORAGE` without waiting for a lifecycle transition. |
+
+## Returns
+
+`void` — the story resumes once the write has completed.
+
+## Errors
+
+| Error | Meaning |
+| --- | --- |
+| `FileWriteObjectJsonErrorTypeEnum.AccessDenied` | The caller lacks permission to write to this drive (e.g. a foreign drive shared without write access). |
+| `FileWriteObjectJsonErrorTypeEnum.DriveNotFound` | No storage drive with that name exists in the deployed config. |
+
+Errors thrown by actions can be caught with `askCatch` from quidproquo-core. It returns an `EitherActionResult` — `{ success: true, result }` on success, or `{ success: false, error }` on failure:
+
+```typescript
+const outcome = yield* askCatch(askFileWriteObjectJson('config', 'settings.json', settings));
+
+if (outcome.success) {
+  // written
+} else {
+  // outcome.error.errorType / outcome.error.errorText
+}
+```
+
+## Notes
+
+- If the drive declares an `onEvent.create` handler in [defineStorageDrive](../../../config/core/storage-drive.md#file-events-onevent), that story is triggered by this write.
+
+## Related
+
+- [defineStorageDrive](../../../config/core/storage-drive.md) — declares the drive, its tiers, events, and encryption.
+- [askFileReadObjectJson](./ask-file-read-object-json.md) — the read counterpart (read + `JSON.parse`).
+- [askFileWriteTextContents](./ask-file-write-text-contents.md) — write a raw string without serializing.

package/template/docusaurus/docs/actions/core/file/ask-file-write-text-contents.md

@@ -0,0 +1,69 @@
+---
+title: askFileWriteTextContents
+description: Write a UTF-8 string to a file on a storage drive.
+---
+
+# askFileWriteTextContents
+
+Writes a string to a file on a [storage drive](../../../config/core/storage-drive.md), creating the file if it doesn't exist and overwriting it if it does.
+
+- **Action type:** `FileActionType.WriteTextContents`
+
+```typescript
+import { askFileWriteTextContents } from 'quidproquo-core';
+
+export function* askSaveReport(reportCsv: string) {
+  yield* askFileWriteTextContents('reports', 'exports/monthly.csv', reportCsv);
+}
+```
+
+## Signature
+
+```typescript
+function* askFileWriteTextContents(
+  drive: string,
+  filepath: string,
+  data: string,
+  storageDriveAdvancedWriteOptions?: StorageDriveAdvancedWriteOptions,
+): AskResponse<void>;
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `drive` | `string` | Name of the storage drive to write to — must match a drive declared with [defineStorageDrive](../../../config/core/storage-drive.md) (or one shared via its `owner` option). |
+| `filepath` | `string` | Destination path within the drive, forward-slash delimited. Parent "directories" are implicit — no need to create them. |
+| `data` | `string` | The text content to write. |
+| `storageDriveAdvancedWriteOptions` | `StorageDriveAdvancedWriteOptions` | Optional write options — see below. |
+
+### `StorageDriveAdvancedWriteOptions`
+
+| Property | Type | Default | Description |
+| --- | --- | --- | --- |
+| `storageDriveTier` | `StorageDriveTier` | `REGULAR` | The [storage tier](../../../config/core/storage-drive.md#storagedrivetier) to write the file into, e.g. write archives directly to `COLD_STORAGE` without waiting for a lifecycle transition. |
+
+## Returns
+
+`void` — the story resumes once the write has completed.
+
+## Errors
+
+| Error | Meaning |
+| --- | --- |
+| `FileWriteTextContentsErrorTypeEnum.AccessDenied` | The caller lacks permission to write to this drive (e.g. a foreign drive shared without write access). |
+| `FileWriteTextContentsErrorTypeEnum.DriveNotFound` | No storage drive with that name exists in the deployed config. |
+
+## Notes
+
+- If the drive declares an `onEvent.create` handler in [defineStorageDrive](../../../config/core/storage-drive.md#file-events-onevent), that story is triggered by this write.
+- Writes to a drive with `encryption: true` are encrypted at rest automatically — nothing extra is needed at the call site.
+
+## Related
+
+- [defineStorageDrive](../../../config/core/storage-drive.md) — declares the drive, its tiers, events, and encryption.
+- [askFileReadTextContents](./ask-file-read-text-contents.md) — the read counterpart.
+- [askFileWriteObjectJson](./ask-file-write-object-json.md) — `JSON.stringify` + write in one action.
+- [askFileWriteBinaryContents](./ask-file-write-binary-contents.md) — write raw bytes instead of text.
+- [askFileGenerateTemporaryUploadSecureUrl](./ask-file-generate-temporary-upload-secure-url.md) — let a browser upload directly to the drive instead of routing bytes through your service.
+- [askFileDelete](./ask-file-delete.md) — remove a file from the drive.

package/template/docusaurus/docs/actions/core/graph-database/_category_.json

@@ -0,0 +1,7 @@
+{
+  "label": "Graph Database",
+  "link": {
+    "type": "generated-index",
+    "description": "Run openCypher queries against a graph database defined with defineGraphDatabase."
+  }
+}