tungsten 0.3.2 → 0.3.4

package/dist/components/library/RichTextEditor/sanitizeAuthoredHtml.d.ts

@@ -0,0 +1,30 @@
+import type { HtmlAllowList } from '../../../rawHtml/HtmlAllowList.js';
+/**
+ * Cleans authored HTML (typically pasted content) down to what the editor
+ * stores: the tags and attributes `safeHtmlAllowList` — and therefore
+ * `<RawHtml safe>` — will actually render, with no generic block containers.
+ *
+ * The safety half is entirely Tungsten's `sanitizeHtml`, which is
+ * `parseHtml` + `contentNodeToHtml` and so makes exactly the decisions the
+ * display side makes: nothing saved from the editor can be silently stripped
+ * later on, because one implementation decides both. Comments go with it —
+ * Windows wraps clipboard HTML in `<!--StartFragment-->` markers, which
+ * otherwise accumulate in the stored markup — as do `script`/`style` whole,
+ * `on*` handlers, and `javascript:`/`data:` URLs.
+ *
+ * What is left here is editor-specific normalisation, which is structure
+ * rather than safety: `<p>`/`<div>` flattened to `<br>`-separated inline
+ * content, empty elements swept, and leading/trailing/repeated blank lines
+ * trimmed.
+ *
+ * Parsing that second pass goes through `DOMParser` rather than assigning to a
+ * detached element's `innerHTML`: a DOMParser document is inert, so nothing in
+ * the markup can load a resource or run a handler while it is walked. The live
+ * document is never touched either way.
+ *
+ * `doc` supplies that parser and defaults to the ambient global `document`,
+ * which is always right in a real browser; callers holding a specific node
+ * should pass its `ownerDocument` instead of relying on the global.
+ */
+export declare function sanitizeAuthoredHtml(html: string, doc?: Document, allowList?: HtmlAllowList): string;
+//# sourceMappingURL=sanitizeAuthoredHtml.d.ts.map

package/dist/components/library/RichTextEditor/sanitizeAuthoredHtml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizeAuthoredHtml.d.ts","sourceRoot":"","sources":["../../../../src/components/library/RichTextEditor/sanitizeAuthoredHtml.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAA;AAsEtE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,QAAmB,EAAE,SAAS,GAAE,aAAiC,GACrF,MAAM,CAUR"}

package/dist/components/library/RichTextEditor/sanitizeAuthoredHtml.js

