@cratis/pi 0.0.1

package/skills/cratis-arc-react-page/references/dialogs.md

@@ -0,0 +1,238 @@
+# Dialogs reference
+
+The Cratis dialog wrappers own command execution, validation timing, busy
+state, and footer buttons. Never import `Dialog` from `primereact/dialog`.
+
+The **components** live in `@cratis/components`; the **hooks, enums, and
+context** live in `@cratis/arc.react/dialogs`. `@cratis/components` exports no
+dialog hooks at all.
+
+```tsx
+import { CommandDialog } from '@cratis/components/CommandDialog';
+import { BusyIndicatorDialog, ConfirmationDialog, Dialog } from '@cratis/components/Dialogs';
+import { DialogInitialFocus } from '@cratis/components/Dialogs';
+import { InputTextField } from '@cratis/components/CommandForm';
+import {
+    DialogButtons, DialogComponents, DialogResult, useDialog, useDialogContext,
+} from '@cratis/arc.react/dialogs';
+```
+
+## Choose the dialog
+
+- Confirm runs a command → `CommandDialog`.
+- Confirm returns data without a command → `Dialog`.
+- Asking the user to confirm, or blocking them while work runs → do not build a
+  dialog; raise the host-registered one by hook.
+- A command split over named steps → `StepperCommandDialog`, see the
+  **cratis-components-stepper-command-dialog** skill.
+
+## Opening a dialog
+
+```tsx
+const [AccountDialog, showAccountDialog] = useDialog(CreateAccountDialog);
+// render <AccountDialog /> once in the tree
+const [result, response] = await showAccountDialog({ accountId });
+if (result === DialogResult.Ok) { /* ... */ }
+```
+
+`useDialog<TResponse, TInput>(Component)` returns a three-element tuple — the
+wrapper component, the show function, and the dialog context. Destructuring the
+first two is the normal case. `showDialog(input?)` resolves to
+`[DialogResult, TResponse?]` when the dialog closes.
+
+Inside the dialog, prefer plain typed props for input and take `closeDialog`
+from `useDialogContext<TResponse>()`:
+
+```tsx
+const { request, closeDialog } = useDialogContext<AccountCreated>();
+closeDialog(DialogResult.Ok, response);
+```
+
+Dialogs that destructure `closeDialog` from a props interface extending
+`DialogProps` remain valid.
+
+## The enums
+
+```ts
+enum DialogResult { None = 0, Yes = 1, No = 2, Ok = 3, Cancelled = 4 }
+enum DialogButtons { Ok = 1, OkCancel = 2, YesNo = 3, YesNoCancel = 4 }
+enum DialogInitialFocus { Confirm = 1, Cancel = 2, Content = 3 }
+```
+
+Branch on the enum member, never on button text.
+
+## `CommandDialog`
+
+`CommandDialog` combines the command form and the dialog: its props are every
+`Dialog` prop except `children`, plus every command-form prop except `children`
+and `onBeforeExecute`, plus its own `onBeforeExecute` and `children`. `buttons`
+defaults to `DialogButtons.OkCancel`.
+
+The most-used props:
+
+| Prop | Purpose |
+| --- | --- |
+| `command` | the generated command class |
+| `title` | dialog header |
+| `okLabel` / `cancelLabel` | button labels (`'Ok'` / `'Cancel'` by default) |
+| `initialValues` | synchronous baseline; also the change-tracking baseline |
+| `currentValues` | reactive overlay for late-loading values |
+| `isValid` | extra validity gate on top of field validation |
+| `onBeforeExecute` | transform values just before execute |
+| `onSuccess` | receives the typed command response after a successful execute |
+| `onValidationFailure` / `onFailed` | failure branches |
+| `onConfirm` / `onCancel` / `onClose` | close gates |
+| `validateOn` | `'blur' \| 'change' \| 'both'` |
+| `validateOnInit` | validate on mount so pre-filled invalid values show immediately |
+| `initialFocus` | which control receives focus when the dialog opens |
+| `dismissable` | X, Escape, and backdrop dismissal |
+| `pt` / `ptOptions` / `unstyled` | PrimeReact pass-through |
+
+`CommandDialog.Column` exists for multi-column layouts:
+
+```tsx
+<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '1.5rem' }}>
+    <CommandDialog.Column>
+        <InputTextField value={(c: UpdateProfile) => c.firstName} title='First name' />
+    </CommandDialog.Column>
+    <CommandDialog.Column>
+        <InputTextField value={(c: UpdateProfile) => c.lastName} title='Last name' />
+    </CommandDialog.Column>
+</div>
+```
+
+### Execution flow
+
+On confirm, `CommandDialog` applies `onBeforeExecute`, sets busy, executes the
+command, and on failure calls `onValidationFailure(result.validationResults)`
+or `onFailed(result)` and **keeps the dialog open**. On success it calls
+`onSuccess(result.response)` and then the close gate.
+
+### `initialValues` versus `onBeforeExecute`
+
+Validation runs against the pre-transform values, so a required value seeded in
+`onBeforeExecute` never makes the form valid and the submit button stays
+permanently disabled. Seed required values with `initialValues`; reserve
+`onBeforeExecute` for transforms that do not affect validity, such as a
+generated id.
+
+`onBeforeExecute` is a **transformer** — it receives the current values and must
+return them (a `TCommand` or a `Promise<TCommand>`). Returning `undefined`
+keeps the current values and logs a console warning rather than executing with
+undefined values, but it is still a bug: always return the values.
+
+### `onSuccess` versus `onConfirm`
+
+`onSuccess(response)` fires only after the command succeeds and carries the
+typed response — use it to close, refresh, or toast. `onConfirm()` receives no
+command result; it is a close gate that must return exactly `true` to let the
+wrapper close. Do not use `onConfirm` as a result handler.
+
+## `CommandForm` fields
+
+Every user-entered command value must be bound through a `CommandForm` field
+from `@cratis/components/CommandForm` (also published as
+`@cratis/components/CommandForm/fields`, the same module). A raw PrimeReact
+control bypasses the field wrapper, so validation never re-runs and the submit
+button stays disabled.
+
+The full catalog: `InputTextField`, `PasswordField`, `NumberField`,
+`TextAreaField`, `CheckboxField`, `ToggleSwitchField`, `DropdownField`,
+`MultiSelectField`, `RadioButtonField`, `RadioGroupField`, `CalendarField`,
+`ChipsField`, `ColorPickerField`, `SliderField`, `RatingField`.
+
+Shared field props: `value` (the accessor), `title` (the **label**),
+`description`, `required`, `icon` (a `React.ReactElement`), `initialValue`,
+`noInitialValue`, `populationKey`. `CheckboxField`, `ToggleSwitchField`,
+`RadioButtonField`, and `RadioGroupField` additionally take their own `label`.
+
+```tsx
+<InputTextField<CreateAccount> value={c => c.name} title='Account name' placeholder='Acme' />
+<NumberField<CreateAccount> value={c => c.limit} title='Limit' min={0} />
+<DropdownField<CreateAccount> value={c => c.status} title='Status' options={statuses} optionLabel='name' optionValue='id' />
+<CheckboxField<CreateAccount> value={c => c.isActive} label='Active' />
+<CalendarField<CreateAccount> value={c => c.opensOn} title='Opens on' showIcon />
+```
+
+`DropdownField` requires `options`, `optionLabel`, and `optionValue`;
+`RadioGroupField` requires all three too and takes `layout='horizontal' | 'vertical'`;
+`RadioButtonField` is one component per option and requires `buttonValue`.
+
+The `value` accessor doubles as the binding and as type-checked field
+selection — renaming a command property produces a compile error at every
+binding.
+
+`AutoCommandForm` renders a field per command property from the generated
+property descriptors, with `exclude` for the ones you do not want:
+
+```tsx
+<AutoCommandForm command={RegisterInvoice} exclude={['invoiceId']} />
+```
+
+## `Dialog` — data without a command
+
+```tsx
+export const RenameDialog = () => {
+    const { closeDialog } = useDialogContext<{ name: string }>();
+    const [name, setName] = useState('');
+
+    return (
+        <Dialog
+            title='Rename'
+            width='32rem'
+            isValid={name.trim().length > 0}
+            onConfirm={() => closeDialog(DialogResult.Ok, { name })}
+            onCancel={() => closeDialog(DialogResult.Cancelled)}>
+            <InputText value={name} onChange={event => setName(event.target.value)} autoFocus />
+        </Dialog>
+    );
+};
+```
+
+`DialogProps` defaults: `visible` `true`, `buttons` `DialogButtons.OkCancel`,
+`initialFocus` `DialogInitialFocus.Confirm`, `width` `'450px'`, `isValid` true
+when omitted, `isBusy` `false`, `okLabel` `'Ok'`, `cancelLabel` `'Cancel'`,
+`yesLabel` `'Yes'`, `noLabel` `'No'`, `closeAriaLabel` `'Close'`.
+
+Two behaviors worth knowing:
+
+- `resizable` is accepted for compatibility but has **no effect** — the
+  PrimeReact 11 headless dialog has no resize.
+- Passing a custom node to `buttons` instead of a `DialogButtons` member
+  removes the header close control, disables Escape, and means `onClose`,
+  `onCancel`, and `onConfirm` are never invoked. Close through
+  `useDialogContext().closeDialog(...)`, or set `dismissable` explicitly.
+
+### Keeping the dialog open on failure
+
+`onConfirm` must return exactly `true` to close. Returning `false` keeps it
+open. Annotate the handler as `Promise<boolean>` so TypeScript does not infer
+`Promise<false | void>`:
+
+```tsx
+const handleConfirm = async (): Promise<boolean> => {
+    const result = await command.execute();
+    return result.isSuccess;
+};
+```
+
+`onClose(result)` is the combined handler for both outcomes and closes unless it
+returns `false`.
+
+### Initial focus
+
+`DialogInitialFocus.Confirm` is the default and *arms* the confirm button — a
+browser fires `click` from the `keydown` of Enter, so a held Enter confirms.
+For a destructive dialog use `DialogInitialFocus.Cancel`, which focuses the
+least destructive action and degrades to `Content` when the button set has
+nothing to dismiss with. `DialogInitialFocus.Content` focuses the title so
+nothing is armed. There is deliberately no "focus nothing" option — a modal
+must move focus into itself.
+
+## Host-registered confirmation and busy indicators
+
+`ConfirmationDialog` takes no props at all; it reads its title, message, and
+buttons from the dialog request. `BusyIndicatorDialog` takes the busy-indicator
+request. Register both once at the app root through `DialogComponents` and
+raise them by hook — see the skill's step 5. From a view model, use the
+injectable `IDialogs` abstraction instead of the hooks.

