@melite/harness-provisioner 0.0.0-stage → 0.1.4-alpha

package/LICENSE

@@ -0,0 +1,557 @@
+                     Server Side Public License
+                     VERSION 1, OCTOBER 16, 2018
+
+                    Copyright © 2018 MongoDB, Inc.
+
+  Everyone is permitted to copy and distribute verbatim copies of this
+  license document, but changing it is not allowed.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+  
+  “This License” refers to Server Side Public License.
+
+  “Copyright” also means copyright-like laws that apply to other kinds of
+  works, such as semiconductor masks.
+
+  “The Program” refers to any copyrightable work licensed under this
+  License.  Each licensee is addressed as “you”. “Licensees” and
+  “recipients” may be individuals or organizations.
+
+  To “modify” a work means to copy from or adapt all or part of the work in
+  a fashion requiring copyright permission, other than the making of an
+  exact copy. The resulting work is called a “modified version” of the
+  earlier work or a work “based on” the earlier work.
+
+  A “covered work” means either the unmodified Program or a work based on
+  the Program.
+
+  To “propagate” a work means to do anything with it that, without
+  permission, would make you directly or secondarily liable for
+  infringement under applicable copyright law, except executing it on a
+  computer or modifying a private copy. Propagation includes copying,
+  distribution (with or without modification), making available to the
+  public, and in some countries other activities as well.
+
+  To “convey” a work means any kind of propagation that enables other
+  parties to make or receive copies. Mere interaction with a user through a
+  computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays “Appropriate Legal Notices” to the
+  extent that it includes a convenient and prominently visible feature that
+  (1) displays an appropriate copyright notice, and (2) tells the user that
+  there is no warranty for the work (except to the extent that warranties
+  are provided), that licensees may convey the work under this License, and
+  how to view a copy of this License. If the interface presents a list of
+  user commands or options, such as a menu, a prominent item in the list
+  meets this criterion.
+
+  1. Source Code.
+
+  The “source code” for a work means the preferred form of the work for
+  making modifications to it. “Object code” means any non-source form of a
+  work.
+
+  A “Standard Interface” means an interface that either is an official
+  standard defined by a recognized standards body, or, in the case of
+  interfaces specified for a particular programming language, one that is
+  widely used among developers working in that language.  The “System
+  Libraries” of an executable work include anything, other than the work as
+  a whole, that (a) is included in the normal form of packaging a Major
+  Component, but which is not part of that Major Component, and (b) serves
+  only to enable use of the work with that Major Component, or to implement
+  a Standard Interface for which an implementation is available to the
+  public in source code form. A “Major Component”, in this context, means a
+  major essential component (kernel, window system, and so on) of the
+  specific operating system (if any) on which the executable work runs, or
+  a compiler used to produce the work, or an object code interpreter used
+  to run it.
+
+  The “Corresponding Source” for a work in object code form means all the
+  source code needed to generate, install, and (for an executable work) run
+  the object code and to modify the work, including scripts to control
+  those activities. However, it does not include the work's System
+  Libraries, or general-purpose tools or generally available free programs
+  which are used unmodified in performing those activities but which are
+  not part of the work. For example, Corresponding Source includes
+  interface definition files associated with source files for the work, and
+  the source code for shared libraries and dynamically linked subprograms
+  that the work is specifically designed to require, such as by intimate
+  data communication or control flow between those subprograms and other
+  parts of the work.
+
+  The Corresponding Source need not include anything that users can
+  regenerate automatically from other parts of the Corresponding Source.
+
+  The Corresponding Source for a work in source code form is that same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+  copyright on the Program, and are irrevocable provided the stated
+  conditions are met. This License explicitly affirms your unlimited
+  permission to run the unmodified Program, subject to section 13. The
+  output from running a covered work is covered by this License only if the
+  output, given its content, constitutes a covered work. This License
+  acknowledges your rights of fair use or other equivalent, as provided by
+  copyright law.  Subject to section 13, you may make, run and propagate
+  covered works that you do not convey, without conditions so long as your
+  license otherwise remains in force. You may convey covered works to
+  others for the sole purpose of having them make modifications exclusively
+  for you, or provide you with facilities for running those works, provided
+  that you comply with the terms of this License in conveying all
+  material for which you do not control copyright. Those thus making or
+  running the covered works for you must do so exclusively on your
+  behalf, under your direction and control, on terms that prohibit them
+  from making any copies of your copyrighted material outside their
+  relationship with you.
+
+  Conveying under any other circumstances is permitted solely under the
+  conditions stated below. Sublicensing is not allowed; section 10 makes it
+  unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+  measure under any applicable law fulfilling obligations under article 11
+  of the WIPO copyright treaty adopted on 20 December 1996, or similar laws
+  prohibiting or restricting circumvention of such measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+  circumvention of technological measures to the extent such circumvention is
+  effected by exercising rights under this License with respect to the
+  covered work, and you disclaim any intention to limit operation or
+  modification of the work as a means of enforcing, against the work's users,
+  your or third parties' legal rights to forbid circumvention of
+  technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+  receive it, in any medium, provided that you conspicuously and
+  appropriately publish on each copy an appropriate copyright notice; keep
+  intact all notices stating that this License and any non-permissive terms
+  added in accord with section 7 apply to the code; keep intact all notices
+  of the absence of any warranty; and give all recipients a copy of this
+  License along with the Program.  You may charge any price or no price for
+  each copy that you convey, and you may offer support or warranty
+  protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+  produce it from the Program, in the form of source code under the terms
+  of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified it,
+    and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is released
+    under this License and any conditions added under section 7. This
+    requirement modifies the requirement in section 4 to “keep intact all
+    notices”.
+
+    c) You must license the entire work, as a whole, under this License to
+    anyone who comes into possession of a copy. This License will therefore
+    apply, along with any applicable section 7 additional terms, to the
+    whole of the work, and all its parts, regardless of how they are
+    packaged. This License gives no permission to license the work in any
+    other way, but it does not invalidate such permission if you have
+    separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your work
+    need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+  works, which are not by their nature extensions of the covered work, and
+  which are not combined with it such as to form a larger program, in or on
+  a volume of a storage or distribution medium, is called an “aggregate” if
+  the compilation and its resulting copyright are not used to limit the
+  access or legal rights of the compilation's users beyond what the
+  individual works permit. Inclusion of a covered work in an aggregate does
+  not cause this License to apply to the other parts of the aggregate.
+  
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms of
+  sections 4 and 5, provided that you also convey the machine-readable
+  Corresponding Source under the terms of this License, in one of these
+  ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium customarily
+    used for software interchange.
+   
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a written
+    offer, valid for at least three years and valid for as long as you
+    offer spare parts or customer support for that product model, to give
+    anyone who possesses the object code either (1) a copy of the
+    Corresponding Source for all the software in the product that is
+    covered by this License, on a durable physical medium customarily used
+    for software interchange, for a price no more than your reasonable cost
+    of physically performing this conveying of source, or (2) access to
+    copy the Corresponding Source from a network server at no charge.
+   
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source. This alternative is
+    allowed only occasionally and noncommercially, and only if you received
+    the object code with such an offer, in accord with subsection 6b.
+   
+    d) Convey the object code by offering access from a designated place
+    (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge. You need not require recipients to copy the
+    Corresponding Source along with the object code. If the place to copy
+    the object code is a network server, the Corresponding Source may be on
+    a different server (operated by you or a third party) that supports
+    equivalent copying facilities, provided you maintain clear directions
+    next to the object code saying where to find the Corresponding Source.
+    Regardless of what server hosts the Corresponding Source, you remain
+    obligated to ensure that it is available for as long as needed to
+    satisfy these requirements.
+   
+    e) Convey the object code using peer-to-peer transmission, provided you
+    inform other peers where the object code and Corresponding Source of
+    the work are being offered to the general public at no charge under
+    subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+  from the Corresponding Source as a System Library, need not be included
+  in conveying the object code work.
+
+  A “User Product” is either (1) a “consumer product”, which means any
+  tangible personal property which is normally used for personal, family,
+  or household purposes, or (2) anything designed or sold for incorporation
+  into a dwelling. In determining whether a product is a consumer product,
+  doubtful cases shall be resolved in favor of coverage. For a particular
+  product received by a particular user, “normally used” refers to a
+  typical or common use of that class of product, regardless of the status
+  of the particular user or of the way in which the particular user
+  actually uses, or expects or is expected to use, the product. A product
+  is a consumer product regardless of whether the product has substantial
+  commercial, industrial or non-consumer uses, unless such uses represent
+  the only significant mode of use of the product.
+
+  “Installation Information” for a User Product means any methods,
+  procedures, authorization keys, or other information required to install
+  and execute modified versions of a covered work in that User Product from
+  a modified version of its Corresponding Source. The information must
+  suffice to ensure that the continued functioning of the modified object
+  code is in no case prevented or interfered with solely because
+  modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+  specifically for use in, a User Product, and the conveying occurs as part
+  of a transaction in which the right of possession and use of the User
+  Product is transferred to the recipient in perpetuity or for a fixed term
+  (regardless of how the transaction is characterized), the Corresponding
+  Source conveyed under this section must be accompanied by the
+  Installation Information. But this requirement does not apply if neither
+  you nor any third party retains the ability to install modified object
+  code on the User Product (for example, the work has been installed in
+  ROM).
+
+  The requirement to provide Installation Information does not include a
+  requirement to continue to provide support service, warranty, or updates
+  for a work that has been modified or installed by the recipient, or for
+  the User Product in which it has been modified or installed. Access
+  to a network may be denied when the modification itself materially
+  and adversely affects the operation of the network or violates the
+  rules and protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided, in
+  accord with this section must be in a format that is publicly documented
+  (and with an implementation available to the public in source code form),
+  and must require no special password or key for unpacking, reading or
+  copying.
+
+  7. Additional Terms.
+
+  “Additional permissions” are terms that supplement the terms of this
+  License by making exceptions from one or more of its conditions.
+  Additional permissions that are applicable to the entire Program shall be
+  treated as though they were included in this License, to the extent that
+  they are valid under applicable law. If additional permissions apply only
+  to part of the Program, that part may be used separately under those
+  permissions, but the entire Program remains governed by this License
+  without regard to the additional permissions.  When you convey a copy of
+  a covered work, you may at your option remove any additional permissions
+  from that copy, or from any part of it. (Additional permissions may be
+  written to require their own removal in certain cases when you modify the
+  work.) You may place additional permissions on material, added by you to
+  a covered work, for which you have or can give appropriate copyright
+  permission.
+
+  Notwithstanding any other provision of this License, for material you add
+  to a covered work, you may (if authorized by the copyright holders of
+  that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some trade
+    names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that material
+    by anyone who conveys the material (or modified versions of it) with
+    contractual assumptions of liability to the recipient, for any
+    liability that these contractual assumptions directly impose on those
+    licensors and authors.
+
+  All other non-permissive additional terms are considered “further
+  restrictions” within the meaning of section 10. If the Program as you
+  received it, or any part of it, contains a notice stating that it is
+  governed by this License along with a term that is a further restriction,
+  you may remove that term. If a license document contains a further
+  restriction but permits relicensing or conveying under this License, you
+  may add to a covered work material governed by the terms of that license
+  document, provided that the further restriction does not survive such
+  relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you must
+  place, in the relevant source files, a statement of the additional terms
+  that apply to those files, or a notice indicating where to find the
+  applicable terms.  Additional terms, permissive or non-permissive, may be
+  stated in the form of a separately written license, or stated as
+  exceptions; the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+  provided under this License. Any attempt otherwise to propagate or modify
+  it is void, and will automatically terminate your rights under this
+  License (including any patent licenses granted under the third paragraph
+  of section 11).
+
+  However, if you cease all violation of this License, then your license
+  from a particular copyright holder is reinstated (a) provisionally,
+  unless and until the copyright holder explicitly and finally terminates
+  your license, and (b) permanently, if the copyright holder fails to
+  notify you of the violation by some reasonable means prior to 60 days
+  after the cessation.
+
+  Moreover, your license from a particular copyright holder is reinstated
+  permanently if the copyright holder notifies you of the violation by some
+  reasonable means, this is the first time you have received notice of
+  violation of this License (for any work) from that copyright holder, and
+  you cure the violation prior to 30 days after your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+  licenses of parties who have received copies or rights from you under
+  this License. If your rights have been terminated and not permanently
+  reinstated, you do not qualify to receive new licenses for the same
+  material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or run a
+  copy of the Program. Ancillary propagation of a covered work occurring
+  solely as a consequence of using peer-to-peer transmission to receive a
+  copy likewise does not require acceptance. However, nothing other than
+  this License grants you permission to propagate or modify any covered
+  work. These actions infringe copyright if you do not accept this License.
+  Therefore, by modifying or propagating a covered work, you indicate your
+  acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically receives
+  a license from the original licensors, to run, modify and propagate that
+  work, subject to this License. You are not responsible for enforcing
+  compliance by third parties with this License.
+
+  An “entity transaction” is a transaction transferring control of an
+  organization, or substantially all assets of one, or subdividing an
+  organization, or merging organizations. If propagation of a covered work
+  results from an entity transaction, each party to that transaction who
+  receives a copy of the work also receives whatever licenses to the work
+  the party's predecessor in interest had or could give under the previous
+  paragraph, plus a right to possession of the Corresponding Source of the
+  work from the predecessor in interest, if the predecessor has it or can
+  get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the rights
+  granted or affirmed under this License. For example, you may not impose a
+  license fee, royalty, or other charge for exercise of rights granted
+  under this License, and you may not initiate litigation (including a
+  cross-claim or counterclaim in a lawsuit) alleging that any patent claim
+  is infringed by making, using, selling, offering for sale, or importing
+  the Program or any portion of it.
+
+  11. Patents.
+
+  A “contributor” is a copyright holder who authorizes use under this
+  License of the Program or a work on which the Program is based. The work
+  thus licensed is called the contributor's “contributor version”.
+
+  A contributor's “essential patent claims” are all patent claims owned or
+  controlled by the contributor, whether already acquired or hereafter
+  acquired, that would be infringed by some manner, permitted by this
+  License, of making, using, or selling its contributor version, but do not
+  include claims that would be infringed only as a consequence of further
+  modification of the contributor version. For purposes of this definition,
+  “control” includes the right to grant patent sublicenses in a manner
+  consistent with the requirements of this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+  patent license under the contributor's essential patent claims, to make,
+  use, sell, offer for sale, import and otherwise run, modify and propagate
+  the contents of its contributor version.
+
+  In the following three paragraphs, a “patent license” is any express
+  agreement or commitment, however denominated, not to enforce a patent
+  (such as an express permission to practice a patent or covenant not to
+  sue for patent infringement). To “grant” such a patent license to a party
+  means to make such an agreement or commitment not to enforce a patent
+  against the party.
+
+  If you convey a covered work, knowingly relying on a patent license, and
+  the Corresponding Source of the work is not available for anyone to copy,
+  free of charge and under the terms of this License, through a publicly
+  available network server or other readily accessible means, then you must
+  either (1) cause the Corresponding Source to be so available, or (2)
+  arrange to deprive yourself of the benefit of the patent license for this
+  particular work, or (3) arrange, in a manner consistent with the
+  requirements of this License, to extend the patent license to downstream
+  recipients. “Knowingly relying” means you have actual knowledge that, but
+  for the patent license, your conveying the covered work in a country, or
+  your recipient's use of the covered work in a country, would infringe
+  one or more identifiable patents in that country that you have reason
+  to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+  arrangement, you convey, or propagate by procuring conveyance of, a
+  covered work, and grant a patent license to some of the parties receiving
+  the covered work authorizing them to use, propagate, modify or convey a
+  specific copy of the covered work, then the patent license you grant is
+  automatically extended to all recipients of the covered work and works
+  based on it.
+
+  A patent license is “discriminatory” if it does not include within the
+  scope of its coverage, prohibits the exercise of, or is conditioned on
+  the non-exercise of one or more of the rights that are specifically
+  granted under this License. You may not convey a covered work if you are
+  a party to an arrangement with a third party that is in the business of
+  distributing software, under which you make payment to the third party
+  based on the extent of your activity of conveying the work, and under
+  which the third party grants, to any of the parties who would receive the
+  covered work from you, a discriminatory patent license (a) in connection
+  with copies of the covered work conveyed by you (or copies made from
+  those copies), or (b) primarily for and in connection with specific
+  products or compilations that contain the covered work, unless you
+  entered into that arrangement, or that patent license was granted, prior
+  to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting any
+  implied license or other defenses to infringement that may otherwise be
+  available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+  otherwise) that contradict the conditions of this License, they do not
+  excuse you from the conditions of this License. If you cannot use,
+  propagate or convey a covered work so as to satisfy simultaneously your
+  obligations under this License and any other pertinent obligations, then
+  as a consequence you may not use, propagate or convey it at all. For
+  example, if you agree to terms that obligate you to collect a royalty for
+  further conveying from those to whom you convey the Program, the only way
+  you could satisfy both those terms and this License would be to refrain
+  entirely from conveying the Program.
+
+  13. Offering the Program as a Service.
+
+  If you make the functionality of the Program or a modified version
+  available to third parties as a service, you must make the Service Source
+  Code available via network download to everyone at no charge, under the
+  terms of this License. Making the functionality of the Program or
+  modified version available to third parties as a service includes,
+  without limitation, enabling third parties to interact with the
+  functionality of the Program or modified version remotely through a
+  computer network, offering a service the value of which entirely or
+  primarily derives from the value of the Program or modified version, or
+  offering a service that accomplishes for users the primary purpose of the
+  Program or modified version.
+
+  “Service Source Code” means the Corresponding Source for the Program or
+  the modified version, and the Corresponding Source for all programs that
+  you use to make the Program or modified version available as a service,
+  including, without limitation, management software, user interfaces,
+  application program interfaces, automation software, monitoring software,
+  backup software, storage software and hosting software, all such that a
+  user could run an instance of the service using the Service Source Code
+  you make available.  
+
+  14. Revised Versions of this License.
+
+  MongoDB, Inc. may publish revised and/or new versions of the Server Side
+  Public License from time to time. Such new versions will be similar in
+  spirit to the present version, but may differ in detail to address new
+  problems or concerns.
+
+  Each version is given a distinguishing version number. If the Program
+  specifies that a certain numbered version of the Server Side Public
+  License “or any later version” applies to it, you have the option of
+  following the terms and conditions either of that numbered version or of
+  any later version published by MongoDB, Inc. If the Program does not
+  specify a version number of the Server Side Public License, you may
+  choose any version ever published by MongoDB, Inc.
+
+  If the Program specifies that a proxy can decide which future versions of
+  the Server Side Public License can be used, that proxy's public statement
+  of acceptance of a version permanently authorizes you to choose that
+  version for the Program.
+
+  Later license versions may give you additional or different permissions.
+  However, no additional obligations are imposed on any author or copyright holder
+  as a result of your choosing to follow a later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+  APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS 
+  AND/OR OTHER PARTIES PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY
+  OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+  IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+  ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+  
+  16. Limitation of Liability.
+  
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+  WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+  THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING
+  ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF
+  THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO
+  LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU
+  OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+  PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGES.
+  
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided above
+  cannot be given local legal effect according to their terms, reviewing
+  courts shall apply local law that most closely approximates an absolute
+  waiver of all civil liability in connection with the Program, unless a
+  warranty or assumption of liability accompanies a copy of the Program in
+  return for a fee.
+  
+                        END OF TERMS AND CONDITIONS

