@lynx-go/ui-kit 0.0.0-stage → 0.1.1

package/src/react/options.ts

@@ -0,0 +1,102 @@
+import type { CommandsRecord, SubsRecord } from "../kernel";
+import {
+  batchKey,
+  type CollectionQuery,
+  collectionKey,
+  type Resource,
+  type ResourceScope,
+  recordKey,
+  type Segment,
+  scopeOf,
+} from "../kernel";
+
+/**
+ * /react —— 绑定（把契约接到 TanStack 引擎与 URL）。
+ * 目录级禁 import effect（layer-check 强制）；公开签名零 effect 泄漏。
+ */
+
+export interface QueryEngineOptions {
+  staleTime?: number;
+  refetchInterval?: number | false;
+  enabled?: boolean;
+}
+
+/** queryOptions 工厂：queryKey 单源；hooks 与 route loader（ensureQueryData/Link preload）共用。 */
+export function collectionQueryOptions<T, ID, C extends CommandsRecord<ID>, S extends SubsRecord>(
+  resource: Resource<T, ID, C, S>,
+  query: CollectionQuery,
+  options: QueryEngineOptions = {},
+): {
+  queryKey: readonly unknown[];
+  queryFn: (ctx: { signal: AbortSignal }) => Promise<Segment<T>>;
+  staleTime?: number;
+  refetchInterval?: number | false;
+  enabled?: boolean;
+} {
+  const collection = resource.collection;
+  if (!collection) {
+    throw new Error(
+      `fleet-ui: resource "${String(resource.name)}" has no collection query — did you mean to wrap it with clientCollection()?`,
+    );
+  }
+  return {
+    queryKey: collectionKey(resource, query),
+    queryFn: ({ signal }) => collection(query, scopeOf(resource), signal),
+    ...options,
+  };
+}
+
+export function recordQueryOptions<T, ID, C extends CommandsRecord<ID>, S extends SubsRecord>(
+  resource: Resource<T, ID, C, S>,
+  id: ID | undefined,
+  options: QueryEngineOptions = {},
+): {
+  queryKey: readonly unknown[];
+  queryFn: (ctx: { signal: AbortSignal }) => Promise<T>;
+  staleTime?: number;
+  refetchInterval?: number | false;
+  enabled?: boolean;
+} {
+  const record = resource.record;
+  if (!record) {
+    throw new Error(`fleet-ui: resource "${String(resource.name)}" has no record query`);
+  }
+  if (id === undefined)
+    return {
+      ...options,
+      queryKey: ["record", resource.name, "none"],
+      queryFn: () => Promise.reject(new Error("unreachable")),
+      enabled: false,
+    };
+  const scope = scopeOf(resource);
+  return {
+    queryKey: recordKey(resource, id),
+    queryFn: ({ signal }) => record(id, scope, signal),
+    ...options,
+  };
+}
+
+export function batchQueryOptions<T, ID, C extends CommandsRecord<ID>, S extends SubsRecord>(
+  resource: Resource<T, ID, C, S>,
+  ids: ReadonlyArray<ID>,
+  options: QueryEngineOptions = {},
+): {
+  queryKey: readonly unknown[];
+  queryFn: (ctx: { signal: AbortSignal }) => Promise<ReadonlyArray<T>>;
+  staleTime?: number;
+  refetchInterval?: number | false;
+  enabled?: boolean;
+} {
+  const batch = resource.batch;
+  if (!batch) {
+    throw new Error(`fleet-ui: resource "${String(resource.name)}" has no batch query`);
+  }
+  const scope = scopeOf(resource);
+  return {
+    queryKey: batchKey(resource, ids),
+    queryFn: ({ signal }) => batch(ids, scope, signal),
+    ...options,
+  };
+}
+
+export type { ResourceScope };

package/src/react/permissions.ts

