@datum-cloud/portal-plugin-sdk 1.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,62 @@
+# @datum-cloud/portal-plugin-sdk
+
+The host-contract package for cloud-portal's [Portal Plugin
+System](https://github.com/datum-cloud/cloud-portal/blob/main/docs/enhancements/portal-plugin-system.md).
+A service team's plugin imports this package to reach the three things the
+host provides — never a plugin-declared backend, and never a hand-rolled
+stand-in.
+
+```tsx
+import { useProjectContext, usePluginFetch, useResourceWatch } from '@datum-cloud/portal-plugin-sdk';
+
+function InstanceList() {
+  const { project } = useProjectContext();
+  const pluginFetch = usePluginFetch();
+  const { lastEvent } = useResourceWatch({
+    resourceType: 'compute.miloapis.com/v1alpha1/workloads',
+  });
+
+  // pluginFetch is pre-scoped to `project`'s control plane and already
+  // authenticated — the path below is just the K8s API path.
+  // await pluginFetch('/apis/compute.miloapis.com/v1alpha1/namespaces/default/workloads')
+
+  return <div>{project?.displayName}</div>;
+}
+```
+
+## Why a singleton, not a normal npm dependency
+
+Plugins are loaded via Module Federation, in the host's own JavaScript realm.
+If a plugin bundled its own copy of this package, its `useContext()` calls
+would read from its own private Context — never the host's. The host
+registers `@datum-cloud/portal-plugin-sdk` as an **eager singleton** shared
+module (see cloud-portal's `federation-host.ts`), the same way it shares
+`react` and `react-router`, so every plugin resolves the host's exact module
+instance at runtime regardless of what version it was built against.
+
+## Two entry points, two audiences
+
+- `@datum-cloud/portal-plugin-sdk` — the plugin-facing surface: `useProjectContext`,
+  `usePluginFetch`, `useResourceWatch`, and their result types. This is the
+  package a plugin repository actually calls.
+- `@datum-cloud/portal-plugin-sdk/host` — host-only wiring
+  (`PortalPluginHostProvider`), imported by cloud-portal to supply the real
+  implementations behind those three hooks. A plugin should never import this.
+
+## Versioning
+
+The host advertises its SDK version; a plugin manifest whose `sdk.range`
+doesn't match is not loaded (`Compatible=False`). Per the enhancement doc:
+additive changes (a new optional field, a new hook) are **minor**; removing a
+hook or a required field is **major**, with a deprecation window. Both entry
+points are part of that same contract — a breaking change to either is a
+major bump.
+
+## Development
+
+```bash
+pnpm install
+pnpm build
+pnpm test
+pnpm typecheck
+```

package/dist/context-Cl6RRw0h.js

@@ -0,0 +1,22 @@
+import { createContext } from "react";
+//#region src/context.ts
+/**
+* The single React Context instance shared by both this package's plugin-
+* facing hooks (`.`) and the host-only Provider (`./host`).
+*
+* Why this matters for Module Federation: a Context object is only ever the
+* same Context to `useContext()` if it is literally the same module instance.
+* If the host and a plugin each bundled their own copy of this package, the
+* plugin's `useProjectContext()` would read from the plugin's own empty
+* Context — never the host's Provider. That's why cloud-portal's federation
+* host must register `@datum-cloud/portal-plugin-sdk` itself as a Module
+* Federation shared singleton (`singleton: true, eager: true`), exactly like
+* `react` and `react-router` — see the host's federation-host.ts. As long as
+* that's true, every consumer (host and every plugin) resolves this same
+* module, so this same `createContext` call.
+*/
+const PortalPluginHostContext = createContext(null);
+//#endregion
+export { PortalPluginHostContext as t };
+
+//# sourceMappingURL=context-Cl6RRw0h.js.map

package/dist/context-Cl6RRw0h.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-Cl6RRw0h.js","names":[],"sources":["../src/context.ts"],"sourcesContent":["/**\n * The single React Context instance shared by both this package's plugin-\n * facing hooks (`.`) and the host-only Provider (`./host`).\n *\n * Why this matters for Module Federation: a Context object is only ever the\n * same Context to `useContext()` if it is literally the same module instance.\n * If the host and a plugin each bundled their own copy of this package, the\n * plugin's `useProjectContext()` would read from the plugin's own empty\n * Context — never the host's Provider. That's why cloud-portal's federation\n * host must register `@datum-cloud/portal-plugin-sdk` itself as a Module\n * Federation shared singleton (`singleton: true, eager: true`), exactly like\n * `react` and `react-router` — see the host's federation-host.ts. As long as\n * that's true, every consumer (host and every plugin) resolves this same\n * module, so this same `createContext` call.\n */\nimport { createContext } from 'react';\nimport type { PortalPluginHostBindings } from './types';\n\nexport const PortalPluginHostContext = createContext<PortalPluginHostBindings | null>(null);\n"],"mappings":";;;;;;;;;;;;;;;;;AAkBA,MAAa,0BAA0B,cAA+C,IAAI"}

package/dist/host/index.d.ts

@@ -0,0 +1,10 @@
+import { s as PortalPluginHostBindings } from "../types-CvoOm66Q.js";
+import { ReactElement, ReactNode } from "react";
+//#region src/host/index.d.ts
+declare function PortalPluginHostProvider({ bindings, children }: {
+  bindings: PortalPluginHostBindings;
+  children: ReactNode;
+}): ReactElement;
+//#endregion
+export { type PortalPluginHostBindings, PortalPluginHostProvider };
+//# sourceMappingURL=index.d.ts.map

package/dist/host/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/host/index.tsx"],"mappings":";;;iBAegB,2BACd,UACA;EAEA,UAAU;EACV,UAAU;IACR"}

package/dist/host/index.js

@@ -0,0 +1,24 @@
+import { t as PortalPluginHostContext } from "../context-Cl6RRw0h.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/host/index.tsx
+/**
+* Host-only wiring — imported by cloud-portal, never by a plugin.
+*
+* Wrap the tree that mounts plugin components (the project layout, or at
+* minimum the plugin catch-all mount) in `<PortalPluginHostProvider>`, and
+* pass real implementations for the three hooks. Because this package is
+* registered as an eager, singleton Module Federation share (see
+* federation-host.ts's `hostShared()`), a plugin's `useProjectContext()` /
+* `usePluginFetch()` / `useResourceWatch()` calls resolve to this exact
+* Provider's value, even though the plugin bundle never imports this module.
+*/
+function PortalPluginHostProvider({ bindings, children }) {
+	return /* @__PURE__ */ jsx(PortalPluginHostContext.Provider, {
+		value: bindings,
+		children
+	});
+}
+//#endregion
+export { PortalPluginHostProvider };
+
+//# sourceMappingURL=index.js.map

package/dist/host/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/host/index.tsx"],"sourcesContent":["/**\n * Host-only wiring — imported by cloud-portal, never by a plugin.\n *\n * Wrap the tree that mounts plugin components (the project layout, or at\n * minimum the plugin catch-all mount) in `<PortalPluginHostProvider>`, and\n * pass real implementations for the three hooks. Because this package is\n * registered as an eager, singleton Module Federation share (see\n * federation-host.ts's `hostShared()`), a plugin's `useProjectContext()` /\n * `usePluginFetch()` / `useResourceWatch()` calls resolve to this exact\n * Provider's value, even though the plugin bundle never imports this module.\n */\nimport { PortalPluginHostContext } from '../context';\nimport type { PortalPluginHostBindings } from '../types';\nimport type { ReactElement, ReactNode } from 'react';\n\nexport function PortalPluginHostProvider({\n  bindings,\n  children,\n}: {\n  bindings: PortalPluginHostBindings;\n  children: ReactNode;\n}): ReactElement {\n  return (\n    <PortalPluginHostContext.Provider value={bindings}>{children}</PortalPluginHostContext.Provider>\n  );\n}\n\nexport type { PortalPluginHostBindings } from '../types';\n"],"mappings":";;;;;;;;;;;;;;AAeA,SAAgB,yBAAyB,EACvC,UACA,YAIe;CACf,OACE,oBAAC,wBAAwB,UAAzB;EAAkC,OAAO;EAAW;CAA2C,CAAA;AAEnG"}

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import { a as PluginWatchEvent, c as UseResourceWatchOptions, i as PluginProjectContextValue, l as UseResourceWatchResult, n as PluginOrganization, o as PluginWatchEventType, r as PluginProject, t as PluginFetch } from "./types-CvoOm66Q.js";
+//#region src/hooks/use-project-context.d.ts
+/**
+ * The current project and organization the plugin is mounted under. Backed
+ * by the host's own project-resolution state (session, route params, and the
+ * project/org fetch) — a plugin never resolves this itself.
+ */
+declare function useProjectContext(): PluginProjectContextValue;
+//#endregion
+//#region src/hooks/use-plugin-fetch.d.ts
+/**
+ * A `fetch` pre-scoped to the current project's control plane and mediated
+ * through the portal's authenticated Milo proxy. This is the only data path
+ * a plugin gets — every API call a plugin issues, including calls to a
+ * service's own aggregated apiserver, must go through it. There is no
+ * plugin-declared backend.
+ */
+declare function usePluginFetch(): PluginFetch;
+//#endregion
+//#region src/hooks/use-resource-watch.d.ts
+/**
+ * Live updates for a resource in the current project's control plane,
+ * through the portal's existing watch stream (the same multiplexed SSE
+ * connection built-in pages use — a plugin never opens its own watch
+ * connection to Kubernetes).
+ */
+declare function useResourceWatch<T = unknown>(options: UseResourceWatchOptions<T>): UseResourceWatchResult<T>;
+//#endregion
+//#region src/version.d.ts
+/**
+ * Identity the host and a plugin's manifest both refer to. `SDK_VERSION`
+ * follows the semver discipline from docs/enhancements/portal-plugin-system.md:
+ * additive changes (new hook, new optional field) are minor releases;
+ * removing an extension point or a hook is major, with a deprecation window.
+ * The host compares its own advertised version against a plugin manifest's
+ * `sdk.range` and refuses to load on a mismatch (`Compatible=False`) — this
+ * constant is that source of truth on the SDK side.
+ */
+declare const SDK_NAME = "@datum-cloud/portal-plugin-sdk";
+declare const SDK_VERSION = "1.0.0";
+//#endregion
+export { type PluginFetch, type PluginOrganization, type PluginProject, type PluginProjectContextValue, type PluginWatchEvent, type PluginWatchEventType, SDK_NAME, SDK_VERSION, type UseResourceWatchOptions, type UseResourceWatchResult, usePluginFetch, useProjectContext, useResourceWatch };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/hooks/use-project-context.ts","../src/hooks/use-plugin-fetch.ts","../src/hooks/use-resource-watch.ts","../src/version.ts"],"mappings":";;;;;;;iBAQgB,qBAAqB;;;;;;;;;;iBCErB,kBAAkB;;;;;;;;;iBCDlB,iBAAiB,aAC/B,SAAS,wBAAwB,KAChC,uBAAuB;;;;;;;;;;;;cCFb;cACA"}

package/dist/index.js

@@ -0,0 +1,66 @@
+import { t as PortalPluginHostContext } from "./context-Cl6RRw0h.js";
+import { useContext } from "react";
+//#region src/hooks/use-host-bindings.ts
+/**
+* Every plugin-facing hook delegates to the host's real implementation rather
+* than containing any logic itself — the SDK is a contract, not a client
+* library. This throws with a specific, actionable message rather than
+* silently returning defaults, because a missing binding here almost always
+* means the MF shared-singleton wiring is wrong, not that the plugin did
+* something incorrectly.
+*/
+function useHostBindings(hookName) {
+	const bindings = useContext(PortalPluginHostContext);
+	if (!bindings) throw new Error(`${hookName}() was called outside the portal host's PortalPluginHostProvider. This usually means @datum-cloud/portal-plugin-sdk is not registered as a Module Federation shared singleton on the host, so the plugin's import resolved to a separate, unbound copy of this package instead of the host's — see @datum-cloud/portal-plugin-sdk/host.`);
+	return bindings;
+}
+//#endregion
+//#region src/hooks/use-project-context.ts
+/**
+* The current project and organization the plugin is mounted under. Backed
+* by the host's own project-resolution state (session, route params, and the
+* project/org fetch) — a plugin never resolves this itself.
+*/
+function useProjectContext() {
+	return useHostBindings("useProjectContext").useProjectContext();
+}
+//#endregion
+//#region src/hooks/use-plugin-fetch.ts
+/**
+* A `fetch` pre-scoped to the current project's control plane and mediated
+* through the portal's authenticated Milo proxy. This is the only data path
+* a plugin gets — every API call a plugin issues, including calls to a
+* service's own aggregated apiserver, must go through it. There is no
+* plugin-declared backend.
+*/
+function usePluginFetch() {
+	return useHostBindings("usePluginFetch").usePluginFetch();
+}
+//#endregion
+//#region src/hooks/use-resource-watch.ts
+/**
+* Live updates for a resource in the current project's control plane,
+* through the portal's existing watch stream (the same multiplexed SSE
+* connection built-in pages use — a plugin never opens its own watch
+* connection to Kubernetes).
+*/
+function useResourceWatch(options) {
+	return useHostBindings("useResourceWatch").useResourceWatch(options);
+}
+//#endregion
+//#region src/version.ts
+/**
+* Identity the host and a plugin's manifest both refer to. `SDK_VERSION`
+* follows the semver discipline from docs/enhancements/portal-plugin-system.md:
+* additive changes (new hook, new optional field) are minor releases;
+* removing an extension point or a hook is major, with a deprecation window.
+* The host compares its own advertised version against a plugin manifest's
+* `sdk.range` and refuses to load on a mismatch (`Compatible=False`) — this
+* constant is that source of truth on the SDK side.
+*/
+const SDK_NAME = "@datum-cloud/portal-plugin-sdk";
+const SDK_VERSION = "1.0.0";
+//#endregion
+export { SDK_NAME, SDK_VERSION, usePluginFetch, useProjectContext, useResourceWatch };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/hooks/use-host-bindings.ts","../src/hooks/use-project-context.ts","../src/hooks/use-plugin-fetch.ts","../src/hooks/use-resource-watch.ts","../src/version.ts"],"sourcesContent":["import { PortalPluginHostContext } from '../context';\nimport type { PortalPluginHostBindings } from '../types';\nimport { useContext } from 'react';\n\n/**\n * Every plugin-facing hook delegates to the host's real implementation rather\n * than containing any logic itself — the SDK is a contract, not a client\n * library. This throws with a specific, actionable message rather than\n * silently returning defaults, because a missing binding here almost always\n * means the MF shared-singleton wiring is wrong, not that the plugin did\n * something incorrectly.\n */\nexport function useHostBindings(hookName: string): PortalPluginHostBindings {\n  const bindings = useContext(PortalPluginHostContext);\n  if (!bindings) {\n    throw new Error(\n      `${hookName}() was called outside the portal host's PortalPluginHostProvider. ` +\n        'This usually means @datum-cloud/portal-plugin-sdk is not registered as a Module ' +\n        \"Federation shared singleton on the host, so the plugin's import resolved to a \" +\n        \"separate, unbound copy of this package instead of the host's — see \" +\n        '@datum-cloud/portal-plugin-sdk/host.'\n    );\n  }\n  return bindings;\n}\n","import { useHostBindings } from './use-host-bindings';\nimport type { PluginProjectContextValue } from '../types';\n\n/**\n * The current project and organization the plugin is mounted under. Backed\n * by the host's own project-resolution state (session, route params, and the\n * project/org fetch) — a plugin never resolves this itself.\n */\nexport function useProjectContext(): PluginProjectContextValue {\n  return useHostBindings('useProjectContext').useProjectContext();\n}\n","import { useHostBindings } from './use-host-bindings';\nimport type { PluginFetch } from '../types';\n\n/**\n * A `fetch` pre-scoped to the current project's control plane and mediated\n * through the portal's authenticated Milo proxy. This is the only data path\n * a plugin gets — every API call a plugin issues, including calls to a\n * service's own aggregated apiserver, must go through it. There is no\n * plugin-declared backend.\n */\nexport function usePluginFetch(): PluginFetch {\n  return useHostBindings('usePluginFetch').usePluginFetch();\n}\n","import { useHostBindings } from './use-host-bindings';\nimport type { UseResourceWatchOptions, UseResourceWatchResult } from '../types';\n\n/**\n * Live updates for a resource in the current project's control plane,\n * through the portal's existing watch stream (the same multiplexed SSE\n * connection built-in pages use — a plugin never opens its own watch\n * connection to Kubernetes).\n */\nexport function useResourceWatch<T = unknown>(\n  options: UseResourceWatchOptions<T>\n): UseResourceWatchResult<T> {\n  return useHostBindings('useResourceWatch').useResourceWatch(options);\n}\n","/**\n * Identity the host and a plugin's manifest both refer to. `SDK_VERSION`\n * follows the semver discipline from docs/enhancements/portal-plugin-system.md:\n * additive changes (new hook, new optional field) are minor releases;\n * removing an extension point or a hook is major, with a deprecation window.\n * The host compares its own advertised version against a plugin manifest's\n * `sdk.range` and refuses to load on a mismatch (`Compatible=False`) — this\n * constant is that source of truth on the SDK side.\n */\nexport const SDK_NAME = '@datum-cloud/portal-plugin-sdk';\nexport const SDK_VERSION = '1.0.0';\n"],"mappings":";;;;;;;;;;;AAYA,SAAgB,gBAAgB,UAA4C;CAC1E,MAAM,WAAW,WAAW,uBAAuB;CACnD,IAAI,CAAC,UACH,MAAM,IAAI,MACR,GAAG,SAAS,wUAKd;CAEF,OAAO;AACT;;;;;;;;AChBA,SAAgB,oBAA+C;CAC7D,OAAO,gBAAgB,mBAAmB,CAAC,CAAC,kBAAkB;AAChE;;;;;;;;;;ACAA,SAAgB,iBAA8B;CAC5C,OAAO,gBAAgB,gBAAgB,CAAC,CAAC,eAAe;AAC1D;;;;;;;;;ACHA,SAAgB,iBACd,SAC2B;CAC3B,OAAO,gBAAgB,kBAAkB,CAAC,CAAC,iBAAiB,OAAO;AACrE;;;;;;;;;;;;ACJA,MAAa,WAAW;AACxB,MAAa,cAAc"}

package/dist/types-CvoOm66Q.d.ts

@@ -0,0 +1,74 @@
+//#region src/types.d.ts
+/**
+ * Plugin-facing contract types. Kept dependency-free (no react-query, no
+ * axios, no k8s client) so the SDK's own footprint never forces a version on
+ * a plugin's toolchain — the host is free to implement these hooks with
+ * whatever internal machinery it likes; only these shapes are the contract.
+ */
+interface PluginProject {
+  /** Kubernetes resource name for the project; also its control-plane namespace. */
+  name: string;
+  displayName?: string;
+}
+interface PluginOrganization {
+  name: string;
+  displayName?: string;
+}
+interface PluginProjectContextValue {
+  project: PluginProject | undefined;
+  org: PluginOrganization | undefined;
+  isLoading: boolean;
+  error: Error | null;
+}
+/**
+ * A `fetch`-like function pre-scoped to the current project's control plane
+ * and already authenticated through the portal's session. `path` is just the
+ * Kubernetes API path (e.g. `/apis/compute.miloapis.com/v1alpha1/namespaces/
+ * default/workloads`) — the host prepends the project-scoped proxy prefix and
+ * injects the session's auth. This is the only data path a plugin gets: there
+ * is no plugin-declared backend, and a plugin never picks a base URL or auth
+ * strategy itself.
+ */
+type PluginFetch = (path: string, init?: RequestInit) => Promise<Response>;
+type PluginWatchEventType = 'ADDED' | 'MODIFIED' | 'DELETED' | 'BOOKMARK' | 'ERROR';
+interface PluginWatchEvent<T = unknown> {
+  type: PluginWatchEventType;
+  object: T;
+}
+interface UseResourceWatchOptions<T = unknown> {
+  /** e.g. `compute.miloapis.com/v1alpha1/workloads`. Scoped to the current project. */
+  resourceType: string;
+  /** Watch a single named resource instead of a list. */
+  name?: string;
+  /** K8s namespace within the project's control plane. Defaults to `default`. */
+  namespace?: string;
+  labelSelector?: string;
+  fieldSelector?: string;
+  /** Set false to pause the subscription without unmounting. @default true */
+  enabled?: boolean;
+  /** Transform the raw watched object before it reaches `lastEvent`/`onEvent`. */
+  transform?: (raw: unknown) => T;
+  /** Imperative event handler, called for every event in addition to the returned state. */
+  onEvent?: (event: PluginWatchEvent<T>) => void;
+}
+interface UseResourceWatchResult<T = unknown> {
+  /** Most recently received event, or `null` before the first one arrives. */
+  lastEvent: PluginWatchEvent<T> | null;
+  /** Whether the underlying watch stream is currently connected. */
+  isConnected: boolean;
+  error: Error | null;
+}
+/**
+ * The real implementations the host supplies behind the plugin-facing hooks.
+ * Never imported by a plugin — only by cloud-portal, via `./host`. Shaped as
+ * a bag of hooks (not a single fetch/watch pair) so the host can freely use
+ * its own React Query / watch-manager internals in each implementation.
+ */
+interface PortalPluginHostBindings {
+  useProjectContext(): PluginProjectContextValue;
+  usePluginFetch(): PluginFetch;
+  useResourceWatch<T = unknown>(options: UseResourceWatchOptions<T>): UseResourceWatchResult<T>;
+}
+//#endregion
+export { PluginWatchEvent as a, UseResourceWatchOptions as c, PluginProjectContextValue as i, UseResourceWatchResult as l, PluginOrganization as n, PluginWatchEventType as o, PluginProject as r, PortalPluginHostBindings as s, PluginFetch as t };
+//# sourceMappingURL=types-CvoOm66Q.d.ts.map

package/dist/types-CvoOm66Q.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CvoOm66Q.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;UAWiB;;EAEf;EACA;;UAGe;EACf;EACA;;UAGe;EACf,SAAS;EACT,KAAK;EACL;EACA,OAAO;;;;;;;;;;;KAgBG,eAAe,cAAc,OAAO,gBAAgB,QAAQ;KAM5D;UAEK,iBAAiB;EAChC,MAAM;EACN,QAAQ;;UAGO,wBAAwB;;EAEvC;;EAEA;;EAEA;EACA;EACA;;EAEA;;EAEA,aAAa,iBAAiB;;EAE9B,WAAW,OAAO,iBAAiB;;UAGpB,uBAAuB;;EAEtC,WAAW,iBAAiB;;EAE5B;EACA,OAAO;;;;;;;;UAaQ;EACf,qBAAqB;EACrB,kBAAkB;EAClB,iBAAiB,aAAa,SAAS,wBAAwB,KAAK,uBAAuB"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@datum-cloud/portal-plugin-sdk",
+  "version": "1.0.0",
+  "type": "module",
+  "license": "MIT",
+  "description": "Host-contract SDK for cloud-portal's Portal Plugin System: React hooks (useProjectContext, usePluginFetch, useResourceWatch) that give a plugin its project identity, its only data path (the portal's authenticated Milo control-plane proxy), and live resource updates.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/datum-cloud/portal-plugin-sdk"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./host": {
+      "types": "./dist/host/index.d.ts",
+      "default": "./dist/host/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown --config-loader native && node scripts/fix-eof.mjs",
+    "dev": "tsdown --config-loader native --watch",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist .turbo node_modules coverage"
+  },
+  "peerDependencies": {
+    "react": ">=19.0.0 <20"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "eslint": "^9.19.0",
+    "jsdom": "^29.1.1",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "tsdown": "^0.22.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.9"
+  },
+  "packageManager": "pnpm@11.8.0",
+  "publishConfig": {
+    "access": "public"
+  }
+}