package/README.md

@@ -1,3 +1,65 @@
-# Temporary Holding Version
+# @melite/harness-provisioner
 
-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.
+The provisioner mounts the Melite estate into a vanilla DSH installation and
+renders ready-to-boot profiles. It is an integrator, not a gateway or a
+second application.
+
+## What it mounts
+
+The workspace-linked bundle mounts the estate host row and its DSH surfaces:
+
+| Surface | Current package |
+| --- | --- |
+| Estate composition | `@melite-plugin/dsh-estate` |
+| Tool plane | `@melite/harness-tools` |
+| Card view | `@melite-plugin/dsh-card-view` |
+| Card deck | `@melite-plugin/dsh-card-deck` |
+| Gallery | `@melite-plugin/dsh-gallery` |
+| Card and model packages | linked through the estate and engine packages |
+
+The package's own `cordis.patch.yml` and the packages' self-registration rows
+own the Cordis composition. This README does not duplicate those rows.
+
+## Render profiles
+
+```sh
+node packages/harness/provisioner/bin/infer-provision.mjs all
+node packages/harness/provisioner/bin/infer-provision.mjs profile inference
+node packages/harness/provisioner/bin/infer-provision.mjs profile headless --dsh-home /tmp/melite-dsh
+```
+
+`all` renders `inference`, `headless`, `estate`, and `melite-test`, then runs
+pnpm in each rendered profile. The output is machine-local state; the source
+of truth is this package and the workspace.
+
+## Interfaces
+
+- `inference` and `melite-test` mount the web app and the browser card UI.
+- `headless` mounts the DSH headless app. `MELITE_HEADLESS=1` selects the
+  delegated run interface.
+- `estate` mounts the SDK app and the headless tool interface.
+
+The tool transport is in-process through the mounted estate row. Do not add a
+`MELITE_GATEWAY` setting or a second HTTP service.
+
+## Requirements
+
+- Node.js and pnpm;
+- a DSH installation with the referenced DSH packages available;
+- a checkout whose workspace links are installed.
+
+For framework changes, obtain the external DSH reference checkout described
+in [`../../../references/README.md`](../../../references/README.md). The rendered
+profile is not a substitute for reading that reference.
+
+## Verification
+
+```sh
+pnpm --dir packages/harness/provisioner exec infer-provision profile headless --dsh-home /tmp/melite-dsh
+pnpm run test
+pnpm run lint
+```
+
+The profile renderer and its package links are the source of truth for profile
+membership; the current documentation index points here for the operator
+workflow.