@@ -0,0 +1,97 @@
+import { sanitizeHtml } from "../../../rawHtml/sanitizeHtml.js";
+import { safeHtmlAllowList } from "../../../rawHtml/safeHtmlAllowList.js";
+// Generic block containers. The editor never creates these — Enter inserts a
+// <br> — so any that appear came from a paste or legacy content, and are
+// flattened to <br>-separated inline content. Browsers disagree about which of
+// <p>/<div> to emit and leave empty ones behind, which is the whole reason the
+// editor avoids them; accepting them back in would reintroduce the mess.
+// Deliberate blocks (headings, blockquote, lists, tables) are not in this set.
+const flattenedBlocks = new Set(['p', 'div']);
+// Elements that carry meaning with no children, so must survive the empty
+// sweep: void elements, and table cells where blank is a real value.
+const meaningfulWhenEmpty = new Set(['br', 'hr', 'img', 'td', 'th', 'col', 'colgroup']);
+function unwrap(element) {
+  const parent = element.parentNode;
+  if (parent === null) return;
+  while (element.firstChild !== null) parent.insertBefore(element.firstChild, element);
+  parent.removeChild(element);
+}
+// Structure only — every safety decision was already made by sanitizeHtml
+// before this ran. Nothing here may reintroduce markup, so nothing here needs
+// to know what is safe.
+function normaliseElement(element) {
+  const tag = element.tagName.toLowerCase();
+  // Recurse before unwrapping, so emptiness cascades outwards from the
+  // deepest node: a block whose only content was an empty span is itself
+  // empty by the time it is considered.
+  for (const child of [...element.children]) {
+    normaliseElement(child);
+  }
+  if (flattenedBlocks.has(tag)) {
+    // A line break stands in for the block boundary, unless nothing
+    // follows it — a trailing break is just a blank line at the end.
+    if (element.nextSibling !== null && element.parentNode !== null) {
+      element.parentNode.insertBefore(element.ownerDocument.createElement('br'), element.nextSibling);
+    }
+    unwrap(element);
+    return;
+  }
+  if (element.childNodes.length === 0 && !meaningfulWhenEmpty.has(tag)) {
+    element.remove();
+  }
+}
+// Blank lines at either end are always noise, and a run of them is usually an
+// accident of editing rather than intent.
+function trimBreaks(body) {
+  const isBreak = node => node !== null && node.nodeType === 1 && node.nodeName.toLowerCase() === 'br';
+  while (isBreak(body.firstChild)) body.firstChild?.remove();
+  while (isBreak(body.lastChild)) body.lastChild?.remove();
+  for (const child of [...body.childNodes]) {
+    if (!isBreak(child)) continue;
+    let following = child.nextSibling;
+    let run = 0;
+    while (isBreak(following)) {
+      const next = following?.nextSibling ?? null;
+      if (++run >= 2) following?.parentNode?.removeChild(following);
+      following = next;
+    }
+  }
+}
+/**
+ * Cleans authored HTML (typically pasted content) down to what the editor
+ * stores: the tags and attributes `safeHtmlAllowList` — and therefore
+ * `<RawHtml safe>` — will actually render, with no generic block containers.
+ *
+ * The safety half is entirely Tungsten's `sanitizeHtml`, which is
+ * `parseHtml` + `contentNodeToHtml` and so makes exactly the decisions the
+ * display side makes: nothing saved from the editor can be silently stripped
+ * later on, because one implementation decides both. Comments go with it —
+ * Windows wraps clipboard HTML in `<!--StartFragment-->` markers, which
+ * otherwise accumulate in the stored markup — as do `script`/`style` whole,
+ * `on*` handlers, and `javascript:`/`data:` URLs.
+ *
+ * What is left here is editor-specific normalisation, which is structure
+ * rather than safety: `<p>`/`<div>` flattened to `<br>`-separated inline
+ * content, empty elements swept, and leading/trailing/repeated blank lines
+ * trimmed.
+ *
+ * Parsing that second pass goes through `DOMParser` rather than assigning to a
+ * detached element's `innerHTML`: a DOMParser document is inert, so nothing in
+ * the markup can load a resource or run a handler while it is walked. The live
+ * document is never touched either way.
+ *
+ * `doc` supplies that parser and defaults to the ambient global `document`,
+ * which is always right in a real browser; callers holding a specific node
+ * should pass its `ownerDocument` instead of relying on the global.
+ */
+export function sanitizeAuthoredHtml(html, doc = document, allowList = safeHtmlAllowList) {
+  const safe = sanitizeHtml(html, {
+    allowList
+  });
+  const parsed = new (doc.defaultView ?? window).DOMParser().parseFromString(safe, 'text/html');
+  for (const child of [...parsed.body.children]) {
+    normaliseElement(child);
+  }
+  trimBreaks(parsed.body);
+  return parsed.body.innerHTML;
+}

package/dist/components/library/__StatefulMessage/MessageData.d.ts

@@ -0,0 +1,7 @@
+export type MessageType = 'success' | 'info' | 'warning' | 'error' | 'exception';
+export type MessageData = {
+    type: MessageType;
+    text: string;
+    hidden?: boolean;
+};
+//# sourceMappingURL=MessageData.d.ts.map

package/dist/components/library/__StatefulMessage/MessageData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageData.d.ts","sourceRoot":"","sources":["../../../../src/components/library/__StatefulMessage/MessageData.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,CAAA;AAEhF,MAAM,MAAM,WAAW,GAAG;IACtB,IAAI,EAAE,WAAW,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IAGZ,MAAM,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA"}

package/dist/components/library/__StatefulMessage/MessageData.js

@@ -0,0 +1 @@
+export {};

