@liquid-glass-forge/dom 0.0.0-stage → 0.1.0-rc.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/scene.js ADDED
@@ -0,0 +1,494 @@
1
+ import { MAX_PIXELS, MAX_SURFACES } from '@liquid-glass-forge/core';
2
+ import { mountGlassHost } from './host.js';
3
+ export class SceneError extends Error {
4
+ code;
5
+ constructor(code, message, options) {
6
+ super(message, options);
7
+ this.code = code;
8
+ this.name = 'SceneError';
9
+ }
10
+ }
11
+ /** One deadline per active operation. Late owned results are reclaimed even after cancellation. */
12
+ function bounded(work, parent, ms, late) {
13
+ return new Promise((resolve, reject) => {
14
+ const controller = new AbortController();
15
+ let settled = false;
16
+ const finish = (cause, value, failed = false) => {
17
+ if (settled)
18
+ return;
19
+ settled = true;
20
+ clearTimeout(timer);
21
+ parent.removeEventListener('abort', abort);
22
+ if (failed)
23
+ reject(cause instanceof Error ? cause : new SceneError('FAILED', 'Scene operation rejected', { cause }));
24
+ else
25
+ resolve(value);
26
+ };
27
+ const abort = () => { controller.abort(parent.reason); finish(parent.reason, undefined, true); };
28
+ const timer = setTimeout(() => { const cause = new SceneError('TIMEOUT', 'Scene operation timed out'); controller.abort(cause); finish(cause, undefined, true); }, ms);
29
+ parent.addEventListener('abort', abort, { once: true });
30
+ if (parent.aborted) {
31
+ abort();
32
+ return;
33
+ }
34
+ try {
35
+ Promise.resolve(work(controller.signal)).then(value => { if (settled)
36
+ late(value);
37
+ else
38
+ finish(undefined, value); }, cause => finish(cause, undefined, true));
39
+ }
40
+ catch (cause) {
41
+ finish(cause, undefined, true);
42
+ }
43
+ });
44
+ }
45
+ /** Shared source ownership and dirty scheduling; the default is material-only. No animation clock. */
46
+ export class GlassScene {
47
+ #options;
48
+ #timeout;
49
+ #state = 'initializing';
50
+ #ready;
51
+ #generation = 0;
52
+ #revision = 0;
53
+ #controller = new AbortController();
54
+ #job;
55
+ #entries = new Set();
56
+ #dirty = new Set();
57
+ #nextId = 0;
58
+ #queued = false;
59
+ #busy = false;
60
+ #prime;
61
+ #initialCleanup;
62
+ #unsubscribe;
63
+ #sourceDestroyed = false;
64
+ #subscribing = false;
65
+ #doc;
66
+ #resize;
67
+ #intersection;
68
+ #listeners = [];
69
+ #externalAbort;
70
+ constructor(options = {}) {
71
+ if (!!options.source !== !!options.renderer || (options.source && typeof options.source.read !== 'function') ||
72
+ (options.renderer && typeof options.renderer.render !== 'function') || (options.ownsSource && !options.source?.destroy)) {
73
+ throw new SceneError('INVALID_OPTIONS', 'Use a source/renderer pair and an explicitly destroyable owned source');
74
+ }
75
+ const timeout = options.timeoutMs ?? 5000;
76
+ if (!Number.isFinite(timeout) || timeout < 1 || timeout > 60000)
77
+ throw new SceneError('INVALID_OPTIONS', 'timeoutMs must be 1–60000');
78
+ this.#options = { ...options };
79
+ this.#timeout = timeout;
80
+ this.#doc = typeof document === 'undefined' ? undefined : document;
81
+ this.#externalAbort = () => this.#fail(new SceneError('ABORTED', 'Scene aborted'));
82
+ options.signal?.addEventListener('abort', this.#externalAbort, { once: true });
83
+ this.#start();
84
+ if (options.signal?.aborted)
85
+ this.#externalAbort();
86
+ }
87
+ get ready() { return this.#ready; }
88
+ get state() { return this.#state; }
89
+ #report(cause) { try {
90
+ this.#options.onError?.(cause);
91
+ }
92
+ catch { /* Error observers do not own cleanup. */ } }
93
+ #release(fn) { try {
94
+ fn?.();
95
+ }
96
+ catch (cause) {
97
+ this.#report(cause);
98
+ } }
99
+ #releaseFrame(frame) { this.#release(frame?.release ? () => frame.release() : undefined); }
100
+ #alive() { if (this.#state === 'destroyed')
101
+ throw new SceneError('DESTROYED', 'Scene destroyed'); }
102
+ #stopJob(reason) { this.#job?.abort(reason); }
103
+ #sourceDispose() {
104
+ if (this.#options.ownsSource && !this.#sourceDestroyed) {
105
+ this.#sourceDestroyed = true;
106
+ this.#release(() => this.#options.source?.destroy?.());
107
+ }
108
+ }
109
+ #stopObservers() {
110
+ const resize = this.#resize, intersection = this.#intersection;
111
+ this.#resize = undefined;
112
+ this.#intersection = undefined;
113
+ this.#release(() => resize?.disconnect());
114
+ this.#release(() => intersection?.disconnect());
115
+ for (const off of this.#listeners.splice(0))
116
+ this.#release(off);
117
+ const off = this.#unsubscribe;
118
+ this.#unsubscribe = undefined;
119
+ this.#release(off);
120
+ }
121
+ #fail(cause) {
122
+ if (this.#state === 'destroyed' || this.#state === 'failed')
123
+ return;
124
+ this.#state = 'failed';
125
+ this.#generation++;
126
+ this.#revision++;
127
+ this.#controller.abort(cause);
128
+ this.#stopJob(new SceneError('FAILED', 'Scene failed'));
129
+ this.#dirty.clear();
130
+ this.#prime = undefined;
131
+ this.#stopObservers();
132
+ const cleanup = this.#initialCleanup;
133
+ this.#initialCleanup = undefined;
134
+ this.#release(cleanup);
135
+ for (const e of this.#entries) {
136
+ try {
137
+ e.host.clear();
138
+ }
139
+ catch (error) {
140
+ this.#report(error);
141
+ }
142
+ }
143
+ this.#sourceDispose();
144
+ this.#report(cause);
145
+ }
146
+ #start() {
147
+ this.#state = 'initializing';
148
+ const generation = ++this.#generation;
149
+ this.#controller = new AbortController();
150
+ if (this.#options.signal?.aborted)
151
+ this.#controller.abort(new SceneError('ABORTED', 'Scene aborted'));
152
+ const signal = this.#controller.signal;
153
+ this.#ready = (async () => {
154
+ const initialize = this.#options.renderer?.initialize;
155
+ if (initialize) {
156
+ const cleanup = await bounded(s => initialize.call(this.#options.renderer, s), signal, this.#timeout, value => this.#release(typeof value === 'function' ? value : undefined));
157
+ if (generation !== this.#generation || signal.aborted) {
158
+ this.#release(typeof cleanup === 'function' ? cleanup : undefined);
159
+ throw signal.reason;
160
+ }
161
+ if (cleanup !== undefined && typeof cleanup !== 'function')
162
+ throw new SceneError('INVALID_OPTIONS', 'Initialize must return a cleanup function or void');
163
+ this.#initialCleanup = typeof cleanup === 'function' ? cleanup : undefined;
164
+ }
165
+ // Hidden documents need a usable material baseline, not background source acquisition.
166
+ if (this.#options.source && !this.#doc?.hidden) {
167
+ const snapshot = await bounded(s => this.#options.source.read({ signal: s }), signal, this.#timeout, () => { });
168
+ if (generation !== this.#generation || signal.aborted)
169
+ throw signal.reason;
170
+ this.#prime = snapshot;
171
+ }
172
+ if (generation !== this.#generation || signal.aborted)
173
+ throw signal.reason;
174
+ this.#state = 'ready';
175
+ this.#observe();
176
+ this.#syncSubscription();
177
+ this.#queue();
178
+ })().catch(cause => {
179
+ if (generation === this.#generation && this.#state !== 'destroyed' && this.#state !== 'paused')
180
+ this.#fail(cause);
181
+ throw cause;
182
+ });
183
+ void this.#ready.catch(() => { });
184
+ }
185
+ #visible(e) {
186
+ const element = e.host.element, view = element.ownerDocument.defaultView;
187
+ if (!e.live || !element.isConnected || !e.intersecting || !view || !element.clientWidth || !element.clientHeight)
188
+ return false;
189
+ if (view.getComputedStyle(element).visibility === 'hidden')
190
+ return false;
191
+ const r = element.getBoundingClientRect();
192
+ return r.bottom > 0 && r.right > 0 && r.top < view.innerHeight && r.left < view.innerWidth;
193
+ }
194
+ #active() { return this.#state === 'ready' && !this.#doc?.hidden; }
195
+ #syncSubscription() {
196
+ const active = () => this.#active() && [...this.#entries].some(e => this.#visible(e));
197
+ if (active() && !this.#unsubscribe && !this.#subscribing && this.#options.source?.subscribe) {
198
+ this.#subscribing = true;
199
+ try {
200
+ const off = this.#options.source.subscribe(() => { if (this.#state !== 'destroyed' && this.#state !== 'failed')
201
+ this.invalidate(); });
202
+ if (typeof off !== 'function')
203
+ throw new SceneError('INVALID_OPTIONS', 'subscribe must return an unsubscribe function');
204
+ if (active())
205
+ this.#unsubscribe = off;
206
+ else
207
+ this.#release(off);
208
+ }
209
+ catch (cause) {
210
+ this.#fail(cause);
211
+ }
212
+ finally {
213
+ this.#subscribing = false;
214
+ }
215
+ }
216
+ else if (!active() && this.#unsubscribe) {
217
+ const off = this.#unsubscribe;
218
+ this.#unsubscribe = undefined;
219
+ this.#release(off);
220
+ }
221
+ }
222
+ #observe() {
223
+ const doc = this.#doc, view = doc?.defaultView;
224
+ if (!doc || !view || !this.#entries.size || this.#listeners.length || this.#state !== 'ready')
225
+ return;
226
+ const listen = (target, name, fn, capture = false) => {
227
+ target.addEventListener(name, fn, { passive: true, capture });
228
+ this.#listeners.push(() => target.removeEventListener(name, fn, capture));
229
+ };
230
+ const wake = () => this.invalidate();
231
+ listen(view, 'scroll', wake, true);
232
+ listen(view, 'resize', wake);
233
+ listen(doc, 'visibilitychange', () => {
234
+ if (doc.hidden) {
235
+ this.#revision++;
236
+ this.#prime = undefined;
237
+ this.#stopJob(new SceneError('SUPERSEDED', 'Document hidden'));
238
+ this.#syncSubscription();
239
+ }
240
+ else
241
+ this.invalidate();
242
+ });
243
+ if (typeof view.ResizeObserver === 'function') {
244
+ this.#resize = new view.ResizeObserver(entries => {
245
+ for (const item of entries)
246
+ for (const e of this.#entries)
247
+ if (e.host.element === item.target) {
248
+ const size = e.host.measure();
249
+ if (e.width !== size.width || e.height !== size.height) {
250
+ e.width = size.width;
251
+ e.height = size.height;
252
+ this.#invalidate(e);
253
+ }
254
+ }
255
+ });
256
+ }
257
+ if (typeof view.IntersectionObserver === 'function') {
258
+ this.#intersection = new view.IntersectionObserver(entries => {
259
+ for (const item of entries)
260
+ for (const e of this.#entries)
261
+ if (e.host.element === item.target && e.intersecting !== item.isIntersecting) {
262
+ e.intersecting = item.isIntersecting;
263
+ this.#invalidate(e);
264
+ }
265
+ this.#syncSubscription();
266
+ });
267
+ }
268
+ for (const e of this.#entries) {
269
+ this.#resize?.observe(e.host.element);
270
+ this.#intersection?.observe(e.host.element);
271
+ }
272
+ }
273
+ #invalidate(e) {
274
+ if (!e.live || this.#state === 'destroyed' || this.#state === 'failed')
275
+ return;
276
+ this.#revision++;
277
+ this.#prime = undefined;
278
+ this.#dirty.add(e);
279
+ this.#syncSubscription();
280
+ this.#queue();
281
+ }
282
+ #queue() {
283
+ if (this.#queued || this.#busy || !this.#active() || !this.#options.renderer || ![...this.#dirty].some(e => this.#visible(e)))
284
+ return;
285
+ this.#queued = true;
286
+ queueMicrotask(() => { this.#queued = false; void this.#flush().catch(cause => this.#fail(cause)); });
287
+ }
288
+ async #flush() {
289
+ if (this.#busy || !this.#active() || !this.#options.renderer || !this.#options.source)
290
+ return;
291
+ const batch = [...this.#dirty].filter(e => this.#visible(e));
292
+ if (!batch.length)
293
+ return;
294
+ batch.forEach(e => this.#dirty.delete(e));
295
+ this.#busy = true;
296
+ const generation = this.#generation, revision = this.#revision, controller = new AbortController();
297
+ this.#job = controller;
298
+ try {
299
+ let totalPixels = 0;
300
+ for (const e of batch) {
301
+ const size = e.host.measure(), dpr = e.host.element.ownerDocument.defaultView.devicePixelRatio || 1;
302
+ totalPixels += Math.round(size.width * dpr) * Math.round(size.height * dpr);
303
+ }
304
+ if (!Number.isSafeInteger(totalPixels) || totalPixels > MAX_PIXELS)
305
+ throw new SceneError('INVALID_OPTIONS', 'Scene batch exceeds core output pixel limit');
306
+ const snapshot = this.#prime ?? await bounded(s => this.#options.source.read({ signal: s }), controller.signal, this.#timeout, () => { });
307
+ this.#prime = undefined;
308
+ if (this.#options.renderer.renderBatch) {
309
+ if (controller.signal.aborted || generation !== this.#generation || revision !== this.#revision || !this.#active())
310
+ return;
311
+ const selected = batch.filter(e => this.#visible(e));
312
+ if (!selected.length)
313
+ return;
314
+ const requests = selected.map(e => {
315
+ const size = e.host.measure(), view = e.host.element.ownerDocument.defaultView, dpr = view.devicePixelRatio || 1;
316
+ const box = e.host.element.getBoundingClientRect();
317
+ e.width = size.width;
318
+ e.height = size.height;
319
+ return Object.freeze({ snapshot, width: Math.round(size.width * dpr), height: Math.round(size.height * dpr), dpr, id: e.id,
320
+ rect: Object.freeze({ x: box.x, y: box.y, width: box.width, height: box.height }),
321
+ prepareTarget: (w, h) => { if (controller.signal.aborted || generation !== this.#generation || revision !== this.#revision || !this.#active() || !e.live)
322
+ throw new SceneError('SUPERSEDED', 'Native target is no longer current'); return e.host.prepareCanvas(w, h); } });
323
+ });
324
+ const frames = await bounded(s => this.#options.renderer.renderBatch(requests, s), controller.signal, this.#timeout, values => values.forEach(value => this.#releaseFrame(value)));
325
+ try {
326
+ if (frames.length !== selected.length)
327
+ throw new SceneError('FAILED', 'Native batch output count mismatch');
328
+ frames.forEach((frame, i) => { const e = selected[i]; if (generation === this.#generation && revision === this.#revision && this.#active() && this.#visible(e))
329
+ e.host.present(frame); });
330
+ }
331
+ finally {
332
+ frames.forEach(frame => this.#releaseFrame(frame));
333
+ }
334
+ return;
335
+ }
336
+ for (const e of batch) {
337
+ if (generation !== this.#generation || revision !== this.#revision || !this.#active() || !this.#visible(e))
338
+ break;
339
+ const size = e.host.measure(), view = e.host.element.ownerDocument.defaultView;
340
+ const dpr = view.devicePixelRatio || 1, width = Math.round(size.width * dpr), height = Math.round(size.height * dpr);
341
+ if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width < 1 || height < 1 || width * height > MAX_PIXELS)
342
+ throw new SceneError('INVALID_OPTIONS', 'Host backing exceeds core limits');
343
+ e.width = size.width;
344
+ e.height = size.height;
345
+ const box = e.host.element.getBoundingClientRect(), rect = Object.freeze({ x: box.x, y: box.y, width: box.width, height: box.height });
346
+ const frame = await bounded(s => this.#options.renderer.render(Object.freeze({ snapshot, width, height, dpr, rect }), s), controller.signal, this.#timeout, value => this.#releaseFrame(value));
347
+ try {
348
+ if (generation === this.#generation && revision === this.#revision && this.#active() && this.#visible(e))
349
+ e.host.present(frame);
350
+ }
351
+ finally {
352
+ this.#releaseFrame(frame);
353
+ }
354
+ }
355
+ }
356
+ catch (cause) {
357
+ if (generation === this.#generation && revision === this.#revision && this.#active())
358
+ this.#fail(cause);
359
+ }
360
+ finally {
361
+ if (generation === this.#generation && revision !== this.#revision && this.#state !== 'failed')
362
+ for (const e of batch)
363
+ if (e.live)
364
+ this.#dirty.add(e);
365
+ if (this.#job === controller)
366
+ this.#job = undefined;
367
+ this.#busy = false;
368
+ this.#syncSubscription();
369
+ this.#queue();
370
+ }
371
+ }
372
+ attach(element, options = {}) {
373
+ this.#alive();
374
+ if (this.#doc && this.#doc !== element.ownerDocument)
375
+ throw new SceneError('INVALID_OPTIONS', 'A scene uses one document');
376
+ this.#doc = element.ownerDocument;
377
+ if (this.#entries.size >= MAX_SURFACES)
378
+ throw new SceneError('INVALID_OPTIONS', 'At most sixteen hosts per scene');
379
+ const host = mountGlassHost(element, options), size = host.measure();
380
+ const e = { id: 'host_' + ++this.#nextId, host, live: true, intersecting: true, width: size.width, height: size.height };
381
+ this.#entries.add(e);
382
+ this.#dirty.add(e);
383
+ try {
384
+ const hadObservers = this.#listeners.length > 0;
385
+ this.#observe();
386
+ if (hadObservers) {
387
+ this.#resize?.observe(element);
388
+ this.#intersection?.observe(element);
389
+ }
390
+ this.#syncSubscription();
391
+ this.#queue();
392
+ }
393
+ catch (cause) {
394
+ this.#entries.delete(e);
395
+ this.#dirty.delete(e);
396
+ host.dispose();
397
+ this.#fail(cause);
398
+ throw cause;
399
+ }
400
+ return Object.freeze({ host,
401
+ update: (next = {}) => { if (!e.live)
402
+ throw new SceneError('DESTROYED', 'Attachment disposed'); if (next.material !== undefined)
403
+ host.setMaterial(next.material); this.#invalidate(e); },
404
+ invalidate: () => { if (!e.live)
405
+ throw new SceneError('DESTROYED', 'Attachment disposed'); this.#invalidate(e); },
406
+ dispose: () => {
407
+ if (!e.live)
408
+ return;
409
+ e.live = false;
410
+ this.#revision++;
411
+ this.#entries.delete(e);
412
+ this.#dirty.delete(e);
413
+ this.#release(() => this.#options.renderer?.releaseSurface?.(e.id));
414
+ this.#release(() => this.#resize?.unobserve(element));
415
+ this.#release(() => this.#intersection?.unobserve(element));
416
+ this.#release(() => host.dispose());
417
+ this.#syncSubscription();
418
+ if (!this.#entries.size) {
419
+ this.#stopJob(new SceneError('SUPERSEDED', 'No attached hosts'));
420
+ this.#stopObservers();
421
+ }
422
+ } });
423
+ }
424
+ update(options = {}) {
425
+ this.#alive();
426
+ if (options.material !== undefined)
427
+ for (const e of this.#entries)
428
+ e.host.setMaterial(options.material);
429
+ this.invalidate();
430
+ }
431
+ invalidate() {
432
+ this.#alive();
433
+ if (this.#state === 'failed')
434
+ return;
435
+ this.#revision++;
436
+ this.#prime = undefined;
437
+ for (const e of this.#entries)
438
+ this.#dirty.add(e);
439
+ this.#syncSubscription();
440
+ this.#queue();
441
+ }
442
+ pause() {
443
+ this.#alive();
444
+ if (this.#state === 'paused' || this.#state === 'failed')
445
+ return;
446
+ this.#state = 'paused';
447
+ this.#generation++;
448
+ this.#revision++;
449
+ const reason = new SceneError('PAUSED', 'Scene paused');
450
+ this.#controller.abort(reason);
451
+ this.#stopJob(reason);
452
+ this.#prime = undefined;
453
+ this.#stopObservers();
454
+ const cleanup = this.#initialCleanup;
455
+ this.#initialCleanup = undefined;
456
+ this.#release(cleanup);
457
+ }
458
+ resume() { this.#alive(); if (this.#state === 'paused') {
459
+ for (const e of this.#entries)
460
+ this.#dirty.add(e);
461
+ this.#start();
462
+ } }
463
+ dispose() {
464
+ if (this.#state === 'destroyed')
465
+ return;
466
+ this.#state = 'destroyed';
467
+ this.#generation++;
468
+ this.#revision++;
469
+ const reason = new SceneError('DESTROYED', 'Scene disposed');
470
+ this.#controller.abort(reason);
471
+ this.#stopJob(reason);
472
+ this.#stopObservers();
473
+ const cleanup = this.#initialCleanup;
474
+ this.#initialCleanup = undefined;
475
+ this.#release(cleanup);
476
+ for (const e of this.#entries) {
477
+ e.live = false;
478
+ try {
479
+ e.host.dispose();
480
+ }
481
+ catch (cause) {
482
+ this.#report(cause);
483
+ }
484
+ }
485
+ this.#entries.clear();
486
+ this.#dirty.clear();
487
+ this.#prime = undefined;
488
+ this.#sourceDispose();
489
+ if (this.#externalAbort)
490
+ this.#options.signal?.removeEventListener('abort', this.#externalAbort);
491
+ this.#externalAbort = undefined;
492
+ }
493
+ }
494
+ export function createGlassScene(options = {}) { return new GlassScene(options); }
@@ -0,0 +1,23 @@
1
+ /* Declarative baseline also works without JavaScript or an optical renderer. */
2
+ .lgf-host { position: relative; isolation: isolate; }
3
+ .lgf-surface {
4
+ display: block; box-sizing: border-box; margin: 0; border: 0; padding: 0;
5
+ position: absolute; inset: 0; width: 100%; height: 100%; z-index: -1;
6
+ pointer-events: none; border-radius: inherit;
7
+ background-color: var(--lgf-tint, rgba(245, 248, 255, .78));
8
+ -webkit-backdrop-filter: blur(var(--lgf-blur, 12px)) saturate(1.1);
9
+ backdrop-filter: blur(var(--lgf-blur, 12px)) saturate(1.1);
10
+ }
11
+ .lgf-surface[data-lgf-material="opaque"] {
12
+ opacity: 0 !important;
13
+ background-color: Canvas !important;
14
+ -webkit-backdrop-filter: none !important; backdrop-filter: none !important;
15
+ }
16
+ .lgf-host:has(> .lgf-surface[data-lgf-material="opaque"]) {
17
+ background-color: Canvas !important;
18
+ color: CanvasText;
19
+ }
20
+ @media (prefers-reduced-transparency: reduce), (forced-colors: active) {
21
+ .lgf-surface { opacity: 0 !important; background-color: Canvas !important; -webkit-backdrop-filter: none !important; backdrop-filter: none !important; }
22
+ .lgf-host { background-color: Canvas !important; color: CanvasText; }
23
+ }
package/package.json CHANGED
@@ -1,6 +1,41 @@
1
1
  {
2
2
  "name": "@liquid-glass-forge/dom",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
6
- }
3
+ "version": "0.1.0-rc.2",
4
+ "description": "Experimental explicit sources, coordinates and vanilla host lifecycle for Liquid Glass Forge",
5
+ "private": false,
6
+ "type": "module",
7
+ "sideEffects": [
8
+ "./dist/styles.css"
9
+ ],
10
+ "license": "MIT",
11
+ "engines": {
12
+ "node": ">=20.19.0"
13
+ },
14
+ "exports": {
15
+ ".": {
16
+ "types": "./dist/index.d.ts",
17
+ "import": "./dist/index.js",
18
+ "default": "./dist/index.js"
19
+ },
20
+ "./styles.css": "./dist/styles.css"
21
+ },
22
+ "files": [
23
+ "dist",
24
+ "LICENSE",
25
+ "NOTICE",
26
+ "README.md"
27
+ ],
28
+ "dependencies": {
29
+ "@liquid-glass-forge/core": "0.1.0-rc.2",
30
+ "@liquid-glass-forge/cpu": "0.1.0-rc.2"
31
+ },
32
+ "homepage": "https://namipsg.github.io/liquid-glass-forge/#playground",
33
+ "repository": {
34
+ "type": "git",
35
+ "url": "git+https://github.com/namipsg/liquid-glass-forge.git",
36
+ "directory": "packages/dom"
37
+ },
38
+ "publishConfig": {
39
+ "access": "public"
40
+ }
41
+ }