@@ -0,0 +1,39 @@
+/**
+ * useCan —— 权限门控（design.md §3 派生表：identity record Query + 纯谓词）。
+ *
+ * - fail-closed：identity 未加载（loading→pending）或加载失败（error→denied）都不放行；
+ * - "未就绪"（pending）与"拒绝"（denied）是两个可渲染态——pending 渲染占位而非敏感内容；
+ * - 页级门控走 beforeLoad（identity 经 loader 预取 + redirect），元素级用本绑定；
+ * - 纯推导拆出 permissionState：beforeLoad 侧没有 hook，loader 预取后调同一函数。
+ */
+
+export type PermissionState = "pending" | "granted" | "denied";
+
+/** identity 侧的最小结构面（useRecord 的 RecordHandle 天然满足）。 */
+export interface IdentityLike<T> {
+  data: T | undefined;
+  status: "loading" | "error" | "success";
+}
+
+export function permissionState<T>(
+  identity: IdentityLike<T>,
+  predicate: (identity: T) => boolean,
+): PermissionState {
+  if (identity.status === "loading") return "pending";
+  if (identity.status !== "success" || identity.data === undefined) return "denied";
+  return predicate(identity.data) ? "granted" : "denied";
+}
+
+export interface CanHandle {
+  state: PermissionState;
+  /** fail-closed：仅 granted 为 true（pending 不是"暂时允许"） */
+  allowed: boolean;
+}
+
+export function useCan<T>(
+  identity: IdentityLike<T>,
+  predicate: (identity: T) => boolean,
+): CanHandle {
+  const state = permissionState(identity, predicate);
+  return { state, allowed: state === "granted" };
+}

package/src/react/preferences.ts

@@ -0,0 +1,66 @@
+import { useCallback, useState } from "react";
+
+/**
+ * usePreference —— localStorage + 编解码的通用受控状态（design.md §3 派生表）。
+ * useState 形 API；读坏（旧版本残留/手改）回退缺省值，不抛错。
+ * SavedQueriesList 等配方后排；双通道作用域同步（URL↔localStorage）是配方层四件套，不在此。
+ */
+
+export interface PreferenceCodec<T> {
+  parse(raw: string): T;
+  stringify(value: T): string;
+}
+
+const jsonCodec: PreferenceCodec<unknown> = {
+  parse: (raw) => JSON.parse(raw) as unknown,
+  stringify: (value) => JSON.stringify(value),
+};
+
+/** 纯读：raw 缺席或解析失败 → fallback（fail-safe，不进错误通道）。 */
+export function decodePreference<T>(
+  raw: string | null | undefined,
+  fallback: T,
+  codec?: PreferenceCodec<T>,
+): T {
+  if (raw === null || raw === undefined) return fallback;
+  try {
+    return codec ? codec.parse(raw) : (jsonCodec.parse(raw) as T);
+  } catch {
+    return fallback;
+  }
+}
+
+function encodePreference<T>(value: T, codec?: PreferenceCodec<T>): string {
+  return codec ? codec.stringify(value) : jsonCodec.stringify(value);
+}
+
+export function usePreference<T>(
+  key: string,
+  fallback: T,
+  codec?: PreferenceCodec<T>,
+): readonly [T, (next: T | ((prev: T) => T)) => void] {
+  const [value, setValue] = useState<T>(() =>
+    typeof window === "undefined"
+      ? fallback
+      : decodePreference(window.localStorage.getItem(key), fallback, codec),
+  );
+
+  const set = useCallback(
+    (next: T | ((prev: T) => T)) => {
+      setValue((prev) => {
+        const resolved = typeof next === "function" ? (next as (p: T) => T)(prev) : next;
+        if (typeof window !== "undefined") {
+          try {
+            window.localStorage.setItem(key, encodePreference(resolved, codec));
+          } catch {
+            // 私有模式/配额：偏好是锦上添花，写失败静默
+          }
+        }
+        return resolved;
+      });
+    },
+    [key, codec],
+  );
+
+  return [value, set] as const;
+}

package/src/react/subscription.ts