package/dist/components/library/__StatefulMessage/StatefulMessage.d.ts

@@ -0,0 +1,22 @@
+import { TungstenStatefulComponent } from '../../../Components.jsx';
+import type { MessageData } from './MessageData.js';
+export interface StatefulMessageData extends MessageData {
+    timestamp: number;
+}
+export type StampedMessageData = StatefulMessageData;
+type Props = {
+    className?: string;
+    data: StatefulMessageData | null;
+};
+type State = {
+    message: StatefulMessageData | null;
+    lastTimestamp: number | null;
+};
+export declare class StatefulMessage extends TungstenStatefulComponent<Props, State> {
+    state: State;
+    componentDidUpdate: () => Promise<void>;
+    content: ({ className }: Props, { message: data }: State) => import("../../../ContentNode.js").ContentNode;
+    style: import("../../../CssNames.js").CssNames;
+}
+export {};
+//# sourceMappingURL=StatefulMessage.d.ts.map

package/dist/components/library/__StatefulMessage/StatefulMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StatefulMessage.d.ts","sourceRoot":"","sources":["../../../../src/components/library/__StatefulMessage/StatefulMessage.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAEnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACpD,SAAS,EAAE,MAAM,CAAA;CACpB;AACD,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,CAAA;AAIpD,KAAK,KAAK,GAAG;IACT,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAAA;CACnC,CAAA;AAED,KAAK,KAAK,GAAG;IAET,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAGnC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B,CAAA;AAOD,qBAAa,eAAgB,SAAQ,yBAAyB,CAAC,KAAK,EAAE,KAAK,CAAC;IACxE,KAAK,EAAE,KAAK,CAIX;IAED,kBAAkB,sBAyBjB;IAED,OAAO,GAAI,eAAe,KAAK,EAAE,mBAAmB,KAAK,mDAM7C;IAEZ,KAAK,0CAyBJ;CACJ"}

package/dist/components/library/__StatefulMessage/StatefulMessage.js

@@ -0,0 +1,88 @@
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+import { TungstenStatefulComponent } from "../../../Components.js";
+import { combineClassNames } from "../../../helpers/combineClassNames.js";
+import { jsx as _jsx } from "tungsten/jsxRuntime.js";
+const BLANK_MS = 70;
+// Inline page feedback which owns its own flash. A page sets a message stamped
+// with the time it was produced; a repeat of the same result therefore arrives
+// as a new timestamp, and the component hides the message briefly so the
+// repeat still reads as a new one. The hidden message keeps its text, and so
+// its size, and nothing else on the page moves.
+export class StatefulMessage extends TungstenStatefulComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "state", {
+      message: this.props.data,
+      // treat the mounting message as already handled, so it does not flash
+      lastTimestamp: this.props.data?.timestamp ?? null
+    });
+    _defineProperty(this, "componentDidUpdate", async () => {
+      const {
+        data
+      } = this.props;
+      if (data === null) {
+        if (this.state.message !== null) this.state.message = null;
+        if (this.state.lastTimestamp !== null) this.state.lastTimestamp = null;
+        return;
+      }
+      // already reacted to this message
+      if (this.state.lastTimestamp === data.timestamp) return;
+      this.state.lastTimestamp = data.timestamp;
+      const shown = this.state.message;
+      const repeatsShownMessage = shown !== null && shown.type === data.type && shown.text === data.text;
+      if (repeatsShownMessage) {
+        this.state.message = {
+          ...data,
+          hidden: true
+        };
+        await new Promise(resolve => setTimeout(resolve, BLANK_MS));
+      }
+      // The prop is the object held in the parent's state; Tungsten adopts it
+      // as a copy, so this component's message and the page's stay separate.
+      this.state.message = data;
+    });
+    _defineProperty(this, "content", ({
+      className
+    }, {
+      message: data
+    }) => data === null ? null : _jsx("p", {
+      className: combineClassNames(className, 'message', data.type, data.hidden === true && 'hidden'),
+      children: data.text
+    }));
+    _defineProperty(this, "style", {
+      "moduleName": "T#-components-library-__StatefulMessage-StatefulMessage",
+      "tags": {},
+      "classes": {
+        "message": "T#-components-library-__StatefulMessage-StatefulMessage_message",
+        "hidden": "T#-components-library-__StatefulMessage-StatefulMessage_hidden",
+        "success": "T#-components-library-__StatefulMessage-StatefulMessage_success",
+        "info": "T#-components-library-__StatefulMessage-StatefulMessage_info",
+        "warning": "T#-components-library-__StatefulMessage-StatefulMessage_warning",
+        "error": "T#-components-library-__StatefulMessage-StatefulMessage_error",
+        "exception": "T#-components-library-__StatefulMessage-StatefulMessage_exception"
+      }
+    });
+  }
+  static $stylesheet = "i/T-components-library-__StatefulMessage-StatefulMessage.css";
+}