package/bin/infer-provision.mjs

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+/**
+ * infer-provision — profile provisioner for vanilla DSH installs.
+ *
+ * The bundle patch (cordis.patch.yml) covers the ROWS; this bin covers
+ * the PROFILES: renders ready-to-boot profile dirs (inference /
+ * headless / estate / melite-test) and installs their link deps.
+ * Self-locating — every path derives from this file's own location
+ * (the provisioner package and its siblings), so a family re-split
+ * or repo move changes nothing.
+ *
+ * Usage:
+ *   infer-provision all                    # render + install every profile
+ *   infer-provision profile <name>         # render one profile dir
+ *   infer-provision preset                 # install the agent preset
+ * Flags:
+ *   --dsh-home <dir>   default $DSH_HOME || ~/.dsh
+ *
+ * Rendered profiles mount the SAME rows the bundle patch mounts (the
+ * profile's cordis.patch.yml user layer stays EMPTY by design — the
+ * bundle owns the rows, so `dsh plugin add` and rendered profiles can
+ * never drift apart). The template pins: our bundle + the dsh web base
+ * for 'inference', the plain headless base for 'headless'.
+ */
+
+import { execSync } from 'node:child_process'
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import process from 'node:process'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+const PROVISIONER = dirname(HERE) // bin/ -> the provisioner package itself
+
+// ── args ────────────────────────────────────────────────────────────────
+const argv = process.argv.slice(2)
+const cmd = argv[0] || 'all'
+const flag = (name, dflt) => {
+  const i = argv.indexOf(name)
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : dflt
+}
+const DSH_HOME = flag('--dsh-home', process.env.DSH_HOME || join(process.env.HOME || '~', '.dsh'))
+const PROFILE = argv[1] && !argv[1].startsWith('--') ? argv[1] : 'inference'
+
+const log = (...a) => console.log(...a)
+const die = (msg) => { console.error('infer-provision: ' + msg); process.exit(1) }
+
+// ── profile rendering ───────────────────────────────────────────────────
+const PROFILE_BASES = {
+  // inference = the studio: web app base + the SELF-REGISTERING
+  
+  // its existence row in ITS OWN package — the provisioner stopped
+  
+  // every FRESH boot of profiles mounting both patches).
+  // anny LEFT the web bases (stroke 89): its studio died — the form
+  // card rides the engine-plane SSOT only, never a browser bundle.
+  
+  // its bundle patch mounts the null host row that materializes
+  // @melite/card-base/client for the browser graph — every card
+  // client externalizes it, and without the row the loader's
+  // require misses the module table at web boot.
+  inference: ['@deepseek-ai/dsh-base', '@deepseek-ai/dsh-web-app', '@melite/harness-provisioner',
+    '@melite/harness-tools', '@melite/card-base', '@melite-plugin/dsh-card-view', '@melite-plugin/dsh-card-deck',
+    '@melite-plugin/dsh-gallery'],
+  // headless = the agent server: one-shot task runner + the tools
+  // plane (harness-tools self-registers its melite-tools row; the
+  // renderer disables the web-plane doors row in this mount).
+  // dsh-estate rides here too: a headless task that composes media
+  // reaches the same runs/queue/drafts seats through melite_flow —
+  // without the bundle the tool answers ABSENCE (the estate-drive
+  
+  // unpinned queue seat refuses loud by design).
+  headless: ['@deepseek-ai/dsh-base', '@deepseek-ai/dsh-headless', '@melite/harness-provisioner',
+    '@melite/harness-tools', '@melite-plugin/dsh-estate'],
+  // estate = the job server: the SDK JSON-RPC base (estate-drive
+  
+  // in-process — no second app, no HTTP). dsh-estate bundles the
+  // runs/queue/drafts seats — without it melite_flow answers
+  // ABSENCE ("no seat of that family is mounted on this lane"),
+  
+  // tools row's HEADLESS interface by its self-registration id.
+  estate: ['@deepseek-ai/dsh-base', '@deepseek-ai/dsh-sdk-app', '@melite/harness-provisioner',
+    '@melite/harness-tools', '@melite-plugin/dsh-estate'],
+  // melite-test = THE TEST LANE, RE-COMPOSED (REBUILD-20, gateway
+  
+  // melite-test profile mounting the estate API as a SECOND
+  // process on :33081) died with the gateway. Its replacement is
+  // the SAME row set as the studio — web app base + the estate
+  // rows in ONE process. Custom bakes serve from this name; the
+  // :33081 wire never existed here.
+  'melite-test': ['@deepseek-ai/dsh-base', '@deepseek-ai/dsh-web-app', '@melite/harness-provisioner',
+    '@melite/harness-tools', '@melite/card-base', '@melite-plugin/dsh-card-view', '@melite-plugin/dsh-card-deck',
+    '@melite-plugin/dsh-gallery'],
+}
+
+/** Maps every workspace package's name to its directory by reading
+ *  this repository's pnpm-workspace.yaml globs (the manifest's
+ *  workspace:* specs are names; pnpm resolves them only inside an
+ *  install — the profile dir is its own install, so the renderer
+ *  resolves them itself). @returns Map<name, absolute dir> */
+function workspacePackages() {
+  const root = resolve(PROVISIONER, '../../..')
+  const wsFile = join(root, 'pnpm-workspace.yaml')
+  const out = new Map()
+  if (!existsSync(wsFile)) return out
+  const globs = [...readFileSync(wsFile, 'utf8').matchAll(/^\s*-\s*['"]?([^'"\s#]+)/gm)]
+    .map((m) => m[1]).filter((g) => !g.startsWith('!'))
+  const seg = (g) => g.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*\*\/?/g, '(?:.*/)?').replace(/\*/g, '[^/]*')
+  const prefixes = [...new Set(globs.map((g) => g.split('*')[0]))]
+    .filter((p, i, a) => !a.some((q) => q !== p && p.startsWith(q)))
+  for (const g of globs) {
+    const re = new RegExp('^' + seg(g) + '$')
+    for (const prefix of prefixes) {
+      const base = join(root, prefix)
+      if (!existsSync(base)) continue
+      const walk = (dir, depth) => {
+        let entries = []
+        try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return }
+        for (const e of entries) {
+          if (!e.isDirectory() || e.name === 'node_modules') continue
+          const full = join(dir, e.name)
+          const rel = full.slice(root.length + 1)
+          if (re.test(rel)) {
+            const pj = join(full, 'package.json')
+            if (existsSync(pj)) {
+              try { out.set(JSON.parse(readFileSync(pj, 'utf8')).name, full) } catch { /* not a package */ }
+            }
+          }
+          if (depth < 8) walk(full, depth + 1)
+        }
+      }
+      walk(base, 0)
+    }
+  }
+  return out
+}
+
+function renderProfile(name) {  // In-box bundles (@deepseek-ai/*) resolve from the DSH INSTALL, never
+  // from a registry - only OUR link goes in dependencies. Mirrors what
+  // `dsh plugin` itself initializes (PROFILE_TEMPLATES + reconcile).
+  const bundles = PROFILE_BASES[name] || PROFILE_BASES.headless
+  const dst = join(DSH_HOME, 'profiles', name)
+  mkdirSync(dst, { recursive: true })
+  const link = 'link:' + PROVISIONER
+
+  // pnpm does NOT materialize a link: dependency's OWN link:/workspace
+  // deps — every plugin package the bundle rows name must become a
+  // DIRECT link: dep here. The provisioner's manifest declares them
+  // as workspace:* specs; a link:-only scan dropped them, so the
+  // headless/estate profiles mounted @melite/harness-tools as a
+  // bundle row with NO installed package — the tool lane could not
+  // load (ledger li-headless-profile-deps). workspace specs resolve
+  // by scanning this repository's own pnpm workspace globs
+  // (self-locating; a family re-split moves nothing).
+  const provPkg = JSON.parse(readFileSync(join(PROVISIONER, 'package.json'), 'utf8'))
+  const rowDeps = {}
+  const byName = workspacePackages()
+  for (const [depName, spec] of Object.entries(provPkg.dependencies || {})) {
+    const s = String(spec)
+    if (s.startsWith('link:')) {
+      rowDeps[depName] = 'link:' + resolve(PROVISIONER, s.slice(5))
+    } else if (byName.has(depName)) {
+      rowDeps[depName] = 'link:' + byName.get(depName)
+    }
+    // Registry specs (e.g. the lane-brain adapter @deepseek-ai/dsh-llm-pi-ai)
+    // are deliberately NOT pinned here: the profile package.json is
+    // link:-only by contract (the render wall proves the trailing
+    // `pnpm install` stays offline-safe). A registry dep rides through
+    // its OWNING package's own manifest — the provisioner declares it,
+    // the provisioner is linked, its install resolves it in the repo
+    // workspace.
+  }
+
+  const pkgPath = join(dst, 'package.json')
+  let pkg = { name: 'dsh-profile-' + name, private: true, dependencies: {} }
+  if (existsSync(pkgPath)) {
+    try { pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) } catch { /* re-render */ }
+  }
+  pkg.name = pkg.name || 'dsh-profile-' + name
+  pkg.private = true
+  
+  // never merged — the renderer owns this file wholesale (same law as
+  // the rows: "the bundle owns every row, no drift"). The old merge kept
+  // fossil link: rows from pre-reorg renders (plugins/harness/dsh/…),
+  // and pnpm warned "installing a dependency from a non-existent
+  // directory" on every install while the profile silently carried
+  
+  // on every render; user-added registry deps belong in the bundle, not
+  // here.
+  pkg.dependencies = { ...rowDeps, '@melite/harness-provisioner': link }
+  
+  // twin rows for the self-registering packages (channel law
+  
+  // their rows; the twins double-mounted the tool plane and killed
+  // every FRESH boot: "tool melite_discover is already
+  // registered"). Direct bundles are THE mount now; nothing is
+  // dropped when the provisioner joins.
+  // THE BUNDLES LIST IS REGENERATED, never merged (stroke 89,
+  
+  // the old union kept RETIRED bundles mounted forever (anny's
+  // studio row crash-booted every fresh compose with "cannot
+  // resolve profile bundle @melite/3d-anny" after the package left
+  // the bases). The bases OWN this list wholesale; a retired
+  // package leaves the profile the day it leaves PROFILE_BASES.
+  pkg.dsh = { profile: { bundles: [...new Set(bundles)] } }
+  writeFileSync(join(dst, 'package.json'), JSON.stringify(pkg, null, 2) + String.fromCharCode(10))
+  // user layer stays EMPTY in web mounts — the bundle patch owns every
+  // row (no drift). NON-web mounts (headless/SDK) get the web-surface
+  // rows mechanically DISABLED (by the packages' SELF-REGISTRATION
+  
+  // The bundle owns the rows; the renderer owns the per-app mount
+  // shape.
+  const webMount = bundles.includes('@deepseek-ai/dsh-web-app')
+  // melite-tools-doors is web-profiles-only by its own contract (the
+  // ✦ doors need webServer+llm — absent in sdk/headless mounts); the
+  // renderer disables it with the other web rows in non-web mounts.
+  const webRows = ['melite-tools-doors',
+                   'infer-card-view', 'ray-card-deck', 'infer-gallery']
+  writeFileSync(join(dst, 'cordis.patch.yml'),
+    webMount
+      ? '# rendered by infer-provision - rows live in the bundle' + '\n' + '[]' + '\n'
+      : '# rendered by infer-provision - rows live in the bundle.\n'
+        + '# No webServer service in this mount: the four web-surface rows\n'
+        + '# are disabled so activation cannot pend forever.\n'
+        + webRows.map(id => '- id: ' + id + '\n  disabled: true\n').join('')
+        // ESTATE JOB SERVER (name === 'estate'): this mount IS the
+        // delegated operator — the tools row selects the HEADLESS
+        // interface (the melite_flow + run_status run doors). Pinned
+        // in the render (not ambient env) because the interface is
+        // profile state: browser mounts compose, the job server
+        // executes. Every other mount keeps the browser default.
+        + (name === 'estate'
+          ? '# HEADLESS interface: the delegated operator runs jobs here.\n'
+            + '- id: melite-tools\n  config:\n    headless: true\n'
+          : ''))
+  writeFileSync(join(dst, 'cordis.yml'), '# rendered by infer-provision' + '\n' + '[]' + '\n')
+  const ws = join(dst, 'pnpm-workspace.yaml')
+  if (!existsSync(ws)) writeFileSync(ws, 'packages:' + '\n' + '  - node_modules/*' + '\n')
+
+  log('rendered profile :', dst)
+  log('  bundles        :', bundles.join(', '))
+  return dst
+}
+
+function installDeps(profileDir) {
+  const pm = execSync('command -v pnpm || true').toString().trim()
+    || join(process.env.HOME || '', '.local/share/pnpm/pnpm')
+  if (!existsSync(pm)) {
+    log('  WARNING: pnpm not found — run manually: (cd ' + profileDir + ' && pnpm install)')
+    return false
+  }
+  log('  installing deps with', pm, '…')
+  execSync('"' + pm + '" install', { cwd: profileDir, stdio: 'inherit' })
+  return true
+}
+
+// ── main ────────────────────────────────────────────────────────────────
+switch (cmd) {
+  case 'all': {
+    
+    
+    // longer exists, so `all` hard-failed at "preset source missing".
+    // Presets are operator-managed now (~/.dsh/.agent-presets); this
+    // command renders + installs every profile (the gateway health
+    // check died with the gateway — there is no second process to
+    // probe anymore).
+    for (const name of ['inference', 'headless', 'estate', 'melite-test']) {
+      installDeps(renderProfile(name))
+    }
+    log('boot with:')
+    log('  LANES BOOT ONLY THROUGH THE PROVISION (the lane law, li-bu):')
+    log('  ~/Documents/programs/active/dsh-provision/apply.sh launch --lane <name>')
+    log('  (this command installs the profiles; the sibling provisioner owns the')
+    log('   launch — binary pin, version floor, home, and unit. The shapes below')
+    log('   are what the door runs UNDER THE HOOD, never a hand-run shortcut:)')
+    log('  dsh --profile inference              # the studio GUI')
+    log('  dsh --profile headless "<task>"      # one-shot agent with card tools')
+    log('  dsh --profile estate                 # the SDK job server (estate row)')
+    log('  dsh --profile melite-test            # the TEST lane (one process, no :33081)')
+    break
+  }
+  case 'profile': {
+    installDeps(renderProfile(PROFILE))
+    log('boot with: dsh --profile ' + PROFILE + (PROFILE === 'inference' ? '' : ' "<task>"'))
+    break
+  }
+  // the `preset` arm died with installPreset (undefined since the
+  
+  // reads ~/.dsh/.agent-presets — refuse LOUD instead of a
+  // ReferenceError
+  default: die('unknown command ' + JSON.stringify(cmd) + ' — use all | profile <name>')
+}

