@opetope/devtools 0.1.0

package/dist/integration.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Trusted attach, per `docs/devtools.md` §3.1: one call in the application composition root, and nothing else in the
+ * application knows this package exists.
+ *
+ * The application hands over the `ApplicationExecution` that `openApplication` returned and nothing else. Opening the
+ * observation port — and, under `mode: 'control'`, the write port — happens here, because `@opetope/runtime/internal`
+ * is a seam between library packages rather than a surface an application is meant to reach (D248). The earlier form
+ * that took ready sessions is replaced in every consumer by the same commit rather than kept beside this one (D35):
+ * a host that could still pass its own sessions would be a second way to own them.
+ *
+ * Feature `ui/models/data/repositories` must not import this module — it is the only surface that will ever hold a
+ * control authority, and source lint keeps it out of feature code. The npm export map is not the security boundary.
+ */
+import type { ApplicationExecution } from '@opetope/runtime/internal';
+import type { DevtoolsHandle } from './install.js';
+import type { DevtoolsMode } from './react/panel.js';
+import type { DevtoolsTheme } from './react/theme.js';
+import type { DevtoolsSessionOptions } from './session.js';
+type InstallDevtoolsOptions = Readonly<{
+    /** Where the drawer mounts. Defaults to a `div` appended to `document.body`, owned by this call. */
+    container?: HTMLElement;
+    /** The running application, exactly as `openApplication` returned it: both ports are keyed by its identity (§3.2). */
+    execution: ApplicationExecution;
+    /**
+     * `control` opens the write port beside the observation one; `inspect`, the default, leaves the panel read-only and
+     * never asks the runtime for an authority it would not use.
+     */
+    mode?: DevtoolsMode;
+    sessionOptions?: DevtoolsSessionOptions;
+    theme?: DevtoolsTheme;
+}>;
+/**
+ * Opens the ports, installs the panel and returns the detach. Both sessions belong to the returned handle: `close()`
+ * closes the observation session and, with it, every override the write session put in place.
+ *
+ * An execution already holds at most one live control session (D191), so a second install on the same one throws out
+ * of here — a failed install, not a panel that quietly came up read-only. Whatever this call has taken by then is
+ * given back before the throw leaves it (§7).
+ */
+declare function installDevtools(options: InstallDevtoolsOptions): DevtoolsHandle;
+export { installDevtools };
+export type { DevtoolsHandle, InstallDevtoolsOptions };

package/dist/integration.js

@@ -0,0 +1,2 @@
+import{createInspectionSession as t,createControlSession as r}from"@opetope/runtime/internal";import{installPanel as s}from"./install.js";function c(e){const o=t(e.execution);try{const n=e.mode==="control"?r(e.execution):void 0;return s({container:e.container,control:n,mode:e.mode,session:o,sessionOptions:e.sessionOptions,theme:e.theme})}catch(n){throw o.close(),n}}export{c as installDevtools};
+//# sourceMappingURL=integration.js.map