package/dist/components/library/index.d.ts

@@ -0,0 +1,5 @@
+export { RichTextEditor } from './RichTextEditor/RichTextEditor.jsx';
+export type { StoredContentNode } from './RichTextEditor/StoredContentNode.js';
+export { serializeContentTree, deserializeContentTree } from './RichTextEditor/contentTree.js';
+export { sanitizeAuthoredHtml } from './RichTextEditor/sanitizeAuthoredHtml.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/library/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/library/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAA;AACpE,YAAY,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAA;AAG9E,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAA;AAC9F,OAAO,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAA"}

package/dist/components/library/index.js

@@ -0,0 +1,7 @@
+// Tungsten's component library — components built on the framework rather than
+// part of it. Exposed as `tungsten/library` so it stays separable from the core.
+export { RichTextEditor } from "./RichTextEditor/RichTextEditor.js";
+// Storing the editor's tree output means reading it back, so the conversion is
+// part of the component's public surface rather than an internal.
+export { serializeContentTree, deserializeContentTree } from "./RichTextEditor/contentTree.js";
+export { sanitizeAuthoredHtml } from "./RichTextEditor/sanitizeAuthoredHtml.js";

package/dist/defaultConfig.d.ts

@@ -15,8 +15,10 @@ export declare const defaultConfig: {
     apiPath: string;
     suppressNoHeadWarning: false;
     suppressOriginMismatchWarning: false;
+    suppressEnvOverwriteWarnings: false;
     warnOnFrameworkChange: true;
     hmr: true;
+    csr: false;
 };
 export type FrameworkConfigDefault = typeof defaultConfig;
 //# sourceMappingURL=defaultConfig.d.ts.map