package/skills/cratis-arc-react-page/references/mvvm.md

@@ -0,0 +1,150 @@
+# MVVM reference
+
+The Arc MVVM layer keeps page logic in plain TypeScript classes and leaves the
+component declarative. `@cratis/arc.react.mvvm` builds on tsyringe for
+injection and MobX for reactivity.
+
+## When to use it
+
+Extract a view model as soon as a component has three or more `useState` calls,
+any state-synchronizing `useEffect`, derived values computed from other state,
+or state shared by prop drilling. A trivial presentational leaf needs none.
+
+## Setup
+
+The app needs `experimentalDecorators`, `emitDecoratorMetadata`, and
+`reflect-metadata` wired for the decorators to work.
+
+Wrap the app (or the route root) in the MVVM provider — it configures MobX and
+registers the shared bindings:
+
+```tsx
+import { MVVM } from '@cratis/arc.react.mvvm';
+
+<MVVM>
+    <App />
+</MVVM>
+```
+
+`<Arc>` does **not** include `<MVVM>`; both are needed.
+
+The provider's initialization registers `IMessenger`, `INavigation`,
+`IIdentityProvider`, and `ILocalStorage` into the root container.
+
+## The view model
+
+```ts
+import { injectable } from 'tsyringe';
+
+@injectable()
+export class AccountsViewModel {
+    selected: AccountSummary | null = null;
+
+    select(account: AccountSummary | null) { this.selected = account; }
+
+    get selectedName() { return this.selected?.name ?? ''; }
+}
+```
+
+- `@injectable()` is tsyringe's — there is no Cratis-specific view-model
+  decorator.
+- **`withViewModel` applies `makeAutoObservable` for you.** Do not call it in
+  the constructor and do not decorate plain assignments.
+- Derived state is a getter, not a `useMemo` in the component.
+- No JSX, no React state, no React hooks in a view model — inject the
+  abstraction instead.
+- A non-trivial view model must be constructible directly in a spec.
+
+## `withViewModel`
+
+```tsx
+import { withViewModel } from '@cratis/arc.react.mvvm';
+
+export const AccountsPage = withViewModel(AccountsViewModel, ({ viewModel, props }) => (
+    /* read viewModel state inside JSX; call viewModel methods from handlers */
+));
+```
+
+The render function receives `{ viewModel, props }`. Behind the scenes
+`withViewModel` creates a child DI container per component instance, registers
+the props, route parameters, query parameters, dialog context, command scope,
+query scope, messenger, and dialogs into it, resolves the view model, makes it
+observable, and renders the body inside an observer.
+
+Any query, observable query, or command resolved through that container is
+automatically configured with the microservice, API base path, and origin from
+the Arc context.
+
+### Dereference late
+
+Read `viewModel.property` **inside** JSX. Destructuring an observable at the top
+of the component body captures the value and stops tracking changes.
+
+`useCallback` and `useMemo` are unnecessary inside a `withViewModel` component —
+the render is already wrapped in an observer, and their presence signals state
+that belongs in the view model.
+
+When passing an observable array into a raw non-observer child, materialize it
+with `.slice()`. In practice prefer the observable data table, which handles
+reactivity internally.
+
+## Props, route parameters, and query parameters
+
+| Need | Mechanism |
+| --- | --- |
+| Props set once at mount | `@props readonly componentProps: TProps` |
+| Props that change after mount | implement `IHandleProps<TProps>` → `handleProps(props)` |
+| Route parameters | `@params readonly routeParams: RouteParams` |
+| Route parameters that change | implement `IHandleParams<T>` → `handleParams(params)` |
+| Query-string parameters | `@queryParams readonly query: QueryParams` |
+| Query parameters that change | implement `IHandleQueryParams<T>` → `handleQueryParams(queryParams)` |
+
+The handler method names are `handleProps`, `handleParams`, and
+`handleQueryParams`. Each is invoked on mount and again whenever the incoming
+value actually differs.
+
+```ts
+@injectable()
+export class AccountDetailsViewModel implements IHandleProps<AccountDetailsProps> {
+    account: AccountSummary | null = null;
+
+    handleProps(props: AccountDetailsProps) { this.account = props.account; }
+}
+```
+
+Route and query parameters arrive from the URL as strings. `withViewModel`
+deserializes them into the class you declared on the decorated constructor
+parameter, so declare a real parameter class with typed properties rather than
+an inline object type — that class is what drives the conversion.
+
+## Injectable abstractions
+
+Never touch a browser or React global from a view model.
+
+| Abstraction | Package | Replaces |
+| --- | --- | --- |
+| `IMessenger` | `@cratis/arc.react.mvvm/messaging` | cross-component selection, not React context |
+| `IDialogs` | `@cratis/arc.react.mvvm/dialogs` | imperative confirmation and busy dialogs |
+| `IIdentityProvider` | `@cratis/arc/identity` | identity, instead of the `useIdentity` hook |
+| `INavigation`, `ILocalStorage` | `@cratis/arc.react.mvvm/browser` | URL navigation, `localStorage` |
+| `IViewModelDetached` | `@cratis/arc.react.mvvm` | teardown via `detached()` |
+
+`IDialogs` exposes `show(input)`, `showConfirmation(title, message, buttons)`
+returning a `DialogResult`, and `showBusyIndicator(title, message)` returning a
+busy indicator with a `close()` method. For a user-triggered dialog that opens
+a React command dialog, use `useDialog` in the component instead.
+
+`IViewModelDetached.detached()` runs on unmount — unsubscribe subscriptions and
+clear timers there.
+
+## `observer`
+
+Import `observer` from `@cratis/arc.react.mvvm`, never directly from
+`mobx-react`. The package re-exports it deliberately so the observer boundary
+stays a single, swappable dependency.
+
+## Testing
+
+A view model is a plain class: construct it directly, pass small typed fakes or
+stubs for its dependencies, and assert on state transitions and getters. See the
+**cratis-application-react-specifications** skill.