@@ -0,0 +1,123 @@
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { createSubscriptionEngine, type SubscriptionEngine } from "../adapters/subscription";
+import type {
+  Cursor,
+  ResourceScope,
+  SubscriptionDescriptor,
+  SubscriptionPolicy,
+  Transport,
+} from "../kernel";
+
+/**
+ * useSubscription —— Subscription 原语的绑定（问/令/听的"听"）。
+ *
+ * /adapters 引擎句柄 + useSyncExternalStore 接线（design.md §5.3 渲染契约）：
+ * - 本 hook 只订阅**状态存储**（status/error/resyncs）——帧到达不触发页面级重渲染；
+ *   帧消费块（LogViewer/EventFeed）自行经 sub.subscribeFrames/getFrames 订阅帧存储；
+ * - StrictMode 双挂载幂等：引擎在 effect 内创建/销毁，退避状态与 transport 实例
+ *   每代独立；
+ * - 锚点语义：cursor 传 undefined = 待命不开（backlog→follow 等定锚）；
+ *   显式 null = 活尾立即开（日志流）。cursor 值变化 = 重建订阅（清缓冲）；
+ *   gapped 后的原地重锚用 sub.resync(newAnchor)（resyncs++ 供黄条），不要换 prop。
+ *
+ * descriptor | transport 双形态（§2.4）：descriptor（Resource.subscriptions 条目）须声明
+ * policy——流属性默认在资源侧声明，兼作运行时判别；裸 Transport 直用（全局流/日志流）。
+ */
+
+export interface UseSubscriptionOptions<Params, F> {
+  /** descriptor 形态的参数（params 变化 = 重建订阅） */
+  params?: Params;
+  scope?: ResourceScope;
+  /** 覆盖 descriptor.policy（policy 锚定在创建时；中途变更请重建订阅） */
+  policy?: SubscriptionPolicy;
+  /** 初始锚点；undefined = 待命（backlog 等定锚）；null = 活尾 */
+  cursor?: Cursor | null;
+  /** 帧游标投影（重连/续订恢复点）；日志流无游标语义可不传 */
+  getCursor?: (frame: F) => Cursor | undefined;
+  onFrame?: (frame: F) => void;
+  /** 缺省：cursor 已定（含显式 null）即开；false = 完全手动（命令式消费） */
+  autoStart?: boolean;
+}
+
+const IDLE_STATE = { status: "reconnecting", error: null, resyncs: 0 } as const;
+const NO_FRAMES: ReadonlyArray<never> = [];
+const noop = () => undefined;
+
+function idleEngine<F>(): SubscriptionEngine<F> {
+  return {
+    frames: NO_FRAMES,
+    status: "reconnecting",
+    error: null,
+    resyncs: 0,
+    start: noop,
+    stop: noop,
+    pause: noop,
+    resume: noop,
+    restart: noop,
+    resync: noop,
+    clear: noop,
+    onFrame: () => noop,
+    subscribeStatus: () => noop,
+    getState: () => IDLE_STATE,
+    subscribeFrames: () => noop,
+    getFrames: () => NO_FRAMES as ReadonlyArray<F>,
+  };
+}
+
+export function useSubscription<Params, F>(
+  source: Transport<F> | SubscriptionDescriptor<Params, F>,
+  options: UseSubscriptionOptions<Params, F> = {},
+): SubscriptionEngine<F> {
+  // 运行时判别：descriptor 声明 policy（资源侧流属性约定，§2.3）；裸 Transport 无 policy
+  const descriptor = source as SubscriptionDescriptor<Params, F>;
+  const isDescriptor =
+    typeof (source as { policy?: unknown }).policy === "object" &&
+    typeof source.open === "function";
+  const paramsKey = options.params === undefined ? "" : JSON.stringify(options.params);
+  const scopeKey = JSON.stringify(options.scope ?? {});
+  const policy = options.policy ?? descriptor.policy;
+  const policyKey = JSON.stringify(policy ?? null);
+  const anchorKey = options.cursor === undefined ? "\u0000waiting" : `\u0000${options.cursor}`;
+
+  // biome-ignore lint/correctness/useExhaustiveDependencies: descriptor.open/options.* 由 paramsKey/scopeKey 记忆——params 对象标识每渲染变化不应重开流
+  const transport = useMemo<Transport<F>>(() => {
+    if (!isDescriptor) return source as Transport<F>;
+    return descriptor.open(options.params as Params, options.scope ?? {});
+  }, [source, isDescriptor, paramsKey, scopeKey]);
+
+  const [engine, setEngine] = useState<SubscriptionEngine<F> | null>(null);
+
+  // onFrame/getCursor 经 ref 透传（回调标识每渲染变化不应重建订阅；getCursor 是纯投影）
+  const onFrameRef = useRef(options.onFrame);
+  onFrameRef.current = options.onFrame;
+  const getCursorRef = useRef(options.getCursor);
+  getCursorRef.current = options.getCursor;
+
+  // biome-ignore lint/correctness/useExhaustiveDependencies: cursor/policy/autoStart 经 anchorKey/policyKey 锚定——引擎重建键 = transport × 锚点 × 策略（创建时值）
+  useEffect(() => {
+    const created = createSubscriptionEngine<F>({
+      transport,
+      cursor: options.cursor ?? null,
+      getCursor: (frame) => getCursorRef.current?.(frame),
+      ...(policy ? { policy } : {}),
+      onFrame: (frame) => onFrameRef.current?.(frame),
+      // cursor 未定 = 待命；已定（含显式 null 活尾）即开
+      autoStart: options.autoStart ?? options.cursor !== undefined,
+    });
+    setEngine(created);
+    return () => {
+      created.stop();
+    };
+  }, [transport, anchorKey, policyKey]);
+
+  const idle = useMemo(() => idleEngine<F>(), []);
+
+  // 页面级只订状态；帧订阅在块内（渲染契约）
+  useSyncExternalStore(
+    engine ? engine.subscribeStatus : idle.subscribeStatus,
+    engine ? engine.getState : idle.getState,
+    idle.getState,
+  );
+
+  return engine ?? idle;
+}

