@miadi/tide 0.5.2 → 0.5.3

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.
Files changed (2) hide show
  1. package/README.md +111 -184
  2. package/package.json +2 -2
package/README.md CHANGED
@@ -1,227 +1,154 @@
1
1
  # `@miadi/tide`
2
2
 
3
- Typed client boundary between Miadi and the **ironsilk `tide`** runtime. The single place the web app talks to `tide` — replacing the per-route
4
- `exec("/home/jgi/anaconda3/bin/tide …")` calls.
3
+ Read and steer the agents working in your terminals, from TypeScript.
5
4
 
6
- Grounding, specs, issues and episodes behind this package are listed in `AGENTS.md` in the
7
- source repository.
5
+ In the Miadi stack, `@miadi/tide` is how a program sees and directs agents at work. It lists
6
+ the terminals on a machine, reads what the agent in a pane is doing, and sends that agent a
7
+ message when the caller is allowed to. It works with tmux and with
8
+ [herdr](https://github.com/ogulcancelik/herdr). Every send passes a steer gate first, so a
9
+ program cannot type into a pane unless a controller has been named for it. Miadi's operator
10
+ cockpit is built on this package.
8
11
 
9
- ## Runtime dependency — install `tide`
12
+ Works with:
10
13
 
11
- This package is a **client**; it does not bundle the runtime. The `tide` CLI is the
12
- console entry point of the **`ironsilk`** PyPI package (`[project.scripts]`
13
- `tide = tide_runtime.cli:main`). Install / upgrade it in the Python env the
14
- Next.js server can reach:
14
+ - `@miadi/tide-contract`: the schema this client and the tide runtime share.
15
+ - `@miadi/annotate-core`: marks an agent's reply before a review is sent back to its pane.
16
+ - the `tide` CLI from the `ironsilk` Python package: the runtime this client talks to.
17
+
18
+ ## Install
15
19
 
16
20
  ```bash
21
+ npm install @miadi/tide
17
22
  pip install -U ironsilk # provides the `tide` CLI (0.9.27+)
18
23
  tide --help # verify
19
24
  ```
20
25
 
21
- `@miadi/tide` resolves the binary via `TIDE_BIN` →
22
- `which tide` → legacy `/home/jgi/anaconda3/bin/tide`; set `TIDE_BIN` when `tide`
23
- is outside the server's `PATH`. The daemon socket is resolved separately via
24
- `TIDE_SOCKET` (see below).
26
+ The package ships TypeScript source (`src/index.ts`), so compile it with your bundler. In
27
+ Next.js, add `@miadi/tide` to `transpilePackages`.
25
28
 
26
29
  ## Verbs
27
30
 
28
31
  ```ts
29
32
  import { getContext, getTerminals, detect, peek, steerProposal, send, sendKeys, buildSendKeysPlan, pingDaemon, describeTransport, TideError } from "@miadi/tide"
30
33
 
31
- const snapshot = await getContext() // R2 live context (daemon socket → CLI fallback)
32
- const terminals = await getTerminals() // operator terminals inventory (CLI, read-only)
33
- const match = await detect({ pane: "56" })// R1 domain detection for a pane/cwd → match | null (CLI)
34
- const scroll = await peek("56", 80) // operator peek %56 (CLI)
35
- const proposal = await steerProposal("56", "continue from checkpoint") // (CLI)
36
- const sent = await send("56", "continue") // guarded --run, controller mode (CLI)
34
+ const snapshot = await getContext() // live context of every terminal (daemon socket → CLI fallback)
35
+ const terminals = await getTerminals() // operator terminals inventory (read-only)
36
+ const match = await detect({ pane: "56" })// domain detection for a pane or cwd → match | null
37
+ const scroll = await peek("56", 80) // last 80 lines of pane %56
38
+ const proposal = await steerProposal("56", "continue from checkpoint") // reviewed proposal, nothing sent
39
+ const sent = await send("56", "continue") // guarded send through the tide runtime
37
40
 
38
- // Direct, simple steer transport — `tmux send-keys` via execFile (no shell, no Python):
41
+ // Direct steer through `tmux send-keys` (no shell, no Python):
39
42
  const keyed = await sendKeys("56", "continue") // types text + Enter
40
- const noEnter = await sendKeys("56", "ls -la", { submit: false })// types text, leaves it unsubmitted
41
- const plan = buildSendKeysPlan("56", "ls -la", false) // pure dry-run plan (no execution)
43
+ const noEnter = await sendKeys("56", "ls -la", { submit: false })// types text, leaves it for a person to submit
44
+ const plan = buildSendKeysPlan("56", "ls -la", false) // the tmux argv that would run, nothing executed
42
45
 
43
46
  const up = await pingDaemon() // daemon liveness (ping → pong)
44
47
  const how = describeTransport() // { transport: "socket"|"cli", socketPath, socketAvailable }
45
48
  ```
46
49
 
47
- ### `sendKeys` — the operator cockpit's primary steer path
48
-
49
- `sendKeys(pane, message, { submit })` drives **`tmux send-keys` directly** through `execFile`
50
- with argument arrays (no shell, no escaping, no Python spawn, no reviewed-proposal artifact) —
51
- the simple, robust transport behind `POST /api/tide/steer`. `submit` (default `true`) controls
52
- the trailing Enter (`C-m`): set it `false` to type content into the pane and leave it on the
53
- prompt for a human to review and submit. `buildSendKeysPlan(...)` returns the exact `tmux` argv
54
- pair without executing — used for the cockpit's inline command preview. The tmux binary is
55
- resolved via `TIDE_TMUX_BIN` -> `tmux` on `PATH`.
56
-
57
- ### herdr transport — `multiplexer: "herdr"` (live-verified)
58
-
59
- `sendKeys(pane, message, { multiplexer: "herdr" })` dispatches to the herdr CLI transport
60
- (`src/herdr.ts`): `herdr pane send-text` types the text, `herdr pane send-keys … Enter` submits
61
- (`submit: false` skips it, same toggle as tmux). The result is the herdr variant of the
62
- `TideSendKeysResult` union from `@miadi/tide-contract` (`multiplexer: "herdr"`, herdr CLI argv).
63
- herdr pane ids (`"w1:p2"` as of herdr 0.7; legacy `"1-2"` accepted) are **session-scoped** —
64
- they reset on herdr restart, and a stale id fails loudly with `pane_not_found`. Pass `paneLabel`
65
- (set via `herdr pane rename`) and the client re-resolves label → current id via
66
- `herdr pane list` before **every** action; duplicate labels throw rather than guess. Additional
67
- verbs: `runInHerdrPane`, `readHerdrPane` (recent-unwrapped text), `renameHerdrPane` (sets the
68
- durable label), `waitForHerdrOutput` (typed `TideHerdrWaitOutputResult`),
69
- `waitForHerdrAgentStatus` (typed `TideHerdrAgentStatusEvent` — live hits print an event
70
- envelope), `listHerdrPanes/Workspaces/Tabs`, and `getHerdrInventory({ includeTabs? })` — the
71
- one-call snapshot (`TideHerdrInventory`: workspaces + panes, tabs on request) behind
72
- `GET /api/tide/herdr`, so cockpit routes stay thin. `peek(pane, lines, { multiplexer: "herdr" })`
73
- reads herdr scrollback through the stable peek verb. Pane-id segments are alphanumeric
74
- (`w2:pE` past `p9`). Binary resolution: `TIDE_HERDR_BIN` → `herdr` on `PATH`.
75
-
76
- > **Readiness: `live-verified`.** Smoked against a real herdr 0.7.4 instance
77
- > (2026-07-16) — inventory parsing, send-text/send-keys, pane run, read,
78
- > wait output (hit + timeout exit codes), agent-status, and label→id resolution — in
79
- > addition to the injected-runner tests in `test/herdr.test.ts`.
80
-
81
- #### Observer inventory + capability advertisement (live-verified)
82
-
83
- ```ts
84
- import { getHerdrSnapshot, describeHerdrCapabilities } from "@miadi/tide"
85
-
86
- const snap = await getHerdrSnapshot()
87
- // `herdr api snapshot` — the whole observer inventory in ONE socket round-trip
88
- // (socket method session.snapshot): workspaces, tabs, panes, detected agents,
89
- // the focus triple, and the server's version/protocol. Read-only, consistent
90
- // (no tearing across a workspace/tab/pane list stitch).
91
-
92
- const caps = await describeHerdrCapabilities()
93
- // `herdr api schema --json` — capability advertisement DERIVED from the live
94
- // schema document: { available, protocol, schema_version, methods[] } plus
95
- // deterministic boolean views (inventory, snapshot, labels, agents,
96
- // wait_output, wait_events, lifecycle_advertised). `lifecycle_authorized` is
97
- // constant false: the server ADVERTISING workspace.close does not authorize
98
- // this client to drive it — that flips only when the closure-receipts ladder
99
- // lands as code. Never throws: a failed probe returns { available: false,
100
- // reason } — safe for /api/tide/health.
101
- ```
102
-
103
- Live receipts (herdr 0.7.4, protocol 16, 2026-07-18): 85 advertised socket
104
- methods, all seven derived flags true, snapshot of 7 workspaces / 22 tabs / 44
105
- panes / 21 agents. That smoke also showed pane ids go **alphanumeric** past `p9`
106
- (`w2:pE`, `w7:pA`) — herdr's own schema types `pane_id` as a plain string — so the
107
- client id pattern accepts the family agreed with `@miadi/tide-contract` 0.2.3:
108
- `w[0-9A-Za-z]+:p[0-9A-Za-z]+` (the dashed legacy form stays digits-only).
109
-
110
- #### Steer gate — ACTIVE_CONTROLLER + TTY + live target
111
-
112
- Every steer **execution** (`sendKeys` tmux + herdr, `sendKeysViaHerdr`,
113
- `runInHerdrPane`) passes the 3-part gate ported from the Python runtime's
114
- `tide operator send --run` boundary (`src/steer-gate.ts`):
115
-
116
- 1. **live-resolved target** — the pane must appear in the CURRENT multiplexer
117
- inventory (`tmux list-panes -a` / `herdr pane list`; label resolution counts
118
- as live proof);
119
- 2. **ACTIVE_CONTROLLER posture** — `mode: controller` in
120
- `${MIADI_HOME|~/.miadi/navigator}/config.yml`, with the controller TTL lease
121
- applied on every read (an expired lease reads as observer, fail-closed);
122
- 3. **interactive local TTY** — or `TIDE_ALLOW_NON_INTERACTIVE_RUN=1` set by an
123
- approval-queue-fronted service after its own review.
124
-
125
- A refused steer throws `TideError` naming **every** failed check and never
126
- touches the multiplexer. Plan builders (`buildSendKeysPlan`,
127
- `buildHerdrSendKeysPlan`) stay ungated — dry-run is the covenant's default
128
- posture. `evaluateSteerGate`/`requireSteerGate`/`readNavigatorPosture` are
129
- exported for `/api/tide/health`-style surfaces. The `gate` option injects
130
- probes (tests, first-party wiring); it cannot disable the gate, and overrides
131
- are only accepted when branded by `trustSteerGateProbes()` — which is NOT on
132
- the package surface (direct module import only; the brand is a module-private
133
- non-enumerable Symbol, so JSON/request-derived gate options are structurally
134
- refused).
135
-
136
- Label hardening (same wave): resolution is NFC-normalized, label-only (the
137
- `title` fallback is gone), **duplicate labels are a hard refusal**, and
138
- `{ workspace: "w7" }` scopes resolution. Wrong-multiplexer dispatch fails
139
- loudly in both directions (a herdr-shaped id on the tmux path and vice versa).
140
-
141
- `getTerminals` and `detect` are the read-only surface behind `GET /api/tide/terminals`
142
- and `GET /api/tide/detect` — the typed half of operator-terminal triage and manual
143
- domain assignment. The write-back half (assign a pane to a domain)
144
- is deferred to the runtime + a guarded route.
145
-
146
- ## Transport status
147
-
148
- | Layer | Status |
149
- |---|---|
150
- | One-shot CLI (`tide … --format json`, `execFile` arg-arrays, no shell) | **implemented** |
151
- | Daemon + Unix-domain-socket transport (`miadi.tide.daemon.v2`) | **implemented** (`src/socket.ts`) |
152
- | herdr CLI transport (`src/herdr.ts`, `multiplexer: "herdr"`) | **live-verified** (herdr 0.7.4, live smoke + runner-mocked tests) |
153
- | Schema-first contract (`tide-api.schema.json` → generated types) | planned |
50
+ `sendKeys` is the primary steer path. It runs `tmux send-keys` through `execFile` with
51
+ argument arrays, so nothing is interpreted by a shell. `submit` (default `true`) controls the
52
+ trailing Enter. `buildSendKeysPlan` returns the exact command without running it, for a
53
+ preview.
154
54
 
155
- ### How transport selection works
55
+ `pingDaemon()` and `describeTransport()` tell a caller which transport is live and whether the
56
+ daemon answers, before it reads context or proposes a steer.
156
57
 
157
- `getContext()` is transport-aware:
58
+ ## The steer gate
158
59
 
159
- - **`auto`** (default): use the daemon socket if it is up; on absence *or* daemon error, fall
160
- back to the CLI. No Python spawn on the hot path when the daemon is running (~µs socket
161
- round-trip vs ~200–500 ms CLI spawn).
162
- - **`socket`**: daemon only — throws `TideDaemonError` if unavailable.
163
- - **`cli`**: force the CLI.
60
+ Every steer that executes (`sendKeys` on tmux or herdr, `sendKeysViaHerdr`, `runInHerdrPane`)
61
+ passes three checks, the same ones the Python runtime applies to `tide operator send --run`:
164
62
 
165
- `peek` / `steerProposal` / `send` are **CLI-only**: the daemon exposes `get_context` / `ping` /
166
- `detect`, not the operator mutation verbs. `sendKeys` is independent of both — it talks to `tmux` directly. They join the socket path when the runtime adds those
167
- actions — verb signatures are the stable surface; only the transport underneath changes.
63
+ 1. **Live target.** The pane is in the current multiplexer inventory (`tmux list-panes -a` or
64
+ `herdr pane list`).
65
+ 2. **Controller posture.** `${MIADI_HOME:-~/.miadi/navigator}/config.yml` says
66
+ `mode: controller`, and its lease has not expired. An expired lease reads as observer.
67
+ 3. **Interactive terminal.** stdin is a TTY, or `TIDE_ALLOW_NON_INTERACTIVE_RUN=1` is set by a
68
+ service that has reviewed the request itself.
168
69
 
169
- ### Wire protocol (mirrors `tide_runtime/daemon.py`)
70
+ A refused steer throws `TideError` naming every failed check and never touches the
71
+ multiplexer. Plan builders (`buildSendKeysPlan`, `buildHerdrSendKeysPlan`) are not gated.
170
72
 
171
- Newline-delimited JSON over a Unix socket. Request
172
- `{contract_version:"miadi.tide.daemon.v2", request_id, action, payload}` →
173
- `{contract_version, request_id, ok:true, data}` (or `ok:false, error:{code,message,retryable}}`).
73
+ `evaluateSteerGate`, `requireSteerGate` and `readNavigatorPosture` expose the gate for health
74
+ checks. A server route that has already authenticated a person can pass
75
+ `humanConsentSteerGate("<route and gate name>")` as the `gate` option: posture and terminal then
76
+ count as satisfied, and the live-target check still applies. No other gate option is accepted
77
+ from outside the package, so options built from JSON or a request cannot bypass the gate.
174
78
 
175
- ### Socket path resolution
79
+ ## herdr
176
80
 
177
- `TIDE_SOCKET` (explicit) → `${MIADI_HOME || ~/.miadi/navigator}/daemon.sock`
178
- (mirrors the runtime's `get_config_dir()`). Binary resolution for the CLI fallback:
179
- `TIDE_BIN` → `which tide` → legacy `/home/jgi/anaconda3/bin/tide`.
81
+ `sendKeys(pane, message, { multiplexer: "herdr" })` types with `herdr pane send-text` and
82
+ submits with `herdr pane send-keys … Enter`. `peek(pane, lines, { multiplexer: "herdr" })`
83
+ reads herdr scrollback.
180
84
 
181
- ## Operator-cockpit surface
85
+ herdr pane ids (`w1:p2`, alphanumeric past `p9` as in `w2:pE`; legacy `1-2` accepted) reset
86
+ when herdr restarts, and a stale id fails with `pane_not_found`. Name a pane with
87
+ `renameHerdrPane` and pass `paneLabel`: the client resolves the label to the current id
88
+ before every action. Labels are compared after NFC normalization, a duplicate label is refused
89
+ rather than guessed, and `{ workspace: "w7" }` limits the search to one workspace. Sending a
90
+ herdr id down the tmux path, or the reverse, fails.
182
91
 
183
- `describeTransport()` + `pingDaemon()` back the shipped `GET /api/tide/health` route, so a
184
- Hermes/Ava/Miadi session can see *which transport is live and whether the daemon is answering*
185
- before it reads context or proposes a steer. The cockpit routes (`steer`, `peek`, `detect`,
186
- `terminals`) are still tmux-only; herdr reachability from `/api/tide/*` is not wired yet.
92
+ Other herdr verbs:
187
93
 
188
- ### Annotate surface — `/api/tide/annotate/{resolve,mark,deliver}` (2026-09-12)
94
+ | verb | returns |
95
+ |---|---|
96
+ | `runInHerdrPane`, `readHerdrPane`, `renameHerdrPane` | run a command, read recent text, set a label |
97
+ | `waitForHerdrOutput`, `waitForHerdrAgentStatus` | wait for output or an agent status change |
98
+ | `listHerdrPanes`, `listHerdrWorkspaces`, `listHerdrTabs` | inventory lists |
99
+ | `getHerdrInventory({ includeTabs? })` | workspaces and panes in one call |
100
+ | `getHerdrSnapshot()` | the whole inventory in one socket round trip: workspaces, tabs, panes, agents, focus, server version |
101
+ | `describeHerdrCapabilities()` | what the running herdr advertises, derived from its schema. Never throws: a failed probe returns `{ available: false, reason }` |
189
102
 
190
- The web leg of the plannotator review loop that `tan <pane>` runs in a terminal. Verbs:
191
- `fetchReply(pane, {pick, host})`, `listBlocks(doc)`, `mark(doc, {block | quote, text, kind})`,
192
- `exportReview(doc)`, `deliver(pane, doc, {submit})`. An adapter over
193
- `/opt/gaia/linux_migration/11-plannotator-tmux-review.sh` and a headless
194
- `plannotator-tui` — no resolution or delivery logic of its own, so the two clients cannot drift.
195
- Marks land in plannotator's store keyed by the vessel document, so a review begun in the browser
196
- can be finished in the terminal TUI and the other way round. A block mark is always a comment;
197
- `looks_good` / `delete` need a quote (plannotator-tui 0.6.0). tmux only.
103
+ `describeHerdrCapabilities()` reports `lifecycle_authorized: false` even when herdr advertises
104
+ `workspace.close`: this client does not close workspaces. Tested against herdr 0.7.4.
198
105
 
199
- A vessel remembers the pane it was fetched
200
- from (`source.json`) and `deliver` refuses any other pane, or a document with no source identity;
201
- every mark made here carries `author` (a stable principal id) and `author_name` — required in
202
- `mark()`, derived from a tailnet identity by the route when there is one — while marks made
203
- earlier or in the TUI stay unattributed. Gates: `resolve` and `mark` are writer-tier
204
- (`requireMiadiAuth({ write: true })`, as `/api/tide/peek`); `deliver` additionally needs the writer
205
- token or a tailnet identity, as `/api/tide/steer`, and answers a pane-guard refusal as `held`, not
206
- an error. Proven in `test/annotate-deliver.test.ts`.
106
+ ## Transports
207
107
 
208
- Resolution: `PLANNOTATOR_TMUX_REVIEW_SCRIPT` → the gaia path above; `PLANNOTATOR_TUI_BIN` →
209
- `which plannotator-tui` → `~/.cargo/bin/plannotator-tui` (the Next server's PATH lacks cargo's
210
- bin); `PLANNOTATOR_TMUX_REVIEW_DIR` is the script's own vessel root, web runs sit under `web/`.
108
+ | transport | used by |
109
+ |---|---|
110
+ | daemon Unix socket (`miadi.tide.daemon.v2`) | `getContext` when the daemon is up |
111
+ | `tide` CLI (`tide … --format json`, `execFile`, no shell) | `getContext` fallback, `getTerminals`, `detect`, `peek`, `steerProposal`, `send` |
112
+ | tmux directly | `sendKeys` |
113
+ | herdr CLI | the herdr verbs and `multiplexer: "herdr"` |
211
114
 
212
- ## Tests
115
+ `getContext({ transport })` accepts `auto` (default: socket, falling back to the CLI on
116
+ absence or error), `socket` (throws `TideDaemonError` when unavailable) or `cli`. The socket
117
+ answers in microseconds where a CLI spawn costs 200–500 ms. Verb signatures stay the same when
118
+ a verb moves to another transport.
213
119
 
214
- ```bash
215
- cd packages/tide && npm test
216
- ```
120
+ The daemon speaks newline-delimited JSON. Request
121
+ `{contract_version:"miadi.tide.daemon.v2", request_id, action, payload}`, reply
122
+ `{contract_version, request_id, ok:true, data}` or `{…, ok:false, error:{code,message,retryable}}`.
217
123
 
218
- Compiles `src` + `test` to `/tmp/miadi-tide-test` (CJS) and runs `node --test`. The suite proves
219
- socket selection and CLI fallback with a **fake Unix-socket daemon** and a **fake `tide` binary** —
220
- no live daemon, no live `tide` required.
124
+ ## Annotating a reply
221
125
 
222
- ## App wiring (current)
126
+ The web half of the plannotator review loop that `tan <pane>` runs in a terminal:
223
127
 
224
- Resolved as **source** via a `tsconfig.json` path alias
225
- (`"@miadi/tide": ["./packages/tide/src/index.ts"]`) — same pattern as `@miadi/a2a-contracts`,
226
- no `pnpm install`, no lockfile change. Switch to a `workspace:*` dependency + `dist/` build when a
227
- real build step is introduced.
128
+ | verb | does |
129
+ |---|---|
130
+ | `fetchReply(pane, { pick, host })` | copy the agent's last reply from a pane into a review document |
131
+ | `listBlocks(doc)` | the document's blocks |
132
+ | `mark(doc, { block \| quote, text, kind, author, author_name })` | add a signed mark |
133
+ | `exportReview(doc)` | the review as text |
134
+ | `deliver(pane, doc, { submit })` | send the review back to the pane it came from |
135
+
136
+ The package holds no review logic of its own. It drives the review script and a headless
137
+ `plannotator-tui`, so a review begun in the browser can be finished in the terminal and the
138
+ other way round. A document remembers the pane it was fetched from, and `deliver` refuses any
139
+ other pane. A block mark is always a comment. `looks_good` and `delete` need a quote.
140
+
141
+ ## Configuration
142
+
143
+ | variable | default | used for |
144
+ |---|---|---|
145
+ | `TIDE_BIN` | `which tide`, then `/home/jgi/anaconda3/bin/tide` | the `tide` CLI |
146
+ | `TIDE_SOCKET` | `${MIADI_HOME:-~/.miadi/navigator}/daemon.sock` | the daemon socket |
147
+ | `MIADI_HOME` | `~/.miadi/navigator` | socket and `config.yml` (controller posture) |
148
+ | `TIDE_TMUX_BIN` | `tmux` on `PATH` | `sendKeys` |
149
+ | `TIDE_HERDR_BIN` | `herdr` on `PATH` | the herdr verbs |
150
+ | `TIDE_ALLOW_NON_INTERACTIVE_RUN` | unset | `1` lets a reviewed service pass the terminal check |
151
+ | `PLANNOTATOR_TMUX_REVIEW_SCRIPT` | `/opt/gaia/linux_migration/11-plannotator-tmux-review.sh` | the review script |
152
+ | `PLANNOTATOR_TUI_BIN` | `which plannotator-tui`, then `~/.cargo/bin/plannotator-tui` | the headless annotator |
153
+ | `PLANNOTATOR_TMUX_REVIEW_DIR` | `${XDG_STATE_HOME:-~/.local/state}/plannotator-tmux-review` | review documents (web runs under `web/`) |
154
+ | `PLANNOTATOR_STORE_DIR` | `~/.plannotator/clients/plannotator-tui/annotations` | plannotator's mark records |
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@miadi/tide",
3
- "version": "0.5.2",
3
+ "version": "0.5.3",
4
4
  "description": "Typed client boundary for the ironsilk `tide` runtime. Daemon Unix-socket transport with CLI fallback.",
5
5
  "publishConfig": {
6
6
  "access": "public"
@@ -15,7 +15,7 @@
15
15
  "src"
16
16
  ],
17
17
  "dependencies": {
18
- "@miadi/annotate-core": "^0.1.0",
18
+ "@miadi/annotate-core": "^0.1.1",
19
19
  "@miadi/tide-contract": "0.3.0"
20
20
  },
21
21
  "keywords": [