package/skills/cratis-arc-react-page/references/queries-and-commands.md

@@ -0,0 +1,200 @@
+# Queries and commands reference
+
+A Debug build generates one typed proxy class per query and per command. The
+proxy exposes static React hooks; the page calls those. Never edit a generated
+file — fix the C# source and rebuild.
+
+## Query proxy hooks
+
+| Static | When |
+| --- | --- |
+| `<Query>.use(args?, sorting?)` | snapshot query, re-renders on change |
+| `<Query>.useWithPaging(pageSize, args?, sorting?)` | server-side paging |
+| `<Query>.useSuspense(...)` | suspense-aware; must render inside a query boundary |
+| `<Query>.useSuspenseWithPaging(pageSize, ...)` | suspense plus paging |
+| `<ObservableQuery>.use(...)` | live query pushed over the query hub |
+| `<ObservableQuery>.useChangeStream(args?, getKey?, sorting?)` | item-level deltas |
+| `<Query>.when(condition).use(args)` | conditional — never wrap a hook in `if` |
+
+### Return tuples
+
+These shapes are load-bearing. The observable variants have **no perform
+function**:
+
+| Hook | Returns |
+| --- | --- |
+| `useQuery(query, args?, sorting?, isEnabled?)` | `[result, perform, setSorting]` |
+| `useQueryWithPaging(query, paging, args?, sorting?, isEnabled?)` | `[result, perform, setSorting, setPage, setPageSize]` |
+| `useSuspenseQuery(...)` | `[result, perform, setSorting]` |
+| `useSuspenseQueryWithPaging(...)` | `[result, perform, setSorting, setPage, setPageSize]` |
+| `useObservableQuery(query, args?, sorting?, isEnabled?)` | `[result, setSorting]` |
+| `useObservableQueryWithPaging(query, paging, ...)` | `[result, setSorting, setPage, setPageSize]` |
+| `useChangeStream(query, args?, getKey?, sorting?, isEnabled?)` | `ChangeSet<T>` |
+
+`setSorting`, `setPage`, and `setPageSize` all return a promise.
+
+The underlying hooks live in `@cratis/arc.react/queries` if you need them
+directly.
+
+### The result object
+
+Every query hook returns a result carrying:
+
+`data`, `paging`, `isSuccess`, `isAuthorized`, `isValid`, `isPerforming`,
+`isReady`, `hasData`, `hasExceptions`, `validationResults`,
+`exceptionMessages`, `exceptionStackTrace`, `changeSet`.
+
+Guard rendering with `hasData` rather than checking `data.length` — a
+conditional query that has not fired returns an empty result with
+`hasData: false`.
+
+### Paging
+
+```ts
+class Paging { constructor(page?: number, pageSize?: number); page: number; pageSize: number; get hasPaging(): boolean }
+class Sorting { constructor(field: string, direction: SortDirection); get hasSorting(): boolean }
+enum SortDirection { unspecified = 0, ascending = 1, descending = 2 }
+```
+
+The result's paging block is a different shape from the request's — note
+`size`, not `pageSize`:
+
+```ts
+class PagingInfo { page: number; size: number; totalItems: number; totalPages: number }
+```
+
+`page` is zero-based. `totalItems` is the total count. A read model returning a
+queryable gets server-side paging and sorting for free — use it whenever a list
+can grow. Over the wire the parameters are `page`, `pageSize`, `sortBy`, and
+`sortDirection`.
+
+### Change streams
+
+```ts
+class ChangeSet<T> { readonly added: T[]; readonly replaced: T[]; readonly removed: T[] }
+```
+
+Without `getKey` removed items cannot be identified and everything arrives as
+`added`; `getKey` is what enables `replaced` and `removed` detection. Change
+streams exist only on observable queries returning a collection.
+
+### Suspense
+
+`useSuspense` throws a promise while loading and a typed error on failure, so it
+must render inside `QueryBoundary` (`@cratis/arc.react/queries`), which combines
+suspense with the query error boundary. It re-suspends on refresh, sorting, and
+paging changes because the cache entry is cleared. In test teardown call
+`clearSuspenseQueryCache()` and `clearSuspenseObservableQueryCache()`.
+
+`QueryFailed` and `QueryUnauthorized` are the thrown error types; `QueryFailed`
+carries `exceptionMessages` for logging.
+
+### Query scope
+
+`QueryScope` plus `useQueryScope()` aggregates one `isPerforming` flag across
+the queries rendered inside it. Members register automatically and scopes nest,
+with an inner scope reporting to the nearest outer one.
+
+## Observable query transport
+
+The `<Arc>` provider defaults `queryTransportMethod` to server-sent events;
+the library-level default without the provider is WebSocket. Both run through a
+multiplexed hub by default (`queryDirectMode` is `false`), so many observable
+queries share one connection. Server-sent-event hub connections are capped —
+raising `queryConnectionCount` above four warns, because HTTP/1.1 limits
+concurrent SSE streams.
+
+`observableQueryTransferMode` defaults to delta: the server sends a change set
+and the client reconstructs the collection from the previously cached result.
+Set it to full to receive every item as `added` on each push.
+
+Identical subscriptions share one connection through the query instance cache,
+which retains an unsubscribed entry briefly (30 seconds by default) so a
+remount does not re-subscribe. After login or logout call `reconnectQueries()`
+from the Arc context to force re-subscription with the new identity.
+
+## Command proxy
+
+```tsx
+const [command, setCommandValues, clearCommandValues] = RegisterAccount.use();
+command.name = 'Acme';                     // or setCommandValues({ name: 'Acme' })
+const result = await command.execute();
+```
+
+`use(initialValues?)` returns a three-element tuple. The instance also exposes
+`validate()`, `clear()`, `setInitialValues(values)`, `revertChanges()`, and
+`hasChanges`.
+
+### Read the result by the granular flag
+
+| Flag | Meaning | Response |
+| --- | --- | --- |
+| `isSuccess` | authorized, valid, and no exception | happy path |
+| `isAuthorized` | roles or policy rejected the call | redirect to login, or "not allowed" |
+| `isValid` | validation failed — `validationResults` carries the messages | render inline field errors |
+| `hasExceptions` | the handler threw — `exceptionMessages` carries diagnostics | generic error, and log it |
+
+The result also carries `correlationId`, `authorizationFailureReason`,
+`exceptionStackTrace`, and the typed `response`. Fluent callbacks
+`onSuccess`, `onFailed`, `onException`, `onUnauthorized`, and
+`onValidationFailure` each return the result for chaining.
+
+```tsx
+const result = await command.execute();
+if (!result.isAuthorized) { redirectToLogin(); return; }
+if (!result.isValid) { /* validationResults -> inline field errors */ return; }
+if (result.hasExceptions) { console.error(result.exceptionMessages); return; }
+```
+
+A validation result is:
+
+```ts
+class ValidationResult {
+    severity: ValidationResultSeverity;   // Unknown 0, Information 1, Warning 2, Error 3
+    message: string;
+    members: string[];                    // the properties the message applies to
+    state: unknown;
+    reason: ValidationResultReason;       // 'rule' by default
+    reasonDetail?: string;
+}
+```
+
+Render per-field errors from `members` and `message`. Never branch on the raw
+message text. `exceptionMessages` and `exceptionStackTrace` are for logging,
+never for users.
+
+`toastCommandResult(result, options)` from `@cratis/components/Notifications`
+collapses the whole branch into one call — mount a `<Toaster />` near the app
+root and it maps every flag to the right toast without showing stack traces. It
+returns `true` when the command succeeded:
+
+```tsx
+if (toastCommandResult(result, { successTitle: 'Account registered' })) refresh();
+```
+
+For ad-hoc notifications the imperative `toast.success/info/warn/error` each
+take an **options object**, not a bare string:
+`toast.info({ title: 'Saved', description: 'Your changes were saved.' })`.
+
+`CommandDialog` performs all of this itself — the flags matter most when
+executing a command outside a dialog.
+
+### Command scope
+
+`CommandScope` plus `useCommandScope()` (`@cratis/arc.react/commands`)
+aggregates change and execution state across several commands on one screen.
+Members register automatically, scopes nest, and the scope is injectable into a
+view model as `ICommandScope`. It exposes `hasChanges`, `isPerforming`,
+`hasValidationFailures`, `hasExceptions`, per-command and aggregated failures,
+`execute()` (which runs only the commands that have changes), and
+`revertChanges()`.
+
+## `<Arc>` configuration
+
+The top-level provider configures the microservice name, API base path, and
+query transport. Its props include `microservice`, `origin`, `basePath`,
+`apiBasePath`, `httpHeadersCallback` (merged into every request — bearer and
+tenant headers), `detailsType`, `queryTransportMethod`, `queryConnectionCount`,
+`queryDirectMode`, `observableQueryTransferMode`, and `queryCacheRetentionMs`.
+`QueryTransportMethod` and `ObservableQueryTransferMode` import from
+`@cratis/arc`; `Arc` imports from `@cratis/arc.react`.

package/skills/cratis-chronicle-cli-operations/LICENSE

@@ -0,0 +1,2 @@
+Copyright (c) Cratis. All rights reserved.
+Licensed under the MIT license. See LICENSE file in the project root for full license information.