package/src/schema/codec.ts

@@ -0,0 +1,290 @@
+import {
+  type CollectionQuery,
+  type Operator,
+  type Order,
+  type Predicate,
+  type QueryWindow,
+  textPredicate,
+} from "../kernel";
+
+/**
+ * /schema —— CollectionQuery 的 URL 编解码（Effect Schema 单源的公开面）。
+ *
+ * 对外只暴露纯函数 + Standard Schema 包装：消费方可自选 schema 库，
+ * 与自有 search 参数在纯对象层合并（validateSearch 接受纯函数）。
+ * URL 键名定案：q / filter=field:op:value（重复键）/ sort=field:dir / cursor / page / size。
+ */
+
+export interface FilterFieldDef {
+  field: string;
+  /** 缺省 "eq" */
+  op?: Operator;
+  label?: string;
+  options?: ReadonlyArray<{ value: string; label: string }>;
+}
+
+export interface QuerySchemaSpec {
+  /** q 参与文本搜索的字段白名单 */
+  text?: ReadonlyArray<string>;
+  filters?: ReadonlyArray<FilterFieldDef>;
+  /** 默认 20 */
+  defaultSize?: number;
+  defaultOrder?: ReadonlyArray<Order>;
+}
+
+/** URL 中的扁平参数形状（human-readable）。 */
+export interface FlatSearchParams {
+  q?: string;
+  filter?: ReadonlyArray<string>;
+  sort?: ReadonlyArray<string>;
+  cursor?: string;
+  page?: number;
+  size?: number;
+}
+
+export type FlatPatch = Partial<
+  Record<string, string | number | ReadonlyArray<string> | undefined>
+>;
+
+/** Standard Schema v1 的最小结构形状（TanStack Router validateSearch 直收）。 */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+  "~standard": {
+    version: 1;
+    vendor: "fleet-ui";
+    validate(value: Input): { value: Output };
+  };
+}
+
+const OPERATORS = new Set<string>([
+  "eq",
+  "ne",
+  "contains",
+  "in",
+  "gt",
+  "lt",
+  "gte",
+  "lte",
+  "exists",
+]);
+
+export interface QuerySearchSchema {
+  toSearchSchema(): StandardSchemaV1<unknown, FlatSearchParams>;
+  encode(query: CollectionQuery): FlatSearchParams;
+  decode(params: unknown): CollectionQuery;
+  patch(part: {
+    predicate?: Predicate | null;
+    order?: ReadonlyArray<Order> | null;
+    window?: QueryWindow;
+  }): FlatPatch;
+  readonly defaults: CollectionQuery;
+  readonly spec: QuerySchemaSpec;
+}
+
+export function collectionQuerySchema(spec: QuerySchemaSpec = {}): QuerySearchSchema {
+  const defaultSize = spec.defaultSize ?? 20;
+  const defaults: CollectionQuery = {
+    window: { size: defaultSize },
+    ...(spec.defaultOrder ? { order: spec.defaultOrder } : {}),
+  };
+
+  // ---- 谓词 <-> 扁平键 ----
+
+  function encodePredicate(predicate: Predicate | undefined): {
+    q?: string;
+    filter?: ReadonlyArray<string>;
+  } {
+    if (predicate === undefined) return {};
+    const textSet = new Set(spec.text ?? []);
+    const filters: string[] = [];
+    let q: string | undefined;
+    for (const leaf of flattenLeaves(predicate)) {
+      if (
+        leaf.op === "contains" &&
+        textSet.has(leaf.field as string) &&
+        typeof leaf.value === "string"
+      ) {
+        q = q === undefined ? leaf.value : q; // 同值多字段（textPredicate 的 any 形）
+        continue;
+      }
+      const value = Array.isArray(leaf.value) ? leaf.value.join(",") : String(leaf.value);
+      filters.push(`${leaf.field}:${leaf.op}:${value}`);
+    }
+    return { ...(q !== undefined ? { q } : {}), ...(filters.length ? { filter: filters } : {}) };
+  }
+
+  function flattenLeaves(p: Predicate): ReadonlyArray<Extract<Predicate, { field: string }>> {
+    if ("field" in p) return [p];
+    if ("all" in p) return p.all.flatMap(flattenLeaves);
+    // any 只允许 textPredicate 产生的纯文本形；一般 OR 树不进 URL（消费方自定义参数）
+    const leaves = p.any.flatMap(flattenLeaves);
+    const textSet = new Set(spec.text ?? []);
+    const isText = leaves.every(
+      (l) => l.op === "contains" && textSet.has(l.field as string) && typeof l.value === "string",
+    );
+    if (!isText) {
+      throw new Error(
+        "fleet-ui: predicate with OR is not URL-serializable — keep it in local state or a custom search param",
+      );
+    }
+    return leaves;
+  }
+
+  function parseFilterEntry(entry: string): Extract<Predicate, { field: string }> | null {
+    const i1 = entry.indexOf(":");
+    const i2 = entry.indexOf(":", i1 + 1);
+    if (i1 < 0 || i2 < 0) return null;
+    const field = entry.slice(0, i1);
+    const op = entry.slice(i1 + 1, i2);
+    if (!OPERATORS.has(op)) return null;
+    const rawValue = entry.slice(i2 + 1);
+    const value = op === "in" ? rawValue.split(",").filter(Boolean) : rawValue;
+    return { field, op: op as Operator, value };
+  }
+
+  function decodePredicate(params: FlatSearchParams): Predicate | undefined {
+    const parts: Predicate[] = [];
+    if (params.q !== undefined) {
+      const text = textPredicate(spec.text ?? [], params.q);
+      if (text) parts.push(text);
+    }
+    for (const entry of params.filter ?? []) {
+      const leaf = parseFilterEntry(entry);
+      if (leaf) parts.push(leaf);
+    }
+    if (parts.length === 0) return undefined;
+    if (parts.length === 1) return parts[0];
+    return { all: parts };
+  }
+
+  // ---- 窗口 <-> 键 ----
+
+  function decodeWindow(params: FlatSearchParams): QueryWindow {
+    const size = positiveInt(params.size) ?? defaultSize;
+    if (params.cursor !== undefined && params.cursor !== "") {
+      return { size, cursor: params.cursor };
+    }
+    const page = positiveInt(params.page);
+    if (page !== undefined && page > 1) {
+      return { size, range: { offset: (page - 1) * size } };
+    }
+    return { size };
+  }
+
+  // ---- 归一化（validateSearch 用；容忍脏输入，绝不 throw） ----
+
+  function normalize(input: unknown): FlatSearchParams {
+    const raw = (input ?? {}) as Record<string, unknown>;
+    const out: FlatSearchParams = {};
+    if (typeof raw.q === "string" && raw.q.trim() !== "") out.q = raw.q;
+    const filter = toArray(raw.filter).filter((e) => parseFilterEntry(e) !== null);
+    if (filter.length > 0) out.filter = filter;
+    const sort = toArray(raw.sort).filter((e) => {
+      const i = e.indexOf(":");
+      if (i < 0) return false;
+      return e.slice(i + 1) === "asc" || e.slice(i + 1) === "desc";
+    });
+    if (sort.length > 0) out.sort = sort;
+    if (typeof raw.cursor === "string" && raw.cursor !== "") out.cursor = raw.cursor;
+    const page = positiveInt(raw.page);
+    if (page !== undefined && page > 1) out.page = page;
+    const size = positiveInt(raw.size);
+    if (size !== undefined && size !== defaultSize) out.size = size;
+    return out;
+  }
+
+  function decodeOrders(params: FlatSearchParams): ReadonlyArray<Order> | undefined {
+    const orders = (params.sort ?? [])
+      .map((e) => {
+        const i = e.indexOf(":");
+        const field = e.slice(0, i);
+        const dir = e.slice(i + 1);
+        return dir === "asc" || dir === "desc" ? ({ field, dir } as Order) : null;
+      })
+      .filter((o): o is Order => o !== null);
+    return orders.length > 0 ? orders : undefined;
+  }
+
+  return {
+    spec,
+    defaults,
+    toSearchSchema() {
+      return {
+        "~standard": {
+          version: 1,
+          vendor: "fleet-ui",
+          validate(value: unknown) {
+            return { value: normalize(value) };
+          },
+        },
+      };
+    },
+    encode(query: CollectionQuery): FlatSearchParams {
+      const flat: FlatSearchParams = { ...encodePredicate(query.predicate) };
+      if (query.order?.length) flat.sort = query.order.map((o) => `${o.field}:${o.dir}`);
+      const w = query.window;
+      flat.size = w.size;
+      if (w.cursor !== undefined) flat.cursor = w.cursor;
+      else if (w.range && w.range.offset > 0) flat.page = Math.floor(w.range.offset / w.size) + 1;
+      return flat;
+    },
+    decode(params: unknown): CollectionQuery {
+      const flat = normalize(params);
+      // "URL + schema 默认值即真相"：URL 无 sort 时落 defaultOrder（不落会静默丢默认排序）
+      const order = decodeOrders(flat) ?? spec.defaultOrder;
+      return {
+        ...(decodePredicate(flat) !== undefined ? { predicate: decodePredicate(flat) } : {}),
+        ...(order ? { order } : {}),
+        window: decodeWindow(flat),
+      };
+    },
+    patch(part): FlatPatch {
+      const out: FlatPatch = {};
+      if ("predicate" in part) {
+        // 清除时必须显式 q/filter = undefined：函数式 search 是 {...prev, ...patch}
+        // 展开，缺席的键会让旧值存活（Clear 后 URL 残留 q——fleetly 试点实咬）。
+        const flat = encodePredicate(part.predicate ?? undefined);
+        out.q = flat.q;
+        out.filter = flat.filter;
+        out.cursor = undefined; // 换谓词回第一页
+        out.page = undefined;
+      }
+      if ("order" in part) {
+        const order = part.order ?? [];
+        if (order.length > 0) out.sort = order.map((o) => `${o.field}:${o.dir}`);
+        else out.sort = undefined;
+        out.cursor = undefined; // 换向回第一页（keyset 游标与方向耦合）
+        out.page = undefined;
+      }
+      if (part.window) {
+        const w = part.window;
+        if ("size" in w) out.size = w.size;
+        if (w.cursor !== undefined) {
+          out.cursor = w.cursor;
+          out.page = undefined;
+        } else if (w.range) {
+          out.page = Math.floor(w.range.offset / w.size) + 1;
+          out.cursor = undefined;
+        }
+      }
+      return out;
+    },
+  };
+}
+
+// ---- 工具 ----
+
+function toArray(value: unknown): ReadonlyArray<string> {
+  if (Array.isArray(value)) return value.filter((v): v is string => typeof v === "string");
+  if (typeof value === "string" && value !== "") return [value];
+  return [];
+}
+
+function positiveInt(value: unknown): number | undefined {
+  const n =
+    typeof value === "number"
+      ? value
+      : typeof value === "string"
+        ? Number.parseInt(value, 10)
+        : NaN;
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : undefined;
+}

package/src/schema/index.ts

@@ -0,0 +1,9 @@
+export {
+  collectionQuerySchema,
+  type FilterFieldDef,
+  type FlatPatch,
+  type FlatSearchParams,
+  type QuerySchemaSpec,
+  type QuerySearchSchema,
+  type StandardSchemaV1,
+} from "./codec";

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.