package/cordis.patch.yml

@@ -0,0 +1,129 @@
+# @melite/harness-provisioner — the vanilla-DSH mount surface for the
+# inference.cpp media stack.
+#
+# Installing this bundle into ANY profile (dsh plugin --profile <name>
+# add <repo>/packages/harness/dsh/provisioner) mounts:
+#
+#   infer-tools          the tool registry, TWO interfaces (profile
+#                        config / MELITE_HEADLESS selects): BASE = discovery
+#                        (melite_discover, melite_load), the bench
+#                        (melite_construct), management (comfy_manage),
+#                        craft (skill_index, skill_read), audit
+#                        (ledger_tail); HEADLESS adds the run doors
+#                        melite_flow / run_status (queue-native).
+#                        enhance_prompt is AD HOC (MELITE_ADHOC), never base.
+#   infer-card-view-*    editable action cards rendered in the
+#                        conversation (host row serves the editor bundle
+#                        + hydrates drafts; client row renders tiles).
+#   infer-card-deck      the sidebar card deck (lanes, drafts, past cards).
+#   infer-media          DELETED (R3, the estate collapse) — DSH's own
+#                        file/attachment/resource faces are the media
+#                        system (the row below is the tombstone comment).
+#   infer-gallery-host   the runs gallery (in-tree seats, or the pinned
+#                        owning DSH cross-host).
+#
+# All rows resolve BY PACKAGE NAME through this bundle's own link:
+# dependencies (pnpm workspace links back into the repo) — never baked
+# absolute paths, so the repo can move without re-provisioning.
+#
+
+# is the ONLY app — there is no second process, no :33081, no
+# MELITE_GATEWAY override. The tools answer in-process over the
+# estate row's ctx seats; cross-host reads pin the ONE DSH that
+# owns the estate state. The runs/drafts/bench faces ride Typert
+# remotes where the estate bundle is mounted.
+#
+# PROFILE-SHAPE PIN (progressive disclosure — dev_docs/deployment/
+# dsh-profiles.md): the HOST `skill-filesystem` row is pinned OFF for
+# every profile this bundle mounts. That row auto-discovers workspace
+# skills and ships their descriptions into the agent context unbidden —
+# the pre-loaded-surface bug the disclosure ladder retires. Discovery
+# here is the estate's own surface (melite_discover →
+# melite_load → skill_read), never a pre-loaded catalog. The pin
+# silences the HOST layer only: a preset that genuinely wants local
+# skill discovery still mounts its OWN preset-layer row. Without this
+# pin the headless profile auto-injects (only dsh-web-app disables the
+# host row, and headless does not bundle it). The row below is an
+# OVERRIDE (column-0 `- id:`, no `insert:`): it patches the dsh-base
+# row and mounts nothing.
+
+- id: skill-filesystem
+  disabled: true
+
+# infer-estate: NO row here (channel law: every web plugin owns its
+# existence row in ITS OWN package — the dsh-estate cordis.patch.yml
+# inserts melite-estate, the runs plane as host services: card
+# registry, runs registry, and the Typert adapters). A twin row here
+# double-mounted the package and its registrations ("melite_discover
+# already registered") killing every fresh boot.
+
+- insert:
+    # infer-tools / infer-tools-doors: NO rows here (channel law,
+
+    # package — the melite-tools cordis.patch.yml inserts
+    # melite-tools + melite-tools-doors). Twin rows under different
+    # ids double-mounted the package and its tool registrations
+    # ("melite_discover already registered") killing every FRESH
+
+    # Profiles needing the tools WITHOUT bundling the package
+    # activate it with `dsh plugin --profile <name> add
+    # <path-to-melite-tools>`.
+
+
+    # web plugin owns its existence row in ITS OWN package — the
+    # dsh-card-view cordis.patch.yml inserts it; a row in BOTH files
+    # duplicated the loader entry id and killed every FRESH boot of
+
+
+
+    # each card package ships its OWN cards.stage.view registration —
+    # a new card never touches the bench host (the DSH plugin
+    # contract). The rows mount the packages' root faces (the browser
+    # graph's dsh.client scan needs bare-root entries); their tool
+    # registrations stay gated on the registrar-threaded EstateCall
+    # seam, so a row-mount registers nothing node-side. The studios
+    # ride the packages' dsh.client declarations (src/client ->
+    # lib/client.js).
+    #
+    # card-studio-anny: NO row here — @melite/3d-anny self-registers
+    # (anny-studio, its own cordis.patch.yml, 6a16cfc9); a twin row
+    # double-mounted the package in every profile bundling it
+
+    # profile (their self-patch never applies there).
+
+    # card-studio-h3-timeline: NO row here — @melite/video-h3-timeline
+    # self-registers (its own cordis.patch.yml); a twin row here
+    # double-mounted the package in every profile bundling both
+    # (same crash law as card-studio-anny).
+
+    # card-studio-ideogram4 RETIRED with its card (the form-seams
+
+    # the row at the next provision)
+
+    - id: card-studio-img-to-mesh
+      name: '@melite/3d-img-to-mesh'
+
+    # mask-studio RETIRED at parity (stroke 75, CONTRACT D): the
+    # loader entry and the row are gone — mask owns the mask
+    # surface; the package survives as the paint leaf-face carrier
+    # (ui/), unmounted.
+
+    # card-studio-motion: NO row here — @melite/motion-motion
+    # self-registers (its own cordis.patch.yml); a twin row here
+    # double-mounted the package in every profile bundling both
+    # (same crash law as card-studio-anny).
+
+
+
+    # dsh-card-deck package self-registers (ray-card-deck, its own
+    # cordis.patch.yml); twin rows double-mounted the package in
+
+
+    # THE ESTATE COLLAPSE (R3): @infer-media/dsh-media DELETED - DSH's
+    # own file/attachment/resource faces are the media system; the
+    # estate's runs/drafts ride Typert remotes (gateway-wire).
+
+
+    # dsh-gallery package self-registers (infer-gallery, its own
+    # cordis.patch.yml); twin rows double-mounted the package in
+

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export declare const PROVISIONER_NAME = "@melite/harness-provisioner";
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,10 @@
+// index.ts — @melite/harness-provisioner's import-safe library door.
+//
+// The package's imperative surface is the bin (bin/infer-provision.mjs:
+// renders ready-to-boot profiles into a DSH_HOME) and its Cordis rows
+// (cordis.patch.yml, mounted by the host runtime). Neither is
+// import-safe — the bin executes its argv switch at load — so the "."
+// exports row lands here instead: the package identity, no imports, no
+// side effects, importable under plain Node from a bare extract.
+export const PROVISIONER_NAME = '@melite/harness-provisioner';
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@melite/harness-provisioner",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.4-alpha",
+  "license": "SSPL-1.0",
+  "description": "Vanilla-DSH provisioner for the inference.cpp media stack: one bundle mounts the estate row (in-process seats, no second process), the tool surface, the card view/deck, media previews, and the runs gallery — and the infer-provision bin renders ready-to-boot profiles (inference / headless / estate / melite-test) into any DSH_HOME.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/**/*.js",
+    "lib/**/*.d.ts",
+    "bin/infer-provision.mjs",
+    "cordis.patch.yml"
+  ],
+  "bin": {
+    "infer-provision": "./bin/infer-provision.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-llm-pi-ai": "0.2.0-rc.2",
+    "@melite-plugin/dsh-estate": "0.1.4-alpha",
+    "@melite-plugin/dsh-card-deck": "0.1.4-alpha",
+    "@melite-plugin/dsh-card-view": "0.1.4-alpha",
+    "@melite/motion-motion": "0.1.4-alpha",
+    "@melite-plugin/dsh-gallery": "0.1.4-alpha",
+    "@melite/harness-tools": "0.1.4-alpha",
+    "@melite/3d-img-to-mesh": "0.1.4-alpha",
+    "@melite/video-h3-timeline": "0.1.4-alpha"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "engines": {
+    "dsh": ">=0.1.1-rc.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh": ">=0.2.0-rc.1 <0.3.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}