package/dist/integration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.js","sources":["../src/integration.ts"],"sourcesContent":["/**\n * Trusted attach, per `docs/devtools.md` §3.1: one call in the application composition root, and nothing else in the\n * application knows this package exists.\n *\n * The application hands over the `ApplicationExecution` that `openApplication` returned and nothing else. Opening the\n * observation port — and, under `mode: 'control'`, the write port — happens here, because `@opetope/runtime/internal`\n * is a seam between library packages rather than a surface an application is meant to reach (D248). The earlier form\n * that took ready sessions is replaced in every consumer by the same commit rather than kept beside this one (D35):\n * a host that could still pass its own sessions would be a second way to own them.\n *\n * Feature `ui/models/data/repositories` must not import this module — it is the only surface that will ever hold a\n * control authority, and source lint keeps it out of feature code. The npm export map is not the security boundary.\n */\n\nimport { createControlSession, createInspectionSession } from '@opetope/runtime/internal';\nimport type { ApplicationExecution } from '@opetope/runtime/internal';\n\nimport { installPanel } from './install';\nimport type { DevtoolsHandle } from './install';\nimport type { DevtoolsMode } from './react/panel';\nimport type { DevtoolsTheme } from './react/theme';\nimport type { DevtoolsSessionOptions } from './session';\n\ntype InstallDevtoolsOptions = Readonly<{\n  /** Where the drawer mounts. Defaults to a `div` appended to `document.body`, owned by this call. */\n  container?: HTMLElement;\n  /** The running application, exactly as `openApplication` returned it: both ports are keyed by its identity (§3.2). */\n  execution: ApplicationExecution;\n  /**\n   * `control` opens the write port beside the observation one; `inspect`, the default, leaves the panel read-only and\n   * never asks the runtime for an authority it would not use.\n   */\n  mode?: DevtoolsMode;\n  sessionOptions?: DevtoolsSessionOptions;\n  theme?: DevtoolsTheme;\n}>;\n\n/**\n * Opens the ports, installs the panel and returns the detach. Both sessions belong to the returned handle: `close()`\n * closes the observation session and, with it, every override the write session put in place.\n *\n * An execution already holds at most one live control session (D191), so a second install on the same one throws out\n * of here — a failed install, not a panel that quietly came up read-only. Whatever this call has taken by then is\n * given back before the throw leaves it (§7).\n */\nfunction installDevtools(options: InstallDevtoolsOptions): DevtoolsHandle {\n  const session = createInspectionSession(options.execution);\n\n  try {\n    const control = options.mode === 'control' ? createControlSession(options.execution) : undefined;\n\n    return installPanel({\n      container: options.container,\n      control,\n      mode: options.mode,\n      session,\n      sessionOptions: options.sessionOptions,\n      theme: options.theme,\n    });\n  } catch (error) {\n    // Closing twice is harmless — the connection closes the producer as well — and closing not at all leaks the slot.\n    session.close();\n\n    throw error;\n  }\n}\n\nexport { installDevtools };\nexport type { DevtoolsHandle, InstallDevtoolsOptions };\n"],"names":["installDevtools","options","session","createInspectionSession","control","createControlSession","installPanel","error"],"mappings":"0IA6CA,SAASA,EAAgBC,EAA+B,CACtD,MAAMC,EAAUC,EAAwBF,EAAQ,SAAS,EAEzD,GAAI,CACF,MAAMG,EAAUH,EAAQ,OAAS,UAAYI,EAAqBJ,EAAQ,SAAS,EAAI,OAEvF,OAAOK,EAAa,CAClB,UAAWL,EAAQ,UACnB,QAAAG,EACA,KAAMH,EAAQ,KACd,QAAAC,EACA,eAAgBD,EAAQ,eACxB,MAAOA,EAAQ,KAChB,CAAA,CACH,OAASM,EAAO,CAEd,MAAAL,EAAQ,MAAK,EAEPK,CACR,CACF"}

package/dist/legend-DT7j0_pD.js

@@ -0,0 +1,2 @@
+import{jsxs as a,jsx as n}from"react/jsx-runtime";import{m as t,n as o,o as g,S as i,a as r,j as m}from"./panel-5jvisQBr.js";const p={legendBadgeDesired:"what the activation machine wants: active or inactive",legendBadgeHealth:"whether that position is a problem",legendBadgeLifecycle:"where the node sits in its own automaton",legendBadges:"badges",legendEdgeContribution:"contribution",legendEdgeDependency:"dependency",legendEdgeOwnership:"ownership",legendEdges:"edges",legendEdgeWeak:"weak dependency",legendLifecycle:"lifecycle",legendWeakCovers:"reads found or missing, never waits"},h={legendBadgeDesired:"\u0447\u0435\u0433\u043E \u0445\u043E\u0447\u0435\u0442 \u043C\u0430\u0448\u0438\u043D\u0430 \u0430\u043A\u0442\u0438\u0432\u0430\u0446\u0438\u0438: active \u0438\u043B\u0438 inactive",legendBadgeHealth:"\u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u043B\u0438 \u044D\u0442\u043E \u043F\u043E\u043B\u043E\u0436\u0435\u043D\u0438\u0435 \u043F\u0440\u043E\u0431\u043B\u0435\u043C\u043E\u0439",legendBadgeLifecycle:"\u0433\u0434\u0435 \u0443\u0437\u0435\u043B \u043D\u0430\u0445\u043E\u0434\u0438\u0442\u0441\u044F \u0432 \u0441\u043E\u0431\u0441\u0442\u0432\u0435\u043D\u043D\u043E\u043C \u0430\u0432\u0442\u043E\u043C\u0430\u0442\u0435",legendBadges:"\u0431\u0435\u0439\u0434\u0436\u0438",legendEdgeContribution:"\u0432\u043A\u043B\u0430\u0434",legendEdgeDependency:"\u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u044C",legendEdgeOwnership:"\u0432\u043B\u0430\u0434\u0435\u043D\u0438\u0435",legendEdges:"\u0440\u0451\u0431\u0440\u0430",legendEdgeWeak:"\u0441\u043B\u0430\u0431\u0430\u044F \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u044C",legendLifecycle:"\u0436\u0438\u0437\u043D\u0435\u043D\u043D\u044B\u0439 \u0446\u0438\u043A\u043B",legendWeakCovers:"\u0447\u0438\u0442\u0430\u0435\u0442\u0441\u044F \u043A\u0430\u043A found \u0438\u043B\u0438 missing, \u043D\u0438\u043A\u043E\u0433\u0434\u0430 \u043D\u0435 \u0436\u0434\u0451\u0442"};function c(e){return e==="ru"?h:p}function u(e){return[{className:"odt-edge-sample",covers:"hard-import, requires-port",name:e.legendEdgeDependency},{className:"odt-edge-sample",covers:`optional-import, optional-port, absent-import, absent-port \xB7 ${e.legendWeakCovers}`,name:e.legendEdgeWeak},{className:"odt-edge-sample odt-edge-sample-accent",covers:"owns, provides-port, condition-control",name:e.legendEdgeOwnership},{className:"odt-edge-sample odt-edge-sample-dashed",covers:"contributes-to",name:e.legendEdgeContribution}]}function N(e,d){return[{detail:e.legendBadgeDesired,name:d[0]},{detail:e.legendBadgeLifecycle,name:d[1]},{detail:e.legendBadgeHealth,name:d[2]}]}function f(){const e=t(),d=c(o());return a("div",{className:"odt-legend-group",children:[n("h3",{className:"odt-sec",children:d.legendLifecycle}),g.map(s=>a("span",{className:"odt-legend-row",children:[n(i,{state:s}),n(r,{state:s}),n("span",{className:"odt-legend-detail",children:m(s,e)})]},s))]})}function v(){const e=c(o());return a("div",{className:"odt-legend-group",children:[n("h3",{className:"odt-sec",children:e.legendEdges}),u(e).map(d=>a("span",{className:"odt-legend-row",children:[n("span",{className:d.className}),n("span",{className:"odt-legend-name",children:d.name}),n("span",{className:"odt-legend-detail odt-mono",children:d.covers})]},d.name))]})}function E(){const e=t(),d=c(o()),s=[e.axisDesired,e.axisLifecycle,e.axisHealth];return a("div",{className:"odt-legend-group",children:[n("h3",{className:"odt-sec",children:d.legendBadges}),N(d,s).map(l=>a("span",{className:"odt-legend-row",children:[n("span",{className:"odt-tag odt-tag-accent",children:l.name}),n("span",{className:"odt-legend-detail",children:l.detail})]},l.name))]})}function w(){const e=t();return a("section",{"aria-label":e.legend,className:"odt-legend-panel",children:[n(f,{}),n(v,{}),n(E,{})]})}export{w as Legend};
+//# sourceMappingURL=legend-DT7j0_pD.js.map

package/dist/legend-DT7j0_pD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legend-DT7j0_pD.js","sources":["../src/react/legend-locale.ts","../src/react/legend.tsx"],"sourcesContent":["/**\n * The legend's own dictionary, kept out of the panel's (§4.6).\n *\n * The legend is collapsed until a developer asks what a shape means, so its words travel with its code rather than\n * with every panel that never opens it. The discipline is the panel's: English is the source, the Russian record is\n * typed against it, and the protocol vocabulary the legend explains is not translated in either.\n */\n\nimport type { DevtoolsLocale } from './locale';\n\nconst en = {\n  legendBadgeDesired: 'what the activation machine wants: active or inactive',\n  legendBadgeHealth: 'whether that position is a problem',\n  legendBadgeLifecycle: 'where the node sits in its own automaton',\n  legendBadges: 'badges',\n  legendEdgeContribution: 'contribution',\n  legendEdgeDependency: 'dependency',\n  legendEdgeOwnership: 'ownership',\n  legendEdges: 'edges',\n  legendEdgeWeak: 'weak dependency',\n  legendLifecycle: 'lifecycle',\n  legendWeakCovers: 'reads found or missing, never waits',\n};\n\nconst ru: typeof en = {\n  legendBadgeDesired: 'чего хочет машина активации: active или inactive',\n  legendBadgeHealth: 'является ли это положение проблемой',\n  legendBadgeLifecycle: 'где узел находится в собственном автомате',\n  legendBadges: 'бейджи',\n  legendEdgeContribution: 'вклад',\n  legendEdgeDependency: 'зависимость',\n  legendEdgeOwnership: 'владение',\n  legendEdges: 'рёбра',\n  legendEdgeWeak: 'слабая зависимость',\n  legendLifecycle: 'жизненный цикл',\n  legendWeakCovers: 'читается как found или missing, никогда не ждёт',\n};\n\nfunction legendStringsFor(locale: DevtoolsLocale): typeof en {\n  return locale === 'ru' ? ru : en;\n}\n\nexport { legendStringsFor };\n","/**\n * One legend for the whole panel, per the owner's request: the state glyphs, the three kinds of edge and the badges,\n * in one collapsible place instead of two partial legends pinned to a tree and a canvas.\n *\n * It is collapsed by default. A legend that is always open spends the space a graph needs; a legend that cannot be\n * found is worse than none — so the header carries a button, and the button says whether it is open.\n */\n\nimport type { ReactElement } from 'react';\n\nimport { displayStates, stateDescription, StateGlyph, StateTag } from './glyph';\nimport { legendStringsFor } from './legend-locale';\nimport { useLocale, useStrings } from './locale-context';\n\ntype LegendStrings = ReturnType<typeof legendStringsFor>;\n\ntype EdgeSample = Readonly<{\n  className: string;\n  covers: string;\n  name: string;\n}>;\n\n/**\n * Three visual kinds, not eleven: the panel draws a dependency, an ownership and a contribution, and the legend says\n * which protocol edges fall into each. The names stay untranslated — they are protocol words, not prose.\n */\nfunction edgeSamples(strings: LegendStrings): readonly EdgeSample[] {\n  return [\n    { className: 'odt-edge-sample', covers: 'hard-import, requires-port', name: strings.legendEdgeDependency },\n    {\n      className: 'odt-edge-sample',\n      covers: `optional-import, optional-port, absent-import, absent-port · ${strings.legendWeakCovers}`,\n      name: strings.legendEdgeWeak,\n    },\n    {\n      className: 'odt-edge-sample odt-edge-sample-accent',\n      covers: 'owns, provides-port, condition-control',\n      name: strings.legendEdgeOwnership,\n    },\n    {\n      className: 'odt-edge-sample odt-edge-sample-dashed',\n      covers: 'contributes-to',\n      name: strings.legendEdgeContribution,\n    },\n  ];\n}\n\ntype BadgeSample = Readonly<{\n  detail: string;\n  name: string;\n}>;\n\nfunction badgeSamples(strings: LegendStrings, axes: readonly [string, string, string]): readonly BadgeSample[] {\n  return [\n    { detail: strings.legendBadgeDesired, name: axes[0] },\n    { detail: strings.legendBadgeLifecycle, name: axes[1] },\n    { detail: strings.legendBadgeHealth, name: axes[2] },\n  ];\n}\n\nfunction LegendStates(): ReactElement {\n  const strings = useStrings();\n  const legend = legendStringsFor(useLocale());\n\n  return (\n    <div className=\"odt-legend-group\">\n      <h3 className=\"odt-sec\">{legend.legendLifecycle}</h3>\n      {displayStates.map(state => (\n        <span key={state} className=\"odt-legend-row\">\n          <StateGlyph state={state} />\n          <StateTag state={state} />\n          <span className=\"odt-legend-detail\">{stateDescription(state, strings)}</span>\n        </span>\n      ))}\n    </div>\n  );\n}\n\nfunction LegendEdges(): ReactElement {\n  const strings = legendStringsFor(useLocale());\n\n  return (\n    <div className=\"odt-legend-group\">\n      <h3 className=\"odt-sec\">{strings.legendEdges}</h3>\n      {edgeSamples(strings).map(sample => (\n        <span key={sample.name} className=\"odt-legend-row\">\n          <span className={sample.className} />\n          <span className=\"odt-legend-name\">{sample.name}</span>\n          <span className=\"odt-legend-detail odt-mono\">{sample.covers}</span>\n        </span>\n      ))}\n    </div>\n  );\n}\n\nfunction LegendBadges(): ReactElement {\n  const panel = useStrings();\n  const strings = legendStringsFor(useLocale());\n  const axes: readonly [string, string, string] = [panel.axisDesired, panel.axisLifecycle, panel.axisHealth];\n\n  return (\n    <div className=\"odt-legend-group\">\n      <h3 className=\"odt-sec\">{strings.legendBadges}</h3>\n      {badgeSamples(strings, axes).map(sample => (\n        <span key={sample.name} className=\"odt-legend-row\">\n          <span className=\"odt-tag odt-tag-accent\">{sample.name}</span>\n          <span className=\"odt-legend-detail\">{sample.detail}</span>\n        </span>\n      ))}\n    </div>\n  );\n}\n\nfunction Legend(): ReactElement {\n  const strings = useStrings();\n\n  return (\n    <section aria-label={strings.legend} className=\"odt-legend-panel\">\n      <LegendStates />\n      <LegendEdges />\n      <LegendBadges />\n    </section>\n  );\n}\n\nexport { Legend };\n"],"names":["en","ru","legendStringsFor","locale","edgeSamples","strings","badgeSamples","axes","LegendStates","useStrings","legend","useLocale","_jsxs","_jsx","displayStates","state","StateGlyph","StateTag","stateDescription","LegendEdges","sample","LegendBadges","panel","Legend"],"mappings":"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"}

package/dist/node-facts.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Small readers over the kind-specific state unions. They exist so the panel and the search index ask "does this node
+ * carry a failure" once, in one place, instead of every view re-implementing a `state.kind` switch and drifting.
+ */
+import type { DiagnosticRuntimeNode } from './graph.js';
+import type { DiagnosticFailure } from './protocol.js';
+/** §2.6: a failure is the runtime's own subject and code plus a phase. There is no message, stack or cause to read. */
+declare function failureOf(node: DiagnosticRuntimeNode): DiagnosticFailure | undefined;
+declare function generationOf(node: DiagnosticRuntimeNode): number | undefined;
+/**
+ * How far a group has walked its canonical order, in either direction. A count, never a duration.
+ *
+ * The counts are written in the protocol's own words — the state kind and the numbers it carries — and not as a
+ * sentence. A projection that composes prose would be prose no dictionary could reach: this string is built below
+ * the view, so an English sentence here would print English in a Russian panel (U21).
+ */
+declare function progressOf(node: DiagnosticRuntimeNode): string | undefined;
+/** Whether this node currently satisfies whoever depends on it. */
+declare function isReadyDisplay(node: DiagnosticRuntimeNode): boolean;
+export { failureOf, generationOf, isReadyDisplay, progressOf };

package/dist/node-state.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Kind-specific state automata. Each one is transcribed from a machine that exists in the runtime today, not from a
+ * taxonomy the panel would like to have:
+ *
+ * - the condition group from `runtime/src/condition-group-execution.ts` (D110);
+ * - the feature instance from `runtime/src/module-generation.ts` and the `FeatureError` codes of `spec.md` §4;
+ * - the attachment from `AttachmentLifecycleSnapshot` in `core/src/attachment-lifecycle-contract.ts`;
+ * - the contribution from the hub of D79, where a published contribution with `when` false is withheld from
+ *   `entries` while staying published;
+ * - the port from the application compiler, which selects one provider at compile time (two is a compile error), so
+ *   the only runtime question left is whether that provider currently has a live instance;
+ * - the host contract from `bind(contract, value)` at `openApplication` (D68).
+ *
+ * There is deliberately no universal `node.status`: collapsing six different automata into one enum is how a debugger
+ * starts lying. The three visual axes are derived from these unions in `visual-axes.ts`, never the other way round.
+ */
+import type { DiagnosticCauseRef, DiagnosticClosedReason, DiagnosticFailure, DiagnosticNodeId, DiagnosticSequence, DiagnosticWaitReason, LifecycleAxis } from './protocol.js';
+/**
+ * A condition's truth. `source-closed` reads as `false` for the activation machine, and the law that produces it is
+ * D93: a condition computed from a retired feature reads `false`. It stays a separate state because "nobody has said
+ * yes" and "the feature that would say yes is gone" send a developer to different places.
+ */
+type ConditionState = Readonly<{
+    kind: 'false';
+}> | Readonly<{
+    kind: 'source-closed';
+}> | Readonly<{
+    kind: 'true';
+}>;
+/**
+ * The condition group: features whose `when` names the same set of conditions, which is the owner of activation the
+ * compiler infers (D93, D102). `opened` and `total` are positions in the canonical order, not a clock.
+ */
+type ConditionGroupState = Readonly<{
+    failure: DiagnosticFailure;
+    kind: 'failed';
+}> | Readonly<{
+    kind: 'active';
+}> | Readonly<{
+    kind: 'closed';
+}> | Readonly<{
+    kind: 'inactive';
+    reason: DiagnosticClosedReason;
+}> | Readonly<{
+    kind: 'opening';
+    opened: number;
+    total: number;
+}> | Readonly<{
+    kind: 'retiring';
+    remaining: number;
+}>;
+/**
+ * One life of one feature: `FeatureInstance` in the author vocabulary (D81, D110). The workspace states carry the
+ * `FeatureError` code that produced them, so `not-ready`, `retired`, `quarantined` and `cleanup-failed` here are the
+ * same four words the runtime throws.
+ */
+type FeatureInstanceState = Readonly<{
+    blockedBy: readonly DiagnosticNodeId[];
+    kind: 'waiting';
+    reason: DiagnosticWaitReason;
+}> | Readonly<{
+    failure: DiagnosticFailure;
+    kind: 'cleanup-failed';
+}> | Readonly<{
+    failure: DiagnosticFailure;
+    kind: 'not-ready';
+}> | Readonly<{
+    failure: DiagnosticFailure;
+    kind: 'quarantined';
+}> | Readonly<{
+    kind: 'draining';
+}> | Readonly<{
+    kind: 'fencing';
+}> | Readonly<{
+    kind: 'opening';
+}> | Readonly<{
+    kind: 'ready';
+}> | Readonly<{
+    kind: 'retired';
+    reason: DiagnosticClosedReason;
+}>;
+/** Exactly `AttachmentLifecycleSnapshot`: the five states an attachment can report, with its closing phase. */
+type AttachmentState = Readonly<{
+    failure: DiagnosticFailure;
+    kind: 'failed-close';
+}> | Readonly<{
+    kind: 'closed';
+}> | Readonly<{
+    kind: 'closing';
+    phase: 'close' | 'retry' | 'rollback';
+}> | Readonly<{
+    kind: 'opening';
+}> | Readonly<{
+    kind: 'ready';
+}>;
+/**
+ * A contribution. `withheld` is the state D79 created: the contribution is published and its id is validated, but
+ * its `when` reads `false`, so `Slot`, `fold`, `select` and emptiness checks do not see it. Published-and-invisible
+ * is not the same fact as withdrawn, and merging them would hide the most common "why is my slot empty".
+ */
+type ContributionState = Readonly<{
+    failure: DiagnosticFailure;
+    kind: 'rejected';
+}> | Readonly<{
+    kind: 'pending';
+}> | Readonly<{
+    kind: 'published';
+}> | Readonly<{
+    kind: 'withdrawn';
+}> | Readonly<{
+    kind: 'withheld';
+}>;
+/**
+ * A port. The provider is chosen once, when `defineApplication` compiles the topology, so there is no admission,
+ * no candidate set and no ambiguity to report at runtime — two providers are a compile error and `required` without
+ * a provider never compiles. What is left is whether the selected provider has a live instance right now, which is
+ * what decides between a call that runs and a weak call that settles `CallError('unavailable')` (D105).
+ */
+type PortState = Readonly<{
+    instance: DiagnosticNodeId;
+    kind: 'available';
+}> | Readonly<{
+    kind: 'absent';
+}> | Readonly<{
+    kind: 'unavailable';
+    provider: DiagnosticNodeId;
+}>;
+/**
+ * A host contract. `bound` is a value the host passed to `bind(contract, value)`, `unbound` is a weak host import the
+ * host chose not to bind, and `deferred` is `onDemand(hostContract)`, whose connection waits for the attachment that
+ * opens it rather than for activation.
+ */
+type HostContractState = Readonly<{
+    kind: 'bound';
+}> | Readonly<{
+    kind: 'deferred';
+}> | Readonly<{
+    kind: 'unbound';
+}>;
+type DiagnosticNodeState = AttachmentState | ConditionGroupState | ConditionState | ContributionState | FeatureInstanceState | HostContractState | PortState;
+/**
+ * One step of the chain the inspector shows under "last causal chain". Typed on purpose: the panel formats
+ * `<condition> → true` or `<node> · ready` from refs, it does not receive or parse a prose sentence. The step has no
+ * clock of its own — `cause.at` is the only one, and it is optional.
+ */
+type DiagnosticCausalStep = Readonly<{
+    cause: DiagnosticCauseRef;
+    lifecycle?: LifecycleAxis;
+    node?: DiagnosticNodeId;
+    sequence: DiagnosticSequence;
+}>;
+export type { AttachmentState, ConditionGroupState, ConditionState, ContributionState, DiagnosticCausalStep, DiagnosticNodeState, FeatureInstanceState, HostContractState, PortState, };

package/dist/optional.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `exactOptionalPropertyTypes` forbids writing `undefined` into an optional property, which otherwise turns every
+ * optional field into its own conditional spread. This drops absent keys instead, so a projection can be assembled
+ * from possibly-absent values in one place.
+ */
+declare function defined<Fields extends object>(fields: {
+    [Key in keyof Fields]?: Fields[Key] | undefined;
+}): Fields;
+export { defined };