package/dist/defaultConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaultConfig.d.ts","sourceRoot":"","sources":["../src/defaultConfig.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;CAuBS,CAAA;AAEnC,MAAM,MAAM,sBAAsB,GAAG,OAAO,aAAa,CAAA"}
+{"version":3,"file":"defaultConfig.d.ts","sourceRoot":"","sources":["../src/defaultConfig.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;CAyBS,CAAA;AAEnC,MAAM,MAAM,sBAAsB,GAAG,OAAO,aAAa,CAAA"}

package/dist/defaultConfig.js

@@ -21,6 +21,8 @@ export const defaultConfig = {
   //debug: false // moved to env
   suppressNoHeadWarning: false,
   suppressOriginMismatchWarning: false,
+  suppressEnvOverwriteWarnings: false,
   warnOnFrameworkChange: true,
-  hmr: true
+  hmr: true,
+  csr: false
 };

package/dist/env/Interfaces.d.ts

@@ -1,8 +1,9 @@
 import type { TungstenCorePrivateEnv } from '../Servers/tungstenCorePrivateEnvSchema.js';
+import type { TungstenCorePublicEnv } from '../Servers/tungstenCorePublicEnvSchema.js';
 declare global {
     interface TungstenPrivateEnv extends TungstenCorePrivateEnv {
     }
-    export interface TungstenPublicEnv {
+    export interface TungstenPublicEnv extends TungstenCorePublicEnv {
     }
 }
 //# sourceMappingURL=Interfaces.d.ts.map

package/dist/env/Interfaces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Interfaces.d.ts","sourceRoot":"","sources":["../../src/env/Interfaces.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAA;AAExF,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,kBAAmB,SAAQ,sBAAsB;KAAG;IAC9D,MAAM,WAAW,iBAAiB;KAAG;CACxC"}
+{"version":3,"file":"Interfaces.d.ts","sourceRoot":"","sources":["../../src/env/Interfaces.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAA;AACxF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2CAA2C,CAAA;AAEtF,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,kBAAmB,SAAQ,sBAAsB;KAAG;IAC9D,MAAM,WAAW,iBAAkB,SAAQ,qBAAqB;KAAG;CACtE"}

package/dist/env/getEnvSchemas.d.ts

@@ -3,7 +3,7 @@ import { ZodType } from 'zod';
 import { TungstenEnv } from './types.js';
 export type EnvSchemas = {
     privateEnvSchema?: ZodType<TungstenEnv & TungstenPrivateEnv>;
-    publicEnvSchema?: ZodType<TungstenEnv>;
+    publicEnvSchema?: ZodType<TungstenEnv & TungstenPublicEnv>;
 };
 export declare function getEnvSchemas(config: FrameworkConfigComplete, iteration: number, dev: 'dev'): Promise<EnvSchemas>;
 export declare function getEnvSchemas(config: FrameworkConfigComplete, iteration?: null, dev?: 'prod'): Promise<EnvSchemas>;

package/dist/env/getEnvSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getEnvSchemas.d.ts","sourceRoot":"","sources":["../../src/env/getEnvSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAEpE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AAK7B,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAGxC,MAAM,MAAM,UAAU,GAAG;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC,WAAW,GAAG,kBAAkB,CAAC,CAAC;IAC7D,eAAe,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;CAC1C,CAAA;AAKD,wBAAsB,aAAa,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,GAChG,OAAO,CAAC,UAAU,CAAC,CAAA;AACrB,wBAAsB,aAAa,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,MAAM,GACjG,OAAO,CAAC,UAAU,CAAC,CAAA;AAoErB,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,uBAGlF"}
+{"version":3,"file":"getEnvSchemas.d.ts","sourceRoot":"","sources":["../../src/env/getEnvSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAEpE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AAK7B,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAGxC,MAAM,MAAM,UAAU,GAAG;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC,WAAW,GAAG,kBAAkB,CAAC,CAAC;IAC7D,eAAe,CAAC,EAAE,OAAO,CAAC,WAAW,GAAG,iBAAiB,CAAC,CAAC;CAC9D,CAAA;AAKD,wBAAsB,aAAa,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,GAChG,OAAO,CAAC,UAAU,CAAC,CAAA;AACrB,wBAAsB,aAAa,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,MAAM,GACjG,OAAO,CAAC,UAAU,CAAC,CAAA;AAoErB,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,uBAGlF"}

package/dist/env/injectEnv.d.ts

@@ -1,2 +1,2 @@
-export declare function injectEnv(newEnv: Record<string, string>, env?: Record<string, unknown>, prefix?: string): void;
+export declare function injectEnv(newEnv: Record<string, string>, env?: Record<string, unknown>, prefix?: string, trueEnv?: Record<string, unknown>, suppressOverwriteWarnings?: boolean): void;
 //# sourceMappingURL=injectEnv.d.ts.map

package/dist/env/injectEnv.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"injectEnv.d.ts","sourceRoot":"","sources":["../../src/env/injectEnv.ts"],"names":[],"mappings":"AAEA,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAe,EAAE,MAAM,GAAE,MAAW,QAQxH"}
+{"version":3,"file":"injectEnv.d.ts","sourceRoot":"","sources":["../../src/env/injectEnv.ts"],"names":[],"mappings":"AAGA,wBAAgB,SAAS,CACrB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAe,EAC1C,MAAM,GAAE,MAAW,EAGnB,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACrC,yBAAyB,GAAE,OAAe,QAmB7C"}

package/dist/env/injectEnv.js

@@ -1,9 +1,19 @@
-export function injectEnv(newEnv, env = process.env, prefix = '') {
-  if (prefix.length > 0) {
-    for (const [key, value] of Object.entries(newEnv)) {
-      env[prefix + key] = value;
+import { cliWarn } from "../cliOutput.js";
+export function injectEnv(newEnv, env = process.env, prefix = '',
+// the real (OS/shell) environment as it was before any .env file was loaded - these values
+// always win over .env files, they're never overwritten, only warned about on conflict
+trueEnv = {}, suppressOverwriteWarnings = false) {
+  for (const [key, value] of Object.entries(newEnv)) {
+    const fullKey = prefix + key;
+    if (Object.prototype.hasOwnProperty.call(trueEnv, fullKey)) {
+      if (trueEnv[fullKey] !== value && !suppressOverwriteWarnings) {
+        cliWarn(`env var ${fullKey} from your .env* file is being shadowed by system env`);
+      }
+      continue;
     }
-  } else {
-    Object.assign(env, newEnv);
+    if (!suppressOverwriteWarnings && env[fullKey] !== undefined && env[fullKey] !== value) {
+      cliWarn(`env var ${fullKey} is being overwritten (was "${env[fullKey]}", now "${value}")`);
+    }
+    env[fullKey] = value;
   }
 }

package/dist/env/publicEnv.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"publicEnv.d.ts","sourceRoot":"","sources":["../../src/env/publicEnv.ts"],"names":[],"mappings":"AAGA,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,iBAAiB,GAAG,OAAO,CAG/D"}
+{"version":3,"file":"publicEnv.d.ts","sourceRoot":"","sources":["../../src/env/publicEnv.ts"],"names":[],"mappings":"AAGA,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,iBAAiB,GAAG,OAAO,CAK/D"}

package/dist/env/publicEnv.js

@@ -1,5 +1,8 @@
 import { throwError } from "../throwError.js";
 export function publicEnv(key) {
-  if (tungstenPublicEnv === undefined) throwError('publicEnv', 'Tungsten Public Env is undefined - do you have a .env.public file?');
+  if (tungstenPublicEnv === undefined) {
+    // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+    throwError('publicEnv', 'Tungsten Public Env is undefined - do you have a .env.public file?');
+  }
   return tungstenPublicEnv[key];
 }

package/dist/findUserConfig.d.ts

@@ -1,6 +1,6 @@
 export declare function findUserConfig(projectDir: string, volume?: 'silent' | 'noisy'): Promise<{
     data: any;
-    moduleType: "commonjs" | "module";
+    moduleType: "module" | "commonjs";
     location: string;
 } | null>;
 //# sourceMappingURL=findUserConfig.d.ts.map

package/dist/frameworkConfigSchema.d.ts

@@ -42,6 +42,7 @@ declare const frameworkConfigWithRootComponentValidator: import("arktype/interna
     serverMiddleware?: [string, string, string];
     apiRoutes?: string;
     apiPath?: string;
+    csr?: boolean;
     rootComponent: string;
     useRootComponent?: true;
 }, {}>;
@@ -87,6 +88,7 @@ declare const frameworkConfigWithoutRootComponentValidator: import("arktype/inte
     serverMiddleware?: [string, string, string];
     apiRoutes?: string;
     apiPath?: string;
+    csr?: boolean;
     useRootComponent: false;
 }, {}>;
 export declare const frameworkConfigValidator: import("arktype/internal/variants/object.ts").ObjectType<{
@@ -131,6 +133,7 @@ export declare const frameworkConfigValidator: import("arktype/internal/variants
     serverMiddleware?: [string, string, string];
     apiRoutes?: string;
     apiPath?: string;
+    csr?: boolean;
     rootComponent: string;
     useRootComponent?: true;
 } | {
@@ -175,6 +178,7 @@ export declare const frameworkConfigValidator: import("arktype/internal/variants
     serverMiddleware?: [string, string, string];
     apiRoutes?: string;
     apiPath?: string;
+    csr?: boolean;
     useRootComponent: false;
 }, {}>;
 type ArkFrameworkConfigWithRootComponent = typeof frameworkConfigWithRootComponentValidator.infer;

package/dist/frameworkConfigSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frameworkConfigSchema.d.ts","sourceRoot":"","sources":["../src/frameworkConfigSchema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,IAAI,kBAAkB,EAAE,MAAM,eAAe,CAAA;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAyDnD,QAAA,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAK7C,CAAA;AAEF,QAAA,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAIhD,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEoB,CAAA;AAEzD,KAAK,mCAAmC,GAAG,OAAO,yCAAyC,CAAC,KAAK,CAAA;AACjG,KAAK,sCAAsC,GAAG,OAAO,4CAA4C,CAAC,KAAK,CAAA;AAIvG,UAAU,gCACN,SAAQ,IAAI,CAAC,mCAAmC,EAAE,cAAc,GAAG,cAAc,CAAC;IAClF,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,YAAY,CAAC,EAAE,kBAAkB,CAAA;CACpC;AAED,UAAU,mCACN,SAAQ,IAAI,CAAC,sCAAsC,EAAE,cAAc,GAAG,cAAc,CAAC;IACrF,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,YAAY,CAAC,EAAE,kBAAkB,CAAA;CACpC;AAED,MAAM,MAAM,eAAe,GAAG,gCAAgC,GAAG,mCAAmC,CAAA"}
+{"version":3,"file":"frameworkConfigSchema.d.ts","sourceRoot":"","sources":["../src/frameworkConfigSchema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,IAAI,kBAAkB,EAAE,MAAM,eAAe,CAAA;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AA0DnD,QAAA,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAK7C,CAAA;AAEF,QAAA,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAIhD,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEoB,CAAA;AAEzD,KAAK,mCAAmC,GAAG,OAAO,yCAAyC,CAAC,KAAK,CAAA;AACjG,KAAK,sCAAsC,GAAG,OAAO,4CAA4C,CAAC,KAAK,CAAA;AAIvG,UAAU,gCACN,SAAQ,IAAI,CAAC,mCAAmC,EAAE,cAAc,GAAG,cAAc,CAAC;IAClF,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,YAAY,CAAC,EAAE,kBAAkB,CAAA;CACpC;AAED,UAAU,mCACN,SAAQ,IAAI,CAAC,sCAAsC,EAAE,cAAc,GAAG,cAAc,CAAC;IACrF,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,YAAY,CAAC,EAAE,kBAAkB,CAAA;CACpC;AAED,MAAM,MAAM,eAAe,GAAG,gCAAgC,GAAG,mCAAmC,CAAA"}

package/dist/frameworkConfigSchema.js

@@ -50,7 +50,8 @@ const frameworkConfigBaseValidator = arkType({
   'skipPackageCompilation?': 'string | string[]',
   'serverMiddleware?': ['string', 'string', 'string'],
   'apiRoutes?': 'string',
-  'apiPath?': 'string'
+  'apiPath?': 'string',
+  'csr?': 'boolean'
 });
 const frameworkConfigWithRootComponentValidator = arkType({
   '...': frameworkConfigBaseValidator,

package/dist/hooks/index.d.ts

@@ -1,4 +1,5 @@
 export * from './useCallback.js';
+export * from './useInstance.js';
 export * from './useMemo.js';
 export * from './useRef.js';
 export * from './useState.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AACA,cAAc,kBAAkB,CAAA;AAChC,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AACA,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA"}

package/dist/hooks/index.js

@@ -1,4 +1,5 @@
 export * from "./useCallback.js";
+export * from "./useInstance.js";
 export * from "./useMemo.js";
 export * from "./useRef.js";
 export * from "./useState.js";

package/dist/hooks/useInstance.d.ts

@@ -0,0 +1,3 @@
+import type { Instance } from '../Instance/Instance.js';
+export declare function useInstance(): Instance;
+//# sourceMappingURL=useInstance.d.ts.map

package/dist/hooks/useInstance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInstance.d.ts","sourceRoot":"","sources":["../../src/hooks/useInstance.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD,wBAAgB,WAAW,IAAI,QAAQ,CAEtC"}

package/dist/hooks/useInstance.js

@@ -0,0 +1,4 @@
+import { getCurrentComponent } from "./getCurrentComponent.js";
+export function useInstance() {
+  return getCurrentComponent().__instance;
+}

package/dist/hydrate/hydrate.d.ts

@@ -1,13 +1,15 @@
 import type { InstanceConfig } from '../Instance/InstanceConfig.js';
 import type { AppRoutes } from '../routing/AppRoutes.js';
 import { DomPointer } from '../DomPointer.js';
-import { TungstenBaseComponentType, TungstenBaseComponent } from '../Components.jsx';
+import { TungstenBaseComponentType } from '../Components.jsx';
 import { Instance } from '../Instance/Instance.js';
+import { type TaggedAttributeMismatch } from './renderHydrationMismatchBanner.js';
 import '../hmr/applyHmrModule.js';
-type HydrateMeta = {
+export type HydrateMeta = {
     insideForm: boolean;
+    mismatches: TaggedAttributeMismatch[];
 };
 export declare function hydrate(appRoutes: AppRoutes, RootComponent: TungstenBaseComponentType | null, instanceConfig: InstanceConfig): Promise<void>;
-export declare function hydrateRootComponent(instance: Instance, RootComponent: TungstenBaseComponentType, domPointer: DomPointer, meta: HydrateMeta): Promise<TungstenBaseComponent<object, undefined>>;
-export {};
+export declare function hydrateRootComponent<ComponentType extends TungstenBaseComponentType<any, any>>(instance: Instance, RootComponent: ComponentType, domPointer: DomPointer, meta: HydrateMeta, props?: InstanceType<ComponentType>['props'], // eslint-disable-line no-type-assertion/no-type-assertion -- default only reached when Props is empty, same as the hardcoded {} this replaces
+routeParams?: Record<string, string>, routeData?: unknown): Promise<InstanceType<ComponentType>>;
 //# sourceMappingURL=hydrate.d.ts.map

package/dist/hydrate/hydrate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hydrate.d.ts","sourceRoot":"","sources":["../../src/hydrate/hydrate.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAQnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAoBxD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAM7C,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAA6B,MAAM,mBAAmB,CAAA;AAE/G,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AA0BlD,OAAO,0BAA0B,CAAA;AASjC,KAAK,WAAW,GAAG;IACf,UAAU,EAAE,OAAO,CAAA;CACtB,CAAA;AAKD,wBAAsB,OAAO,CACzB,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,yBAAyB,GAAG,IAAI,EAC/C,cAAc,EAAE,cAAc,iBA0DjC;AAyBD,wBAAsB,oBAAoB,CACtC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,yBAAyB,EACxC,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,WAAW,qDA4DpB"}
+{"version":3,"file":"hydrate.d.ts","sourceRoot":"","sources":["../../src/hydrate/hydrate.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAQnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAoBxD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAM7C,OAAO,EAAE,yBAAyB,EAAoD,MAAM,mBAAmB,CAAA;AAE/G,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAmBlD,OAAO,EAC4B,KAAK,uBAAuB,EAC9D,MAAM,oCAAoC,CAAA;AAQ3C,OAAO,0BAA0B,CAAA;AASjC,MAAM,MAAM,WAAW,GAAG;IACtB,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,uBAAuB,EAAE,CAAA;CACxC,CAAA;AAKD,wBAAsB,OAAO,CACzB,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,yBAAyB,GAAG,IAAI,EAC/C,cAAc,EAAE,cAAc,iBA2DjC;AAyBD,wBAAsB,oBAAoB,CACtC,aAAa,SAAS,yBAAyB,CAAC,GAAG,EAAE,GAAG,CAAC,EAEzD,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,WAAW,EAIjB,KAAK,GAAE,YAAY,CAAC,aAAa,CAAC,CAAC,OAAO,CAA8C,EAAE,8IAA8I;AACxO,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,SAAS,CAAC,EAAE,OAAO,GACpB,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC,CA6DtC"}